[plt-dev] Stepper tests for DeinProgramm language levels?

On Mar 18, 2009, at 5:08 PM, John Clements wrote:

> As part of pre-release testing, I run the tests in plt/collects/ 
> tests/stepper/through-tests... which don't cover any of the  
> deinprogramm language levels.  You clearly have a stake in making  
> sure that the stepper still works for these language levels, so I'm  
> wondering if you'd like to contribute some tests.  Currently, the  
> tests are all in one place--though that could easily change--and  
> they're in one of two formats: my straightforward if somewhat  
> verbose style, and Eli's compact but non-sexp-y flavor.  Here are a  
> couple of examples:
>
> ;; my verbose style
>
> (t1 let2
>     (test-both-ints "(let ([a (+ 4 5)] [b (+ 9 20)]) (+ a b))"
>                     `((before-after ((hilite (let ([a (+ 4 5)] [b (+  
> 9 20)]) (+ a b))))
>                                     ((hilite (define a_0 (+ 4 5)))  
> (hilite (define b_0 (+ 9 20))) (hilite (+ a_0 b_0))))
>                       (before-after ((define a_0 (hilite (+ 4 5)))  
> (define b_0 (+ 9 20)) (+ a_0 b_0))
>                                     ((define a_0 (hilite 9)) (define  
> b_0 (+ 9 20)) (+ a_0 b_0)))
>                       (before-after ((define a_0 9) (define b_0  
> (hilite (+ 9 20))) (+ a_0 b_0))
>                                     ((define a_0 9) (define b_0  
> (hilite 29)) (+ a_0 b_0)))
>                       (before-after ((define a_0 9) (define b_0 29)  
> (+ (hilite a_0) b_0))
>                                     ((define a_0 9) (define b_0 29)  
> (+ (hilite 9) b_0)))
>                       (before-after ((define a_0 9) (define b_0 29)  
> (+ 9 (hilite b_0)))
>                                     ((define a_0 9) (define b_0 29)  
> (+ 9 (hilite 29))))
>                       (before-after ((define a_0 9) (define b_0 29)  
> (hilite (+ 9 29)))
>                                     ((define a_0 9) (define b_0 29)  
> (hilite 38)))
>                       (finished-stepping))))
>
>
> ;; eli's compact style:
>
> (let ([def `(define a5 (lambda (a5) (+ a5 13)))])
>    (t lam-def test-upto-int
>       ,def (a5 23)
>       :: ,def {(a5 23)}
>       -> ,def {(+ 23 13)}
>       -> ,def {36}))
>
>
> Looking at this more closely, the lowest-hanging fruit here would  
> simply be identifying existing tests where the expected result in  
> some DeinProgramm language level is the same as the existing  
> expected result for some test.
>
> I took a quick crack at running a beginner programm in the lowest  
> DeinProgramm level, but the error message suggested that I couldn't  
> define new operations in this language level, so I just gave up :).

I think the DeinProgramm teaching languages just require the explicit  
lambda style of function definition.

Ryan


> Anyhow, if you find time to do this at some point, it would probably  
> increase the reliability of the stepper w.r.t. DeinProgramm.
>
> cc'ing plt-dev, in case anyone else has good suggestions.
>
> John
>
> _________________________________________________
>  For list-related administrative tasks:
>  http://list.cs.brown.edu/mailman/listinfo/plt-dev