aboutsummaryrefslogtreecommitdiff
path: root/stdlib/source/test
diff options
context:
space:
mode:
Diffstat (limited to 'stdlib/source/test')
-rw-r--r--stdlib/source/test/lux.lux151
-rw-r--r--stdlib/source/test/lux/math/number/int.lux63
-rw-r--r--stdlib/source/test/lux/target/js.lux845
3 files changed, 957 insertions, 102 deletions
diff --git a/stdlib/source/test/lux.lux b/stdlib/source/test/lux.lux
index 7026c0a48..c200a0316 100644
--- a/stdlib/source/test/lux.lux
+++ b/stdlib/source/test/lux.lux
@@ -1,72 +1,71 @@
-(.with_expansions [<target>' (.for ["{old}" (.as_is ["[1]/[0]" jvm])
- "JVM" (.as_is ["[1]/[0]" jvm])]
- (.as_is))
- <target> <target>']
- (.using
- [library
- ["/" lux "*"
- [program {"+" program:}]
- ["_" test {"+" Test}]
- ["@" target]
- [abstract
- [monad {"+" do}]]
- [control
- ["[0]" io]
- ["[0]" maybe ("[1]#[0]" functor)]
- [concurrency
- ["[0]" atom {"+" Atom}]]
- [parser
- ["<[0]>" code]]]
- [data
- ["[0]" product]
- ["[0]" bit ("[1]#[0]" equivalence)]
- ["[0]" text ("[1]#[0]" equivalence)
- ["%" format {"+" format}]]
- [collection
- ["[0]" list ("[1]#[0]" functor)]
- ["[0]" set {"+" Set} ("[1]#[0]" equivalence)]
- [dictionary
- ["[0]" plist]]]]
- ["[0]" macro
- [syntax {"+" syntax:}]
- ["[0]" code ("[1]#[0]" equivalence)]
- ["[0]" template]]
- ["[0]" math
- ["[0]" random ("[1]#[0]" functor)]
- [number
- [i8 {"+"}]
- [i16 {"+"}]
- ["n" nat]
- ["i" int]
- ["r" rev]
- ["f" frac]
- ["[0]" i64]]]
- ["[0]" meta
- ["[0]" location ("[1]#[0]" equivalence)]]]]
- ... TODO: Must have 100% coverage on tests.
- ["[0]" / "_"
- ["[1][0]" abstract]
- ["[1][0]" control]
- ["[1][0]" data]
- ["[1][0]" debug]
- ["[1][0]" documentation]
- ["[1][0]" locale]
- ["[1][0]" macro
- ["[1]/[0]" code]]
- ["[1][0]" math]
- ["[1][0]" meta]
- ["[1][0]" program]
- ["[1][0]" static]
- ["[1][0]" target]
- ["[1][0]" test]
- ["[1][0]" time]
- ... ["[1][0]" tool] ... TODO: Update & expand tests for this
- ["[1][0]" type]
- ["[1][0]" world]
- ["[1][0]" ffi]
- ["[1][0]" extension]
- ["[1][0]" target "_"
- <target>]]))
+(.`` (.`` (.using
+ [library
+ ["/" lux "*"
+ [program {"+" program:}]
+ ["_" test {"+" Test}]
+ ["@" target]
+ [abstract
+ [monad {"+" do}]]
+ [control
+ ["[0]" io]
+ ["[0]" maybe ("[1]#[0]" functor)]
+ [concurrency
+ ["[0]" atom {"+" Atom}]]
+ [parser
+ ["<[0]>" code]]]
+ [data
+ ["[0]" product]
+ ["[0]" bit ("[1]#[0]" equivalence)]
+ ["[0]" text ("[1]#[0]" equivalence)
+ ["%" format {"+" format}]]
+ [collection
+ ["[0]" list ("[1]#[0]" functor)]
+ ["[0]" set {"+" Set} ("[1]#[0]" equivalence)]
+ [dictionary
+ ["[0]" plist]]]]
+ ["[0]" macro
+ [syntax {"+" syntax:}]
+ ["[0]" code ("[1]#[0]" equivalence)]
+ ["[0]" template]]
+ ["[0]" math
+ ["[0]" random ("[1]#[0]" functor)]
+ [number
+ [i8 {"+"}]
+ [i16 {"+"}]
+ ["n" nat]
+ ["i" int]
+ ["r" rev]
+ ["f" frac]
+ ["[0]" i64]]]
+ ["[0]" meta
+ ["[0]" location ("[1]#[0]" equivalence)]]]]
+ ... TODO: Must have 100% coverage on tests.
+ ["[0]" / "_"
+ ["[1][0]" abstract]
+ ["[1][0]" control]
+ ["[1][0]" data]
+ ["[1][0]" debug]
+ ["[1][0]" documentation]
+ ["[1][0]" locale]
+ ["[1][0]" macro
+ ["[1]/[0]" code]]
+ ["[1][0]" math]
+ ["[1][0]" meta]
+ ["[1][0]" program]
+ ["[1][0]" static]
+ ["[1][0]" target]
+ ["[1][0]" test]
+ ["[1][0]" time]
+ ... ["[1][0]" tool] ... TODO: Update & expand tests for this
+ ["[1][0]" type]
+ ["[1][0]" world]
+ ["[1][0]" ffi]
+ ["[1][0]" extension]
+ ["[1][0]" target "_"
+ (~~ (.for ["{old}" (~~ (.as_is ["[1]/[0]" jvm]))
+ "JVM" (~~ (.as_is ["[1]/[0]" jvm]))
+ "JavaScript" (~~ (.as_is ["[1]/[0]" js]))]
+ (~~ (.as_is))))]])))
... TODO: Get rid of this ASAP
(template: (!bundle body)
@@ -79,7 +78,8 @@
Test
(with_expansions [... TODO: Update & expand tests for this
<target> (for [@.jvm (~~ (as_is /target/jvm.test))
- @.old (~~ (as_is /target/jvm.test))]
+ @.old (~~ (as_is /target/jvm.test))
+ @.js (~~ (as_is /target/js.test))]
(~~ (as_is)))
<extension> (for [@.old (~~ (as_is))]
(~~ (as_is /extension.test)))]
@@ -865,12 +865,11 @@
(hide left))
true)))))
(_.cover [/.same?]
- (let [not_left (|> left ++ -- %.nat)
- left (%.nat left)]
- (and (and (/.same? left left)
- (/.same? not_left not_left))
- (and (text#= left not_left)
- (not (/.same? left not_left))))))
+ (let [not_left (atom.atom left)
+ left (atom.atom left)]
+ (and (/.same? left left)
+ (/.same? not_left not_left)
+ (not (/.same? left not_left)))))
(_.cover [/.Rec]
(let [list (: (/.Rec NList
(Maybe [Nat NList]))
diff --git a/stdlib/source/test/lux/math/number/int.lux b/stdlib/source/test/lux/math/number/int.lux
index d67d0d853..394c34c15 100644
--- a/stdlib/source/test/lux/math/number/int.lux
+++ b/stdlib/source/test/lux/math/number/int.lux
@@ -1,27 +1,27 @@
(.using
- [library
- [lux "*"
- ["_" test {"+" Test}]
- [abstract
- [monad {"+" do}]
- [\\specification
- ["$[0]" equivalence]
- ["$[0]" hash]
- ["$[0]" order]
- ["$[0]" enum]
- ["$[0]" interval]
- ["$[0]" monoid]
- ["$[0]" codec]]]
- [data
- ["[0]" bit ("[1]#[0]" equivalence)]]
- [math
- ["[0]" random {"+" Random}]]]]
- [\\library
- ["[0]" /
- [//
- ["n" nat]
- ["f" frac]
- ["[0]" i64]]]])
+ [library
+ [lux "*"
+ ["_" test {"+" Test}]
+ [abstract
+ [monad {"+" do}]
+ [\\specification
+ ["$[0]" equivalence]
+ ["$[0]" hash]
+ ["$[0]" order]
+ ["$[0]" enum]
+ ["$[0]" interval]
+ ["$[0]" monoid]
+ ["$[0]" codec]]]
+ [data
+ ["[0]" bit ("[1]#[0]" equivalence)]]
+ [math
+ ["[0]" random {"+" Random}]]]]
+ [\\library
+ ["[0]" /
+ [//
+ ["n" nat]
+ ["f" frac]
+ ["[0]" i64]]]])
(def: signature
Test
@@ -193,7 +193,8 @@
(/.= pattern (/.right_shifted i64.width pattern))
sign_mask (i64.left_shifted (-- i64.width) 1)
- mantissa_mask (i64.not sign_mask)
+ mantissa_mask (-- (i64.left_shifted (n.- idx i64.width) 1))
+ co_mantissa_mask (i64.not mantissa_mask)
sign_preservation!
(/.= (i64.and sign_mask pattern)
@@ -201,11 +202,21 @@
mantissa_parity!
(/.= (i64.and mantissa_mask (i64.right_shifted idx pattern))
- (i64.and mantissa_mask (/.right_shifted idx pattern)))]
+ (i64.and mantissa_mask (/.right_shifted idx pattern)))
+
+ co_mantissa_disparity!
+ (or (n.= 0 idx)
+ (and (/.= +0 (i64.and co_mantissa_mask (i64.right_shifted idx pattern)))
+ (/.= (if (/.< +0 pattern)
+ (.int co_mantissa_mask)
+ +0)
+ (i64.and co_mantissa_mask (/.right_shifted idx pattern)))))]
(and nullity!
idempotency!
sign_preservation!
- mantissa_parity!))))
+ mantissa_parity!
+ co_mantissa_disparity!
+ ))))
..predicate
..signature
diff --git a/stdlib/source/test/lux/target/js.lux b/stdlib/source/test/lux/target/js.lux
new file mode 100644
index 000000000..cc60dd896
--- /dev/null
+++ b/stdlib/source/test/lux/target/js.lux
@@ -0,0 +1,845 @@
+(.using
+ [library
+ [lux "*"
+ ["_" test {"+" Test}]
+ ["[0]" static]
+ [abstract
+ [monad {"+" do}]
+ ["[0]" predicate]]
+ [control
+ [pipe {"+" case>}]
+ ["[0]" function]
+ ["[0]" maybe ("[1]#[0]" functor)]
+ ["[0]" try {"+" Try} ("[1]#[0]" functor)]]
+ [data
+ ["[0]" bit ("[1]#[0]" equivalence)]
+ ["[0]" text {"+" \n} ("[1]#[0]" equivalence)
+ ["%" format {"+" format}]]
+ [collection
+ ["[0]" list ("[1]#[0]" functor)]]]
+ [macro
+ ["[0]" template]]
+ [math
+ ["[0]" random {"+" Random} ("[1]#[0]" monad)]
+ [number
+ ["n" nat]
+ ["i" int]
+ ["f" frac]
+ ["[0]" i64]]]]]
+ [\\library
+ ["[0]" /]])
+
+(def: (eval code)
+ (-> /.Expression (Try (Maybe Any)))
+ ... Note: I have to call "eval" this way
+ ... in order to avoid a quirk of calling eval in Node
+ ... when the code is running under "use strict";.
+ (try (let [return ("js apply" (function.identity ("js constant" "eval")) (/.code code))]
+ (if ("js object null?" return)
+ {.#None}
+ {.#Some return}))))
+
+(def: (expression ??? it)
+ (-> (-> Any Bit) /.Expression Bit)
+ (|> it
+ ..eval
+ (try#each (|>> (maybe#each ???)
+ (maybe.else false)))
+ (try.else false)))
+
+(template [<range>]
+ [(`` (def: (~~ (template.symbol ["as_int/" <range>]))
+ (-> Int Int)
+ (|>> (i64.and (static.nat (-- (i64.left_shifted <range> 1)))))))
+ (`` (def: (~~ (template.symbol ["int/" <range>]))
+ (Random Int)
+ (do [! random.monad]
+ [negative? random.bit
+ mantissa (# ! each (|>> (i64.and (static.nat (-- (i64.left_shifted (-- <range>) 1))))
+ .int)
+ random.nat)]
+ (in (if negative?
+ (i.* -1 mantissa)
+ mantissa)))))]
+
+ [16]
+ [32]
+ )
+
+(def: test|literal
+ Test
+ (do [! random.monad]
+ [boolean random.bit
+ number random.frac
+ int ..int/32
+ string (random.ascii/upper 5)]
+ ($_ _.and
+ (_.cover [/.null]
+ (|> /.null
+ ..eval
+ (try#each (function (_ it)
+ (case it
+ {.#None} true
+ {.#Some _} true)))
+ (try.else false)))
+ (_.cover [/.boolean]
+ (expression (|>> (:as Bit) (bit#= boolean))
+ (/.boolean boolean)))
+ (_.cover [/.number]
+ (expression (|>> (:as Frac) (f.= number))
+ (/.number number)))
+ (_.cover [/.int]
+ (expression (|>> (:as Frac) f.int (i.= int))
+ (/.int int)))
+ (_.cover [/.string]
+ (expression (|>> (:as Text) (text#= string))
+ (/.string string)))
+ )))
+
+(def: test|boolean
+ Test
+ (do [! random.monad]
+ [left random.bit
+ right random.bit]
+ (`` ($_ _.and
+ (~~ (template [<js> <lux>]
+ [(_.cover [<js>]
+ (let [expected (<lux> left right)]
+ (expression (|>> (:as Bit) (bit#= expected))
+ (<js> (/.boolean left) (/.boolean right)))))]
+
+ [/.or .or]
+ [/.and .and]
+ ))
+ (_.cover [/.not]
+ (expression (|>> (:as Bit) (bit#= (not left)))
+ (/.not (/.boolean left))))
+ ))))
+
+(def: test|number
+ Test
+ (do [! random.monad]
+ [parameter (random.only (|>> (f.= +0.0) not)
+ random.safe_frac)
+ subject random.safe_frac]
+ (`` ($_ _.and
+ (~~ (template [<js> <lux>]
+ [(_.cover [<js>]
+ (let [expected (<lux> parameter subject)]
+ (expression (|>> (:as Frac) (f.= expected))
+ (<js> (/.number parameter) (/.number subject)))))]
+
+ [/.+ f.+]
+ [/.- f.-]
+ [/.* f.*]
+ [/./ f./]
+ [/.% f.%]
+ ))
+ (~~ (template [<js> <lux>]
+ [(_.cover [<js>]
+ (let [expected (<lux> parameter subject)]
+ (expression (|>> (:as Bit) (bit#= expected))
+ (<js> (/.number parameter) (/.number subject)))))]
+
+ [/.< f.<]
+ [/.<= f.<=]
+ [/.> f.>]
+ [/.>= f.>=]
+ [/.= f.=]
+ ))
+ ))))
+
+(def: test|i32
+ Test
+ (do [! random.monad]
+ [left ..int/32
+ right ..int/32
+
+ i32 ..int/32
+ i16 ..int/16
+ shift (# ! each (n.% 16) random.nat)]
+ (`` ($_ _.and
+ (~~ (template [<js> <lux>]
+ [(_.cover [<js>]
+ (let [expected (<lux> left right)]
+ (expression (|>> (:as Frac) f.int (i.= expected))
+ (<js> (/.int left) (/.int right)))))]
+
+ [/.bit_or i64.or]
+ [/.bit_xor i64.xor]
+ [/.bit_and i64.and]
+ ))
+ (_.cover [/.opposite]
+ (expression (|>> (:as Frac) f.int (i.= (i.* -1 i32)))
+ (/.opposite (/.i32 i32))))
+
+ (_.cover [/.i32]
+ (expression (|>> (:as Frac) f.int (i.= i32))
+ (/.i32 i32)))
+ (_.cover [/.to_i32]
+ (expression (|>> (:as Frac) f.int (i.= i32))
+ (/.to_i32 (/.int i32))))
+ (_.cover [/.left_shift]
+ (let [expected (i64.left_shifted shift i16)]
+ (expression (|>> (:as Frac) f.int (i.= expected))
+ (/.left_shift (/.int (.int shift))
+ (/.i32 i16)))))
+ (_.cover [/.logic_right_shift]
+ (let [expected (i64.right_shifted shift (as_int/32 i16))]
+ (expression (|>> (:as Frac) f.int (i.= expected))
+ (/.logic_right_shift (/.int (.int shift))
+ (/.i32 i16)))))
+ (_.cover [/.arithmetic_right_shift]
+ (let [expected (i.right_shifted shift i16)]
+ (expression (|>> (:as Frac) f.int (i.= expected))
+ (/.arithmetic_right_shift (/.int (.int shift))
+ (/.i32 i16)))))
+ (_.cover [/.bit_not]
+ (let [expected (if (i.< +0 i32)
+ (as_int/32 (i64.not i32))
+ (i64.not (as_int/32 i32)))]
+ (expression (|>> (:as Frac) f.int (i.= expected))
+ (/.bit_not (/.i32 i32)))))
+ ))))
+
+(def: test|array
+ Test
+ (do [! random.monad]
+ [size (# ! each (|>> (n.% 10) ++) random.nat)
+ index (# ! each (n.% size) random.nat)
+ items (random.list size random.safe_frac)
+ .let [expected (|> items
+ (list.item index)
+ (maybe.else f.not_a_number))]]
+ ($_ _.and
+ (_.cover [/.array /.at]
+ (and (expression (|>> (:as Frac) (f.= expected))
+ (/.at (/.int (.int index))
+ (/.array (list#each /.number items))))
+ (expression (|>> (:as Bit))
+ (|> (/.array (list#each /.number items))
+ (/.at (/.int (.int size)))
+ (/.= /.undefined)))))
+ )))
+
+(def: test|object
+ Test
+ (do [! random.monad]
+ [expected random.safe_frac
+ field (random.ascii/upper 5)
+ dummy (random.only (|>> (text#= field) not)
+ (random.ascii/upper 5))
+
+ size (# ! each (|>> (n.% 10) ++) random.nat)
+ index (# ! each (n.% size) random.nat)
+ items (random.list size random.safe_frac)]
+ ($_ _.and
+ (_.cover [/.object /.the]
+ (expression (|>> (:as Frac) (f.= expected))
+ (/.the field (/.object (list [field (/.number expected)])))))
+ (let [expected (|> items
+ (list.item index)
+ (maybe.else f.not_a_number))]
+ (_.cover [/.do]
+ (expression (|>> (:as Frac) f.int (i.= (.int index)))
+ (|> (/.array (list#each /.number items))
+ (/.do "lastIndexOf" (list (/.number expected)))))))
+ (_.cover [/.undefined]
+ (expression (|>> (:as Bit))
+ (|> (/.object (list [field (/.number expected)]))
+ (/.the dummy)
+ (/.= /.undefined))))
+ )))
+
+(def: test|computation
+ Test
+ (do [! random.monad]
+ [test random.bit
+ then random.safe_frac
+ else random.safe_frac
+
+ boolean random.bit
+ number random.frac
+ string (random.ascii/upper 5)
+
+ comment (random.ascii/upper 10)]
+ ($_ _.and
+ ..test|boolean
+ ..test|number
+ ..test|i32
+ ..test|array
+ ..test|object
+ (_.cover [/.?]
+ (let [expected (if test then else)]
+ (expression (|>> (:as Frac) (f.= expected))
+ (/.? (/.boolean test)
+ (/.number then)
+ (/.number else)))))
+ (_.cover [/.not_a_number?]
+ (and (expression (|>> (:as Bit))
+ (/.not_a_number? (/.number f.not_a_number)))
+ (expression (|>> (:as Bit) not)
+ (/.not_a_number? (/.number then)))))
+ (_.cover [/.type_of]
+ (and (expression (|>> (:as Text) (text#= "boolean"))
+ (/.type_of (/.boolean boolean)))
+ (expression (|>> (:as Text) (text#= "number"))
+ (/.type_of (/.number number)))
+ (expression (|>> (:as Text) (text#= "string"))
+ (/.type_of (/.string string)))
+ (expression (|>> (:as Text) (text#= "object"))
+ (/.type_of /.null))
+ (expression (|>> (:as Text) (text#= "object"))
+ (/.type_of (/.object (list [string (/.number number)]))))
+ (expression (|>> (:as Text) (text#= "object"))
+ (/.type_of (/.array (list (/.boolean boolean)
+ (/.number number)
+ (/.string string)))))
+ (expression (|>> (:as Text) (text#= "undefined"))
+ (/.type_of /.undefined))))
+ (_.cover [/.comment]
+ (expression (|>> (:as Frac) (f.= then))
+ (/.comment comment
+ (/.number then))))
+ )))
+
+(def: test|expression
+ Test
+ (do [! random.monad]
+ [dummy random.safe_frac
+ expected random.safe_frac]
+ (`` ($_ _.and
+ (_.for [/.Literal]
+ ..test|literal)
+ (_.for [/.Computation]
+ ..test|computation)
+ (_.cover [/.,]
+ (expression (|>> (:as Frac) (f.= expected))
+ (/., (/.number dummy) (/.number expected))))
+ ))))
+
+(def: test/var
+ Test
+ (do [! random.monad]
+ [number/0 random.safe_frac
+ number/1 random.safe_frac
+ number/2 random.safe_frac
+ foreign (random.ascii/lower 10)
+ local (random.only (|>> (text#= foreign) not)
+ (random.ascii/lower 10))
+ .let [$foreign (/.var foreign)
+ $local (/.var local)]]
+ ($_ _.and
+ (_.cover [/.var]
+ (expression (|>> (:as Frac) (f.= number/0))
+ (/.apply/* (/.closure (list $foreign) (/.return $foreign))
+ (list (/.number number/0)))))
+ (_.cover [/.define]
+ (expression (|>> (:as Frac) (f.= number/1))
+ (/.apply/* (/.closure (list $foreign)
+ ($_ /.then
+ (/.define $local (/.number number/1))
+ (/.return $local)))
+ (list (/.number number/0)))))
+ (_.cover [/.declare]
+ (expression (|>> (:as Frac) (f.= number/1))
+ (/.apply/* (/.closure (list $foreign)
+ ($_ /.then
+ (/.declare $local)
+ (/.set $local (/.number number/1))
+ (/.return $local)))
+ (list (/.number number/0)))))
+ )))
+
+(def: test/location
+ Test
+ (do [! random.monad]
+ [number/0 random.safe_frac
+ int/0 ..int/16
+ $foreign (# ! each /.var (random.ascii/lower 10))
+ field (random.ascii/upper 10)]
+ ($_ _.and
+ (_.cover [/.set]
+ (and (expression (|>> (:as Frac) (f.= (f.+ number/0 number/0)))
+ (/.apply/* (/.closure (list $foreign)
+ ($_ /.then
+ (/.set $foreign (/.+ $foreign $foreign))
+ (/.return $foreign)))
+ (list (/.number number/0))))
+ (expression (|>> (:as Frac) (f.= (f.+ number/0 number/0)))
+ (let [@ (/.at (/.int +0) $foreign)]
+ (/.apply/* (/.closure (list $foreign)
+ ($_ /.then
+ (/.set $foreign (/.array (list $foreign)))
+ (/.set @ (/.+ @ @))
+ (/.return @)))
+ (list (/.number number/0)))))
+ (expression (|>> (:as Frac) (f.= (f.+ number/0 number/0)))
+ (let [@ (/.the field $foreign)]
+ (/.apply/* (/.closure (list $foreign)
+ ($_ /.then
+ (/.set $foreign (/.object (list [field $foreign])))
+ (/.set @ (/.+ @ @))
+ (/.return @)))
+ (list (/.number number/0)))))))
+ (_.cover [/.delete]
+ (and (and (expression (|>> (:as Bit))
+ (/.apply/* (/.closure (list)
+ ($_ /.then
+ (/.set $foreign (/.number number/0))
+ (/.return (/.delete $foreign))))
+ (list)))
+ (expression (|>> (:as Bit) not)
+ (/.apply/* (/.closure (list $foreign)
+ (/.return (/.delete $foreign)))
+ (list (/.number number/0)))))
+ (expression (|>> (:as Bit))
+ (let [@ (/.at (/.int +0) $foreign)]
+ (/.apply/* (/.closure (list $foreign)
+ ($_ /.then
+ (/.set $foreign (/.array (list $foreign)))
+ (/.return (|> (/.= (/.boolean true) (/.delete @))
+ (/.and (/.= /.undefined @))))))
+ (list (/.number number/0)))))
+ (expression (|>> (:as Bit))
+ (let [@ (/.the field $foreign)]
+ (/.apply/* (/.closure (list $foreign)
+ ($_ /.then
+ (/.set $foreign (/.object (list [field $foreign])))
+ (/.return (|> (/.= (/.boolean true) (/.delete @))
+ (/.and (/.= /.undefined @))))))
+ (list (/.number number/0)))))
+ ))
+ (_.cover [/.Access]
+ (`` (and (~~ (template [<js> <lux>]
+ [(expression (|>> (:as Frac) f.int (i.= (<lux> int/0)))
+ (/.apply/* (/.closure (list $foreign)
+ ($_ /.then
+ (/.statement (<js> $foreign))
+ (/.return $foreign)))
+ (list (/.int int/0))))
+ (expression (|>> (:as Frac) f.int (i.= (<lux> int/0)))
+ (let [@ (/.at (/.int +0) $foreign)]
+ (/.apply/* (/.closure (list $foreign)
+ ($_ /.then
+ (/.set $foreign (/.array (list $foreign)))
+ (/.statement (<js> @))
+ (/.return @)))
+ (list (/.int int/0)))))
+ (expression (|>> (:as Frac) f.int (i.= (<lux> int/0)))
+ (let [@ (/.the field $foreign)]
+ (/.apply/* (/.closure (list $foreign)
+ ($_ /.then
+ (/.set $foreign (/.object (list [field $foreign])))
+ (/.statement (<js> @))
+ (/.return @)))
+ (list (/.int int/0)))))]
+
+ [/.++ .++]
+ [/.-- .--]
+ )))))
+ (_.for [/.Var]
+ ..test/var)
+ )))
+
+(def: test|label
+ Test
+ (do [! random.monad]
+ [input ..int/16
+
+ full_inner_iterations (# ! each (|>> (n.% 20) ++) random.nat)
+ expected_inner_iterations (# ! each (n.% full_inner_iterations) random.nat)
+
+ @outer (# ! each /.label (random.ascii/upper 5))
+ full_outer_iterations (# ! each (|>> (n.% 10) ++) random.nat)
+ expected_outer_iterations (# ! each (n.% full_outer_iterations) random.nat)
+
+ .let [$input (/.var "input")
+ $output (/.var "output")
+ $inner_index (/.var "inner_index")
+ $outer_index (/.var "outer_index")]]
+ ($_ _.and
+ (_.cover [/.break]
+ (let [expected (i.* (.int expected_inner_iterations) input)]
+ (expression (|>> (:as Frac) f.int (i.= expected))
+ (/.apply/* (/.closure (list $input)
+ ($_ /.then
+ (/.define $inner_index (/.int +0))
+ (/.define $output (/.int +0))
+ (/.while (/.< (/.int (.int full_inner_iterations)) $inner_index)
+ ($_ /.then
+ (/.when (/.= (/.int (.int expected_inner_iterations)) $inner_index)
+ /.break)
+ (/.set $output (/.+ $input $output))
+ (/.set $inner_index (/.+ (/.int +1) $inner_index))
+ ))
+ (/.return $output)))
+ (list (/.int input))))))
+ (_.cover [/.continue]
+ (let [expected (i.* (.int (n.- expected_inner_iterations full_inner_iterations)) input)]
+ (expression (|>> (:as Frac) f.int (i.= expected))
+ (/.apply/* (/.closure (list $input)
+ ($_ /.then
+ (/.define $inner_index (/.int +0))
+ (/.define $output (/.int +0))
+ (/.while (/.< (/.int (.int full_inner_iterations)) $inner_index)
+ ($_ /.then
+ (/.set $inner_index (/.+ (/.int +1) $inner_index))
+ (/.when (/.<= (/.int (.int expected_inner_iterations)) $inner_index)
+ /.continue)
+ (/.set $output (/.+ $input $output))
+ ))
+ (/.return $output)))
+ (list (/.int input))))))
+ (_.for [/.label /.with_label]
+ ($_ _.and
+ (_.cover [/.break_at]
+ (let [expected (i.* (.int (n.* expected_outer_iterations
+ expected_inner_iterations))
+ input)]
+ (expression (|>> (:as Frac) f.int (i.= expected))
+ (/.apply/* (/.closure (list $input)
+ ($_ /.then
+ (/.define $output (/.int +0))
+ (/.define $outer_index (/.int +0))
+ (/.with_label @outer
+ (/.while (/.< (/.int (.int full_outer_iterations)) $outer_index)
+ ($_ /.then
+ (/.define $inner_index (/.int +0))
+ (/.while (/.< (/.int (.int full_inner_iterations)) $inner_index)
+ ($_ /.then
+ (/.when (/.= (/.int (.int expected_outer_iterations)) $outer_index)
+ (/.break_at @outer))
+ (/.when (/.= (/.int (.int expected_inner_iterations)) $inner_index)
+ /.break)
+ (/.set $output (/.+ $input $output))
+ (/.set $inner_index (/.+ (/.int +1) $inner_index))
+ ))
+ (/.set $outer_index (/.+ (/.int +1) $outer_index))
+ )))
+ (/.return $output)))
+ (list (/.int input))))))
+ (_.cover [/.continue_at]
+ (let [expected (i.* (.int (n.* (n.- expected_outer_iterations full_outer_iterations)
+ (n.- expected_inner_iterations full_inner_iterations)))
+ input)]
+ (expression (|>> (:as Frac) f.int (i.= expected))
+ (/.apply/* (/.closure (list $input)
+ ($_ /.then
+ (/.define $output (/.int +0))
+ (/.define $outer_index (/.int +0))
+ (/.with_label @outer
+ (/.while (/.< (/.int (.int full_outer_iterations)) $outer_index)
+ ($_ /.then
+ (/.set $outer_index (/.+ (/.int +1) $outer_index))
+ (/.define $inner_index (/.int +0))
+ (/.while (/.< (/.int (.int full_inner_iterations)) $inner_index)
+ ($_ /.then
+ (/.set $inner_index (/.+ (/.int +1) $inner_index))
+ (/.when (/.<= (/.int (.int expected_outer_iterations)) $outer_index)
+ (/.continue_at @outer))
+ (/.when (/.<= (/.int (.int expected_inner_iterations)) $inner_index)
+ /.continue)
+ (/.set $output (/.+ $input $output))
+ ))
+ )
+ ))
+ (/.return $output)))
+ (list (/.int input))))))
+ ))
+ )))
+
+(def: test|loop
+ Test
+ (do [! random.monad]
+ [input ..int/16
+ iterations (# ! each (n.% 10) random.nat)
+ .let [$input (/.var "input")
+ $output (/.var "output")
+ $index (/.var "index")
+ expected|while (i.* (.int iterations) input)
+ expected|do_while (i.* (.int (n.max 1 iterations)) input)]]
+ ($_ _.and
+ (_.cover [/.while]
+ (expression (|>> (:as Frac) f.int (i.= expected|while))
+ (/.apply/* (/.closure (list $input)
+ ($_ /.then
+ (/.define $index (/.int +0))
+ (/.define $output (/.int +0))
+ (/.while (/.< (/.int (.int iterations)) $index)
+ ($_ /.then
+ (/.set $output (/.+ $input $output))
+ (/.set $index (/.+ (/.int +1) $index))
+ ))
+ (/.return $output)))
+ (list (/.int input)))))
+ (_.cover [/.do_while]
+ (expression (|>> (:as Frac) f.int (i.= expected|do_while))
+ (/.apply/* (/.closure (list $input)
+ ($_ /.then
+ (/.define $index (/.int +0))
+ (/.define $output (/.int +0))
+ (/.do_while (/.< (/.int (.int iterations)) $index)
+ ($_ /.then
+ (/.set $output (/.+ $input $output))
+ (/.set $index (/.+ (/.int +1) $index))
+ ))
+ (/.return $output)))
+ (list (/.int input)))))
+ (_.cover [/.for]
+ (expression (|>> (:as Frac) f.int (i.= expected|while))
+ (/.apply/* (/.closure (list $input)
+ ($_ /.then
+ (/.define $output (/.int +0))
+ (/.for $index (/.int +0)
+ (/.< (/.int (.int iterations)) $index)
+ (/.++ $index)
+ (/.set $output (/.+ $input $output)))
+ (/.return $output)))
+ (list (/.int input)))))
+ (_.for [/.Label]
+ ..test|label)
+ )))
+
+(def: test|exception
+ Test
+ (do [! random.monad]
+ [expected random.safe_frac
+ dummy (random.only (|>> (f.= expected) not)
+ random.safe_frac)
+ $ex (# ! each /.var (random.ascii/lower 10))]
+ ($_ _.and
+ (_.cover [/.try]
+ (expression (|>> (:as Frac) (f.= expected))
+ (/.apply/* (/.closure (list)
+ (/.try (/.return (/.number expected))
+ [$ex (/.return (/.number dummy))]))
+ (list))))
+ (_.cover [/.throw]
+ (expression (|>> (:as Frac) (f.= expected))
+ (/.apply/* (/.closure (list)
+ (/.try ($_ /.then
+ (/.throw (/.number expected))
+ (/.return (/.number dummy)))
+ [$ex (/.return $ex)]))
+ (list))))
+ )))
+
+(def: test|apply
+ Test
+ (do [! random.monad]
+ [number/0 random.safe_frac
+ number/1 random.safe_frac
+ number/2 random.safe_frac
+ $arg/0 (# ! each /.var (random.ascii/lower 10))
+ $arg/1 (# ! each /.var (random.ascii/lower 11))
+ $arg/2 (# ! each /.var (random.ascii/lower 12))]
+ (`` ($_ _.and
+ (_.cover [/.apply/1]
+ (expression (|>> (:as Frac) (f.= number/0))
+ (/.apply/1 (/.closure (list $arg/0) (/.return $arg/0))
+ (/.number number/0))))
+ (_.cover [/.apply/2]
+ (expression (|>> (:as Frac) (f.= ($_ f.+ number/0 number/1)))
+ (/.apply/2 (/.closure (list $arg/0 $arg/1) (/.return ($_ /.+ $arg/0 $arg/1)))
+ (/.number number/0)
+ (/.number number/1))))
+ (_.cover [/.apply/3]
+ (expression (|>> (:as Frac) (f.= ($_ f.+ number/0 number/1 number/2)))
+ (/.apply/3 (/.closure (list $arg/0 $arg/1 $arg/2) (/.return ($_ /.+ $arg/0 $arg/1 $arg/2)))
+ (/.number number/0)
+ (/.number number/1)
+ (/.number number/2))))
+ (_.cover [/.apply/*]
+ (expression (|>> (:as Frac) (f.= ($_ f.+ number/0 number/1 number/2)))
+ (/.apply/* (/.closure (list $arg/0 $arg/1 $arg/2) (/.return ($_ /.+ $arg/0 $arg/1 $arg/2)))
+ (list (/.number number/0)
+ (/.number number/1)
+ (/.number number/2)))))
+ ))))
+
+(def: test|function
+ Test
+ (do [! random.monad]
+ [number/0 random.safe_frac
+ iterations (# ! each (n.% 10) random.nat)
+ $self (# ! each /.var (random.ascii/lower 1))
+ $arg/0 (# ! each /.var (random.ascii/lower 2))
+ field (random.ascii/lower 3)
+ $class (# ! each /.var (random.ascii/upper 4))]
+ ($_ _.and
+ (_.cover [/.closure /.return]
+ (expression (|>> (:as Frac) (f.= number/0))
+ (/.apply/* (/.closure (list) (/.return (/.number number/0)))
+ (list))))
+ (_.cover [/.function]
+ (expression (|>> (:as Frac) f.nat (n.= iterations))
+ (/.apply/1 (/.function $self (list $arg/0)
+ (/.return (/.? (/.< (/.int (.int iterations)) $arg/0)
+ (/.apply/1 $self (/.+ (/.int +1) $arg/0))
+ $arg/0)))
+ (/.int +0))))
+ (_.cover [/.function!]
+ (expression (|>> (:as Frac) f.nat (n.= iterations))
+ (/.apply/* (/.closure (list)
+ ($_ /.then
+ (/.function! $self (list $arg/0)
+ (/.return (/.? (/.< (/.int (.int iterations)) $arg/0)
+ (/.apply/1 $self (/.+ (/.int +1) $arg/0))
+ $arg/0)))
+ (/.return (/.apply/1 $self (/.int +0)))))
+ (list))))
+ (_.cover [/.new]
+ (let [$this (/.var "this")]
+ (expression (|>> (:as Frac) (f.= number/0))
+ (/.apply/1 (/.closure (list $arg/0)
+ ($_ /.then
+ (/.function! $class (list)
+ (/.set (/.the field $this) $arg/0))
+ (/.return (/.the field (/.new $class (list))))))
+ (/.number number/0)))))
+ ..test|apply
+ )))
+
+(def: test|branching
+ Test
+ (do [! random.monad]
+ [number/0 random.safe_frac
+ number/1 random.safe_frac
+ number/2 random.safe_frac
+ arg/0 (random.ascii/lower 10)
+ arg/1 (random.only (|>> (text#= arg/0) not)
+ (random.ascii/lower 10))
+ arg/2 (random.only (predicate.and (|>> (text#= arg/0) not)
+ (|>> (text#= arg/1) not))
+ (random.ascii/lower 10))
+ .let [$arg/0 (/.var arg/0)
+ $arg/1 (/.var arg/1)
+ $arg/2 (/.var arg/2)]
+ ??? random.bit
+ int ..int/16]
+ ($_ _.and
+ (_.cover [/.if]
+ (expression (|>> (:as Frac) (f.= (if ??? number/0 number/1)))
+ (/.apply/* (/.closure (list)
+ (/.if (/.boolean ???)
+ (/.return (/.number number/0))
+ (/.return (/.number number/1))))
+ (list))))
+ (_.cover [/.when]
+ (expression (|>> (:as Frac) (f.= (if ??? number/0 number/1)))
+ (/.apply/* (/.closure (list)
+ ($_ /.then
+ (/.when (/.boolean ???)
+ (/.return (/.number number/0)))
+ (/.return (/.number number/1))))
+ (list))))
+ (_.cover [/.switch]
+ (let [number/0' (%.frac number/0)
+ number/1' (%.frac number/1)
+ number/2' (%.frac number/2)]
+ (and (expression (|>> (:as Text) (text#= number/0'))
+ (/.apply/* (/.closure (list)
+ (/.switch (/.number number/0)
+ (list [(list (/.number number/0)) (/.return (/.string number/0'))]
+ [(list (/.number number/1)) (/.return (/.string number/1'))])
+ {.#None}))
+ (list)))
+ (expression (|>> (:as Text) (text#= number/1'))
+ (/.apply/* (/.closure (list)
+ (/.switch (/.number number/1)
+ (list [(list (/.number number/0)) (/.return (/.string number/0'))]
+ [(list (/.number number/1)) (/.return (/.string number/1'))])
+ {.#Some (/.return (/.string number/2'))}))
+ (list)))
+ (expression (|>> (:as Text) (text#= number/2'))
+ (/.apply/* (/.closure (list)
+ (/.switch (/.number number/2)
+ (list [(list (/.number number/0)) (/.return (/.string number/0'))]
+ [(list (/.number number/1)) (/.return (/.string number/1'))])
+ {.#Some (/.return (/.string number/2'))}))
+ (list)))
+ )))
+ )))
+
+(def: test|statement
+ Test
+ (do [! random.monad]
+ [number/0 random.safe_frac
+ number/1 random.safe_frac
+ number/2 random.safe_frac
+ $arg/0 (# ! each /.var (random.ascii/lower 10))
+ $arg/1 (# ! each /.var (random.ascii/lower 11))
+ $arg/2 (# ! each /.var (random.ascii/lower 12))
+ ??? random.bit
+ int ..int/16]
+ (`` ($_ _.and
+ (_.cover [/.statement]
+ (expression (|>> (:as Frac) (f.= number/0))
+ (/.apply/1 (/.closure (list $arg/0)
+ ($_ /.then
+ (/.statement (/.+ $arg/0 $arg/0))
+ (/.return $arg/0)))
+ (/.number number/0))))
+ (~~ (template [<js> <lux>]
+ [(_.cover [<js>]
+ (expression (|>> (:as Frac) f.int (i.= (<lux> int)))
+ (/.apply/1 (/.closure (list $arg/0)
+ (/.return (/., (<js> $arg/0)
+ $arg/0)))
+ (/.int int))))]
+
+ [/.++ .++]
+ [/.-- .--]
+ ))
+ (_.cover [/.then]
+ (expression (|>> (:as Frac) (f.= number/0))
+ (/.apply/2 (/.closure (list $arg/0 $arg/1)
+ ($_ /.then
+ (/.return $arg/0)
+ (/.return $arg/1)))
+ (/.number number/0)
+ (/.number number/1))))
+ (_.cover [/.use_strict]
+ (and (expression (|>> (:as Frac) (f.= number/0))
+ (/.apply/* (/.closure (list)
+ ($_ /.then
+ /.use_strict
+ (/.declare $arg/0)
+ (/.set $arg/0 (/.number number/0))
+ (/.return $arg/0)))
+ (list)))
+ (|> (/.apply/* (/.closure (list)
+ ($_ /.then
+ /.use_strict
+ ... (/.declare $arg/0)
+ (/.set $arg/0 (/.number number/0))
+ (/.return $arg/0)))
+ (list))
+ ..eval
+ (case> {try.#Success it}
+ false
+
+ {try.#Failure error}
+ true))))
+ ..test|exception
+ ..test|function
+ ..test|branching
+ (_.for [/.Location]
+ ..test/location)
+ (_.for [/.Loop]
+ ..test|loop)
+ ))))
+
+(def: .public test
+ Test
+ (do [! random.monad]
+ []
+ (<| (_.covering /._)
+ (_.for [/.Code /.code])
+ (`` ($_ _.and
+ (_.for [/.Expression]
+ ..test|expression)
+ (_.for [/.Statement]
+ ..test|statement)
+ )))))