1 files changed, 49 insertions, 62 deletions

diff --git a/new-luxc/test/test/luxc/lang/translation/reference.lux b/new-luxc/test/test/luxc/lang/translation/reference.lux
index 4aaed8124..a10e98ae6 100644
--- a/new-luxc/test/test/luxc/lang/translation/reference.lux
+++ b/new-luxc/test/test/luxc/lang/translation/reference.lux
@@ -1,61 +1,48 @@
 (.module:
-  lux
-  (lux (control [monad #+ do]
-                pipe)
-       (data ["e" error]
-             [text])
-       (lang ["//." synthesis])
-       ["r" math/random]
-       test)
-  (luxc (lang (translation (jvm [".T_jvm" statement])
-                           ## (js [".T_js" statement])
-                           ## (lua [".T_lua" statement])
-                           ## (ruby [".T_ruby" statement])
-                           ## (python [".T_python" statement])
-                           ## (r [".T_r" statement])
-                           ## (scheme [".T_scheme" statement])
-                           ## (common-lisp [".T_common-lisp" statement])
-                           ## (php [".T_php" statement])
-                           )))
-  (test/luxc common))
+  [lux #*
+   [control
+    [monad (#+ do)]
+    pipe]
+   [data
+    ["e" error]
+    ["." text]]
+   [compiler
+    [default
+     ["." reference]
+     [phase
+      ["." synthesis]]]]
+   [math
+    ["r" random]]
+   test]
+  [test
+   [luxc
+    ["." common (#+ Runner Definer)]]]
+  [//
+   ["&" function]])
 
 (def: name-part
   (r.Random Text)
-  (|> (r.ascii +5)
-      (r.filter (function (_ sample)
-                  (not (or (text.contains? "/" sample)
-                           (text.contains? "[" sample)
-                           (text.contains? "]" sample)))))))
+  (r.ascii/alpha 5))
 
 (def: (definitions-spec define)
   (-> Definer Test)
   (do r.Monad<Random>
-    [def-name (r.seq name-part name-part)
-     def-value r.int]
+    [name (r.and name-part name-part)
+     value r.frac]
     (test "Can refer to definitions."
-          (|> (define def-name (//synthesis.i64 def-value))
-              (case> (#e.Success valueT)
-                     (i/= def-value (:coerce Int valueT))
-
-                     (#e.Error error)
-                     (exec (log! error)
-                       #0))))))
+          (|> (define name (synthesis.f64 value))
+              (&.check value)))))
 
 (def: (variables-spec run)
   (-> Runner Test)
   (do r.Monad<Random>
-    [register (|> r.nat (:: @ map (n/% +100)))
-     value r.int]
+    [register (|> r.nat (:: @ map (n/% 100)))
+     value r.frac]
     (test "Can refer to local variables/registers."
-          (|> (run (//synthesis.branch/let [(//synthesis.i64 value)
-                                            register
-                                            (//synthesis.variable/local register)]))
-              (case> (#e.Success outputT)
-                     (i/= value (:coerce Int outputT))
-
-                     (#e.Error error)
-                     (exec (log! error)
-                       #0))))))
+          (|> (run (synthesis.branch/let [(synthesis.f64 value)
+                                          register
+                                          (synthesis.variable/local register)]))
+              (&.check value)))))
 
 (def: (references-spec run define)
   (-> Runner Definer Test)
@@ -63,37 +50,37 @@
        (variables-spec run)))
 
 (context: "[JVM] References."
-  (<| (times +100)
-      (references-spec run-jvm def-jvm)))
+  (<| (times 100)
+      (references-spec common.run-jvm common.def-jvm)))
 
 ## (context: "[JS] References."
-##   (<| (times +100)
-##       (references-spec run-js def-js)))
+##   (<| (times 100)
+##       (references-spec common.run-js common.def-js)))
 
 ## (context: "[Lua] References."
-##   (<| (times +100)
-##       (references-spec run-lua def-lua)))
+##   (<| (times 100)
+##       (references-spec common.run-lua common.def-lua)))
 
 ## (context: "[Ruby] References."
-##   (<| (times +100)
-##       (references-spec run-ruby def-ruby)))
+##   (<| (times 100)
+##       (references-spec common.run-ruby common.def-ruby)))
 
 ## (context: "[Python] References."
-##   (<| (times +100)
-##       (references-spec run-python def-python)))
+##   (<| (times 100)
+##       (references-spec common.run-python common.def-python)))
 
 ## (context: "[R] References."
-##   (<| (times +100)
-##       (references-spec run-r def-r)))
+##   (<| (times 100)
+##       (references-spec common.run-r common.def-r)))
 
 ## (context: "[Scheme] References."
-##   (<| (times +100)
-##       (references-spec run-scheme def-scheme)))
+##   (<| (times 100)
+##       (references-spec common.run-scheme common.def-scheme)))
 
 ## (context: "[Common Lisp] References."
-##   (<| (times +100)
-##       (references-spec run-common-lisp def-common-lisp)))
+##   (<| (times 100)
+##       (references-spec common.run-common-lisp common.def-common-lisp)))
 
 ## (context: "[PHP] References."
-##   (<| (times +100)
-##       (references-spec run-php def-php)))
+##   (<| (times 100)
+##       (references-spec common.run-php common.def-php)))