Add tests for eval

[dgr]

Closes #259

[dgr]

Note that this does not test ClojureScript eval, but I need some feedback on the way that I handled the reader conditionalization. Specifically, ClojureScript still includes an eval symbol, so the when-var-exists macro will find it and not print SKIP - eval. Thus, the tests, if any, in the namespace will be executed. I could have conditionalized the whole deftest form but if I had done that, then there would have been no test reported in the ClojureScript output. So, instead, I conditionalized each of the testing blocks inside the deftest form. Thus, ClojureScript sees a deftest that contains no assertions. @jeaye, if you want me to do it another way, I'm happy to adjust it.

[jeaye]

Thus, ClojureScript sees a deftest that contains no assertions. @jeaye, if you want me to do it another way, I'm happy to adjust it.

This is how I'd do it, too. All good.

[jeaye]

Oh, actually, can we just have one reader conditional, as a top-level do which is nil for CLJS?

[jeaye]

Thanks, Dave!

[jeaye]

Note that both of these are macros and not special forms. That's not to say this is wrong, it's just not exactly testing what's commented. let* and loop* are the special forms, which would work just as well here. The macros just add destructuring support.

[dgr]

Hm. I relied on https://clojure.org/reference/special_forms for the list of special forms. And the doc strings for both let and loop say they are special forms. For example:

user> (doc loop)
-------------------------
clojure.core/loop
  (loop [bindings*] exprs*)
([bindings & body])
Special Form
  Evaluates the exprs in a lexical context in which the symbols in
  the binding-forms are bound to their respective init-exprs or parts
  therein. Acts as a recur target.

  Please see http://clojure.org/special_forms#loop

and

user> (doc let)
-------------------------
clojure.core/let
  (let [bindings*] exprs*)
([bindings & body])
Special Form
  binding => binding-form init-expr
  binding-form => name, or destructuring-form
  destructuring-form => map-destructure-form, or seq-destructure-form

  Evaluates the exprs in a lexical context in which the symbols in
  the binding-forms are bound to their respective init-exprs or parts
  therein.

  See https://clojure.org/reference/special_forms#binding-forms for
  more information about destructuring.

  Please see http://clojure.org/special_forms#let
Spec
  args: (cat :bindings :clojure.core.specs.alpha/bindings :body (* any?))
  ret: any?

[jeaye]

What about an infinite seq?

[dgr]

What are you trying to test with that? That it doesn't get realized?

[dgr]

So, eval'ing an infinite range returns a clojure.lang.Iterate object. I'm not even sure what that is.

user> (class (eval '(range)))
clojure.lang.Iterate

What are you wanting to test with that?

[dgr]

Interestingly, eval'ing a fixed range returns a clojure.lang.LongRange:

user> (class (eval '(range 10)))
clojure.lang.LongRange

[jeaye]

What are you trying to test with that? That it doesn't get realized?

Yep.

So, eval'ing an infinite range returns a clojure.lang.Iterate object. I'm not even sure what that is.

That's the type of (range).

Interestingly, eval'ing a fixed range returns a clojure.lang.LongRange:

LongRange was the type that went in. The Long is because each value is a Long (i.e. 10 is a Long).

So, eval clearly doesn't realize the seq, from the behavior. That's a great test case to have.

[dgr]

So, how do I test for not being realized, exactly? Is it just that I get something back at all, because if it tried to realize the infinite sequence it would wait until the full sequence was realized and finally throw and OOM exception?

[jeaye]

Exactly. If we get it back and continue running the test, we can know that it wasn't realized.

[dgr]

OK, I'll add this.

[dgr]

I think this is good to go now.

[jeaye]

Great work, Dave!