aboutsummaryrefslogtreecommitdiff
path: root/stdlib/source/test
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--stdlib/source/test/aedifex.lux2
-rw-r--r--stdlib/source/test/aedifex/input.lux51
-rw-r--r--stdlib/source/test/lux/abstract.lux2
-rw-r--r--stdlib/source/test/lux/abstract/hash.lux35
-rw-r--r--stdlib/source/test/lux/data/collection/row.lux206
-rw-r--r--stdlib/source/test/lux/macro/code.lux20
-rw-r--r--stdlib/source/test/lux/macro/poly/equivalence.lux20
-rw-r--r--stdlib/source/test/lux/macro/syntax/common.lux14
-rw-r--r--stdlib/source/test/lux/math.lux16
-rw-r--r--stdlib/source/test/lux/math/logic/fuzzy.lux4
-rw-r--r--stdlib/source/test/lux/target/jvm.lux50
11 files changed, 275 insertions, 145 deletions
diff --git a/stdlib/source/test/aedifex.lux b/stdlib/source/test/aedifex.lux
index 50d194e43..fd92d9b40 100644
--- a/stdlib/source/test/aedifex.lux
+++ b/stdlib/source/test/aedifex.lux
@@ -7,6 +7,7 @@
[cli (#+ program:)]]]]
["." / #_
["#." artifact]
+ ["#." input]
["#." command #_
["#/." pom]]
["#." dependency]
@@ -21,6 +22,7 @@
Test
($_ _.and
/artifact.test
+ /input.test
/command/pom.test
/dependency.test
/profile.test
diff --git a/stdlib/source/test/aedifex/input.lux b/stdlib/source/test/aedifex/input.lux
new file mode 100644
index 000000000..39a71eb81
--- /dev/null
+++ b/stdlib/source/test/aedifex/input.lux
@@ -0,0 +1,51 @@
+(.module:
+ [lux #*
+ ["_" test (#+ Test)]
+ [abstract
+ [monad (#+ do)]]
+ [control
+ ["." try (#+ Try) ("#@." functor)]
+ [concurrency
+ ["." promise (#+ Promise)]]
+ [security
+ ["!" capability]]]
+ [data
+ ["." binary]
+ ["." text ("#@." equivalence)
+ ["%" format]
+ ["." encoding]]]
+ [math
+ ["." random (#+ Random)]]
+ [world
+ ["." file (#+ File)]]]
+ [//
+ ["@." profile]]
+ {#program
+ ["." /
+ ["/#" // #_
+ ["#" profile (#+ Profile)]
+ ["#." project]
+ ["#." action]
+ ["#." format]]]})
+
+(def: #export test
+ Test
+ (<| (_.covering /._)
+ (do {@ random.monad}
+ [expected (:: @ map (set@ #//.parents (list)) @profile.random)
+ #let [fs (: (file.System Promise)
+ (file.mock (:: file.system separator)))]]
+ (wrap (do promise.monad
+ [verdict (do //action.monad
+ [file (: (Promise (Try (File Promise)))
+ (file.get-file promise.monad fs //project.file))
+ _ (|> expected
+ //format.profile
+ %.code
+ encoding.to-utf8
+ (!.use (:: file over-write)))
+ actual (: (Promise (Try Profile))
+ (/.read promise.monad fs //.default))]
+ (wrap (:: //.equivalence = expected actual)))]
+ (_.claim [/.read]
+ (try.default false verdict)))))))
diff --git a/stdlib/source/test/lux/abstract.lux b/stdlib/source/test/lux/abstract.lux
index 12c3625b3..d99d3c063 100644
--- a/stdlib/source/test/lux/abstract.lux
+++ b/stdlib/source/test/lux/abstract.lux
@@ -10,7 +10,6 @@
["#." fold]
["#." functor
["#/." contravariant]]
- ["#." hash]
["#." interval]
["#." monad
["#/." free]]
@@ -42,7 +41,6 @@
/equivalence.test
/fold.test
..functor
- /hash.test
/interval.test
..monad
/monoid.test
diff --git a/stdlib/source/test/lux/abstract/hash.lux b/stdlib/source/test/lux/abstract/hash.lux
deleted file mode 100644
index f7f82ffe2..000000000
--- a/stdlib/source/test/lux/abstract/hash.lux
+++ /dev/null
@@ -1,35 +0,0 @@
-(.module:
- [lux #*
- ["_" test (#+ Test)]
- [abstract
- [monad (#+ do)]]
- [data
- ["." bit ("#@." equivalence)]
- [number
- ["n" nat]
- ["i" int]]]
- [math
- ["." random]]]
- {1
- ["." /]})
-
-(def: #export test
- Test
- (do random.monad
- [left random.nat
- right random.int
- other-left random.nat
- other-right random.int]
- (<| (_.covering /._)
- ($_ _.and
- (_.cover [/.product]
- (and (n.= (:: (/.product n.hash i.hash) hash [left right])
- (n.* (:: n.hash hash left)
- (:: i.hash hash right)))
- (bit@= (:: (/.product n.hash i.hash) = [left right] [left right])
- (and (:: n.hash = left left)
- (:: i.hash = right right)))
- (bit@= (:: (/.product n.hash i.hash) = [left right] [other-left other-right])
- (and (:: n.hash = left other-left)
- (:: i.hash = right other-right)))))
- ))))
diff --git a/stdlib/source/test/lux/data/collection/row.lux b/stdlib/source/test/lux/data/collection/row.lux
index 1a9cfd383..e096c9085 100644
--- a/stdlib/source/test/lux/data/collection/row.lux
+++ b/stdlib/source/test/lux/data/collection/row.lux
@@ -1,6 +1,5 @@
(.module:
[lux #*
- ["%" data/text/format (#+ format)]
["_" test (#+ Test)]
[abstract
[monad (#+ do)]
@@ -13,69 +12,176 @@
["$." apply]
["$." monad]]}]
[control
- ["." try]]
+ ["." try (#+ Try)]
+ ["." exception]]
[data
+ ["." bit ("#@." equivalence)]
[number
["n" nat]]
[collection
- ["." list ("#@." fold)]]]
+ ["." list ("#@." fold)]
+ ["." set]]]
[math
- ["r" random]]]
+ ["." random]]]
{1
["." / ("#@." monad)]})
+(def: signatures
+ Test
+ (do {@ random.monad}
+ [size (:: @ map (n.% 100) random.nat)]
+ ($_ _.and
+ (_.with-cover [/.equivalence]
+ ($equivalence.spec (/.equivalence n.equivalence) (random.row size random.nat)))
+ (_.with-cover [/.monoid]
+ ($monoid.spec (/.equivalence n.equivalence) /.monoid (random.row size random.nat)))
+ (_.with-cover [/.fold]
+ ($fold.spec /@wrap /.equivalence /.fold))
+ (_.with-cover [/.functor]
+ ($functor.spec /@wrap /.equivalence /.functor))
+ (_.with-cover [/.apply]
+ ($apply.spec /@wrap /.equivalence /.apply))
+ (_.with-cover [/.monad]
+ ($monad.spec /@wrap /.equivalence /.monad))
+ )))
+
+(def: whole
+ Test
+ (do {@ random.monad}
+ [size (:: @ map (n.% 100) random.nat)
+ sample (random.set n.hash size random.nat)
+ #let [sample (|> sample set.to-list /.from-list)]
+ #let [(^open "/@.") (/.equivalence n.equivalence)]]
+ ($_ _.and
+ (_.cover [/.size]
+ (n.= size (/.size sample)))
+ (_.cover [/.empty?]
+ (bit@= (/.empty? sample) (n.= 0 (/.size sample))))
+ (_.cover [/.empty]
+ (/.empty? /.empty))
+ (_.cover [/.to-list /.from-list]
+ (|> sample /.to-list /.from-list (/@= sample)))
+ (_.cover [/.reverse]
+ (or (n.< 2 (/.size sample))
+ (let [not-same!
+ (not (/@= sample
+ (/.reverse sample)))
+
+ self-symmetry!
+ (/@= sample
+ (/.reverse (/.reverse sample)))]
+ (and not-same!
+ self-symmetry!))))
+ (_.cover [/.every? /.any?]
+ (if (/.every? n.even? sample)
+ (not (/.any? (bit.complement n.even?) sample))
+ (/.any? (bit.complement n.even?) sample)))
+ )))
+
+(def: index-based
+ Test
+ (do {@ random.monad}
+ [size (:: @ map (|>> (n.% 100) inc) random.nat)]
+ ($_ _.and
+ (do @
+ [good-index (|> random.nat (:: @ map (n.% size)))
+ #let [bad-index (n.+ size good-index)]
+ sample (random.set n.hash size random.nat)
+ non-member (random.filter (|>> (set.member? sample) not)
+ random.nat)
+ #let [sample (|> sample set.to-list /.from-list)]]
+ ($_ _.and
+ (_.cover [/.nth]
+ (case (/.nth good-index sample)
+ (#try.Success member)
+ (/.member? n.equivalence sample member)
+
+ (#try.Failure error)
+ false))
+ (_.cover [/.put]
+ (<| (try.default false)
+ (do try.monad
+ [sample (/.put good-index non-member sample)
+ actual (/.nth good-index sample)]
+ (wrap (is? non-member actual)))))
+ (_.cover [/.update]
+ (<| (try.default false)
+ (do try.monad
+ [sample (/.put good-index non-member sample)
+ sample (/.update good-index inc sample)
+ actual (/.nth good-index sample)]
+ (wrap (n.= (inc non-member) actual)))))
+ (_.cover [/.within-bounds?]
+ (and (/.within-bounds? sample good-index)
+ (not (/.within-bounds? sample bad-index))))
+ (_.cover [/.index-out-of-bounds]
+ (let [fails! (: (All [a] (-> (Try a) Bit))
+ (function (_ situation)
+ (case situation
+ (#try.Success member)
+ false
+
+ (#try.Failure error)
+ (exception.match? /.index-out-of-bounds error))))]
+ (and (fails! (/.nth bad-index sample))
+ (fails! (/.put bad-index non-member sample))
+ (fails! (/.update bad-index inc sample)))))
+ ))
+ )))
+
(def: #export test
Test
- (<| (_.context (%.name (name-of /._)))
- (do {@ r.monad}
- [size (|> r.nat (:: @ map (|>> (n.% 100) (n.max 10))))]
+ (<| (_.covering /._)
+ (_.with-cover [/.Row])
+ (do {@ random.monad}
+ [size (:: @ map (|>> (n.% 100) inc) random.nat)]
($_ _.and
- ($equivalence.spec (/.equivalence n.equivalence) (r.row size r.nat))
- ($monoid.spec (/.equivalence n.equivalence) /.monoid (r.row size r.nat))
- ($fold.spec /@wrap /.equivalence /.fold)
- ($functor.spec /@wrap /.equivalence /.functor)
- ($apply.spec /@wrap /.equivalence /.apply)
- ($monad.spec /@wrap /.equivalence /.monad)
+ ..signatures
+ ..whole
+ ..index-based
(do @
- [idx (|> r.nat (:: @ map (n.% size)))
- sample (r.row size r.nat)
- other-sample (r.row size r.nat)
- non-member (|> r.nat (r.filter (|>> (/.member? n.equivalence sample) not)))
+ [sample (random.set n.hash size random.nat)
+ non-member (random.filter (|>> (set.member? sample) not)
+ random.nat)
+ #let [sample (|> sample set.to-list /.from-list)]
#let [(^open "/@.") (/.equivalence n.equivalence)]]
($_ _.and
- (_.test (format (%.name (name-of /.size))
- " " (%.name (name-of /.empty?)))
- (if (/.empty? sample)
- (and (n.= 0 size)
- (n.= 0 (/.size sample)))
- (n.= size (/.size sample))))
- (_.test (format (%.name (name-of /.add))
- " " (%.name (name-of /.pop)))
- (and (n.= (inc size) (/.size (/.add non-member sample)))
- (n.= (dec size) (/.size (/.pop sample)))))
- (_.test (format (%.name (name-of /.put))
- " &&& " (%.name (name-of /.nth)))
- (|> sample
- (/.put idx non-member) try.assume
- (/.nth idx) try.assume
- (is? non-member)))
- (_.test (%.name (name-of /.update))
- (|> sample
- (/.put idx non-member) try.assume
- (/.update idx inc) try.assume
- (/.nth idx) try.assume
- (n.= (inc non-member))))
- (_.test (format (%.name (name-of /.to-list))
- " &&& " (%.name (name-of /.from-list)))
- (|> sample /.to-list /.from-list (/@= sample)))
- (_.test (%.name (name-of /.member?))
- (and (not (/.member? n.equivalence sample non-member))
- (/.member? n.equivalence (/.add non-member sample) non-member)))
- (_.test (%.name (name-of /.reverse))
- (and (not (/@= sample
- (/.reverse sample)))
- (/@= sample
- (/.reverse (/.reverse sample)))))
+ (do @
+ [value/0 random.nat
+ value/1 random.nat
+ value/2 random.nat]
+ (_.cover [/.row]
+ (/@= (/.from-list (list value/0 value/1 value/2))
+ (/.row value/0 value/1 value/2))))
+ (_.cover [/.member?]
+ (and (list.every? (/.member? n.equivalence sample)
+ (/.to-list sample))
+ (not (/.member? n.equivalence sample non-member))))
+ (_.cover [/.add]
+ (let [added (/.add non-member sample)
+
+ size-increases!
+ (n.= (inc (/.size sample))
+ (/.size added))
+
+ is-a-member!
+ (/.member? n.equivalence added non-member)]
+ (and size-increases!
+ is-a-member!)))
+ (_.cover [/.pop]
+ (if (/.empty? sample)
+ (/.empty? (/.pop sample))
+ (let [expected-size!
+ (n.= (dec (/.size sample))
+ (/.size (/.pop sample)))
+
+ symmetry!
+ (|> sample
+ (/.add non-member)
+ /.pop
+ (/@= sample))]
+ (and expected-size!
+ symmetry!))))
))
))))
diff --git a/stdlib/source/test/lux/macro/code.lux b/stdlib/source/test/lux/macro/code.lux
index f6a1ca855..52955680e 100644
--- a/stdlib/source/test/lux/macro/code.lux
+++ b/stdlib/source/test/lux/macro/code.lux
@@ -37,14 +37,14 @@
(def: (random-sequence random)
(All [a] (-> (Random a) (Random (List a))))
- (do {@ random.monad}
- [size (|> random.nat (:: @ map (n.% 3)))]
+ (do {! random.monad}
+ [size (|> random.nat (:: ! map (n.% 3)))]
(random.list size random)))
(def: (random-record random)
(All [a] (-> (Random a) (Random (List [a a]))))
- (do {@ random.monad}
- [size (|> random.nat (:: @ map (n.% 3)))]
+ (do {! random.monad}
+ [size (|> random.nat (:: ! map (n.% 3)))]
(random.list size (random.and random random))))
(def: #export random
@@ -85,13 +85,13 @@
(function (_ replace-simulation)
(let [for-sequence (: (-> (-> (List Code) Code) (Random [Code Code]))
(function (_ to-code)
- (do {@ random.monad}
+ (do {! random.monad}
[parts (..random-sequence replace-simulation)]
(wrap [(to-code (list@map product.left parts))
(to-code (list@map product.right parts))]))))]
($_ random.either
(random@wrap [original substitute])
- (do {@ random.monad}
+ (do {! random.monad}
[sample (random.filter (|>> (:: /.equivalence = original) not)
($_ random.either
(random@map /.bit random.bit)
@@ -105,7 +105,7 @@
(wrap [sample sample]))
(for-sequence /.form)
(for-sequence /.tuple)
- (do {@ random.monad}
+ (do {! random.monad}
[parts (..random-sequence replace-simulation)]
(wrap [(/.record (let [parts' (list@map product.left parts)]
(list.zip/2 parts' parts')))
@@ -122,7 +122,7 @@
(_.with-cover [/.format]
(`` ($_ _.and
(~~ (template [<coverage> <random> <tag>]
- [(do {@ random.monad}
+ [(do {! random.monad}
[expected <random>]
(_.cover [<coverage>]
(and (case (..read (/.format (<coverage> expected)))
@@ -149,7 +149,7 @@
[/.tuple (..random-sequence ..random) #.Tuple]
[/.record (..random-record ..random) #.Record]))
(~~ (template [<coverage> <random> <tag>]
- [(do {@ random.monad}
+ [(do {! random.monad}
[expected <random>]
(_.cover [<coverage>]
(and (case (..read (/.format (<coverage> expected)))
@@ -168,7 +168,7 @@
[/.local-tag ..random-text #.Tag]
[/.local-identifier ..random-text #.Identifier]
)))))
- (do {@ random.monad}
+ (do {! random.monad}
[[original substitute] (random.and ..random ..random)
[sample expected] (..replace-simulation [original substitute])]
(_.cover [/.replace]
diff --git a/stdlib/source/test/lux/macro/poly/equivalence.lux b/stdlib/source/test/lux/macro/poly/equivalence.lux
index bfd0a2540..985da657c 100644
--- a/stdlib/source/test/lux/macro/poly/equivalence.lux
+++ b/stdlib/source/test/lux/macro/poly/equivalence.lux
@@ -44,8 +44,9 @@
(def: gen-recursive
(Random Recursive)
(random.rec (function (_ gen-recursive)
- (random.or random.frac
- (random.and random.frac gen-recursive)))))
+ (random.or random.safe-frac
+ (random.and random.safe-frac
+ gen-recursive)))))
(def: gen-record
(Random Record)
@@ -55,15 +56,22 @@
($_ random.and
random.bit
gen-int
- random.frac
+ random.safe-frac
(random.unicode size)
(random.maybe gen-int)
(random.list size gen-int)
- ($_ random.or random.bit gen-int random.frac)
- ($_ random.and gen-int random.frac (random.unicode size))
+ ($_ random.or
+ random.bit
+ gen-int
+ random.safe-frac)
+ ($_ random.and
+ gen-int
+ random.safe-frac
+ (random.unicode size))
gen-recursive)))
-(derived: equivalence (/.equivalence Record))
+(derived: equivalence
+ (/.equivalence Record))
(def: #export test
Test
diff --git a/stdlib/source/test/lux/macro/syntax/common.lux b/stdlib/source/test/lux/macro/syntax/common.lux
index 1aaf851a9..d50b94eaa 100644
--- a/stdlib/source/test/lux/macro/syntax/common.lux
+++ b/stdlib/source/test/lux/macro/syntax/common.lux
@@ -44,8 +44,8 @@
(def: random-annotations
(Random /.Annotations)
- (do {@ random.monad}
- [size (:: @ map (|>> (n.% 3)) random.nat)]
+ (do {! random.monad}
+ [size (:: ! map (|>> (n.% 3)) random.nat)]
(random.list size (random.and random-name
///code.random))))
@@ -89,8 +89,8 @@
(#try.Failure error)
false)))
))
- (do {@ random.monad}
- [size (:: @ map (|>> (n.% 3)) random.nat)
+ (do {! random.monad}
+ [size (:: ! map (|>> (n.% 3)) random.nat)
expected (random.list size ..random-text)]
(_.cover [/.Type-Var /reader.type-variables /writer.type-variables]
(|> expected
@@ -101,8 +101,8 @@
(#try.Failure error)
false))))
- (do {@ random.monad}
- [size (:: @ map (|>> (n.% 3)) random.nat)
+ (do {! random.monad}
+ [size (:: ! map (|>> (n.% 3)) random.nat)
expected (: (Random /.Declaration)
(random.and ..random-text
(random.list size ..random-text)))]
@@ -117,7 +117,7 @@
(#try.Failure error)
false))))
- (do {@ random.monad}
+ (do {! random.monad}
[expected (: (Random /.Typed-Input)
(random.and ///code.random
///code.random))]
diff --git a/stdlib/source/test/lux/math.lux b/stdlib/source/test/lux/math.lux
index c29b25b97..673099c34 100644
--- a/stdlib/source/test/lux/math.lux
+++ b/stdlib/source/test/lux/math.lux
@@ -36,8 +36,8 @@
(<| (_.context (%.name (name-of /._)))
($_ _.and
(<| (_.context "Trigonometry")
- (do {@ r.monad}
- [angle (|> r.safe-frac (:: @ map (f.* /.tau)))]
+ (do {! r.monad}
+ [angle (|> r.safe-frac (:: ! map (f.* /.tau)))]
($_ _.and
(_.test "Sine and arc-sine are inverse functions."
(trigonometric-symmetry /.sin /.asin angle))
@@ -47,8 +47,8 @@
(trigonometric-symmetry /.tan /.atan angle))
)))
(<| (_.context "Rounding")
- (do {@ r.monad}
- [sample (|> r.safe-frac (:: @ map (f.* +1000.0)))]
+ (do {! r.monad}
+ [sample (|> r.safe-frac (:: ! map (f.* +1000.0)))]
($_ _.and
(_.test "The ceiling will be an integer value, and will be >= the original."
(let [ceil'd (/.ceil sample)]
@@ -66,13 +66,13 @@
(f.<= +1.0 (f.abs (f.- sample round'd))))))
)))
(<| (_.context "Exponentials and logarithms")
- (do {@ r.monad}
- [sample (|> r.safe-frac (:: @ map (f.* +10.0)))]
+ (do {! r.monad}
+ [sample (|> r.safe-frac (:: ! map (f.* +10.0)))]
(_.test "Logarithm is the inverse of exponential."
(|> sample /.exp /.log (within? +0.000000000000001 sample)))))
(<| (_.context "Greatest-Common-Divisor and Least-Common-Multiple")
- (do {@ r.monad}
- [#let [gen-nat (|> r.nat (:: @ map (|>> (n.% 1000) (n.max 1))))]
+ (do {! r.monad}
+ [#let [gen-nat (|> r.nat (:: ! map (|>> (n.% 1000) (n.max 1))))]
x gen-nat
y gen-nat]
($_ _.and
diff --git a/stdlib/source/test/lux/math/logic/fuzzy.lux b/stdlib/source/test/lux/math/logic/fuzzy.lux
index d692cb3f4..16e9116c1 100644
--- a/stdlib/source/test/lux/math/logic/fuzzy.lux
+++ b/stdlib/source/test/lux/math/logic/fuzzy.lux
@@ -143,9 +143,9 @@
(def: predicates-and-sets
Test
- (do {@ random.monad}
+ (do {! random.monad}
[#let [set-10 (set.from-list n.hash (enum.range n.enum 0 10))]
- sample (|> random.nat (:: @ map (n.% 20)))]
+ sample (|> random.nat (:: ! map (n.% 20)))]
($_ _.and
(_.test (%.name (name-of /.from-predicate))
(bit@= (r.= //.true (/.membership sample (/.from-predicate n.even?)))
diff --git a/stdlib/source/test/lux/target/jvm.lux b/stdlib/source/test/lux/target/jvm.lux
index 4eefd9e03..3a98b5380 100644
--- a/stdlib/source/test/lux/target/jvm.lux
+++ b/stdlib/source/test/lux/target/jvm.lux
@@ -299,8 +299,8 @@
(template [<name> <bits> <type> <push> <wrap> <message> <to-long> <signed>]
[(def: <name>
Test
- (do {@ random.monad}
- [expected (:: @ map (i64.and (i64.mask <bits>)) random.nat)]
+ (do {! random.monad}
+ [expected (:: ! map (i64.and (i64.mask <bits>)) random.nat)]
(<| (_.lift <message>)
(..bytecode (for {@.old
(|>> (:coerce <type>) <to-long> ("jvm leq" expected))
@@ -377,8 +377,8 @@
instruction)))))
shift (: (-> (-> java/lang/Integer java/lang/Integer java/lang/Integer) (Bytecode Any) (Random Bit))
(function (_ reference instruction)
- (do {@ random.monad}
- [parameter (:: @ map (|>> (n.% 32) .int (:coerce java/lang/Long) host.long-to-int) random.nat)
+ (do {! random.monad}
+ [parameter (:: ! map (|>> (n.% 32) .int (:coerce java/lang/Long) host.long-to-int) random.nat)
subject ..$Integer::random]
(int (reference parameter subject)
(do /.monad
@@ -456,8 +456,8 @@
instruction)))))
shift (: (-> (-> java/lang/Integer java/lang/Long java/lang/Long) (Bytecode Any) (Random Bit))
(function (_ reference instruction)
- (do {@ random.monad}
- [parameter (:: @ map (|>> (n.% 64) (:coerce java/lang/Long)) random.nat)
+ (do {! random.monad}
+ [parameter (:: ! map (|>> (n.% 64) (:coerce java/lang/Long)) random.nat)
subject ..$Long::random]
(long (reference (host.long-to-int parameter) subject)
(do /.monad
@@ -937,8 +937,8 @@
(-> a Any Bit)
Test))
(function (_ constructor random literal [*store *load *wrap] test)
- (do {@ random.monad}
- [size (:: @ map (|>> (n.% 1024) (n.max 1)) random.nat)
+ (do {! random.monad}
+ [size (:: ! map (|>> (n.% 1024) (n.max 1)) random.nat)
value random]
($_ _.and
(<| (_.lift "length")
@@ -1009,12 +1009,12 @@
(array (/.anewarray ..$String) $String::random $String::literal [/.aastore /.aaload /.nop]
(function (_ expected) (|>> (:coerce Text) (text@= (:coerce Text expected))))))
(<| (_.context "multi")
- (do {@ random.monad}
- [#let [size (:: @ map (|>> (n.% 10) (n.+ 1))
+ (do {! random.monad}
+ [#let [size (:: ! map (|>> (n.% 10) (n.+ 1))
random.nat)]
dimensions size
sizesH size
- sizesT (monad.seq @ (list.repeat (dec dimensions) size))
+ sizesT (monad.seq ! (list.repeat (dec dimensions) size))
#let [type (loop [dimensions dimensions
type (: (Type Object)
..$Object)]
@@ -1023,8 +1023,8 @@
_ (recur (dec dimensions) (/type.array type))))]]
(<| (_.lift "MULTIANEWARRAY")
(..bytecode (|>> (:coerce Nat) (n.= sizesH)))
- (do {@ /.monad}
- [_ (monad.map @ (|>> (:coerce java/lang/Long) host.long-to-int ..$Integer::literal)
+ (do {! /.monad}
+ [_ (monad.map ! (|>> (:coerce java/lang/Long) host.long-to-int ..$Integer::literal)
(#.Cons sizesH sizesT))
_ (/.multianewarray type (|> dimensions /unsigned.u1 try.assume))
_ ?length]
@@ -1121,9 +1121,9 @@
(-> a (-> Any Bit))
(Random Bit)))
(function (_ random-value literal *wrap [store load] test)
- (do {@ random.monad}
+ (do {! random.monad}
[expected random-value
- register (:: @ map (n.% 128) random.nat)]
+ register (:: ! map (n.% 128) random.nat)]
(<| (..bytecode (test expected))
(do /.monad
[_ (literal expected)
@@ -1145,9 +1145,9 @@
(_.lift "ISTORE/ILOAD"
(store-and-load ..$Integer::random ..$Integer::literal ..$Integer::wrap [/.istore /.iload] test))
(_.lift "IINC"
- (do {@ random.monad}
+ (do {! random.monad}
[base ..$Byte::random
- increment (:: @ map (|>> (n.% 100) /unsigned.u1 try.assume)
+ increment (:: ! map (|>> (n.% 100) /unsigned.u1 try.assume)
random.nat)
#let [expected (: java/lang/Long
(for {@.old
@@ -1468,12 +1468,12 @@
Test
($_ _.and
(<| (_.lift "TABLESWITCH")
- (do {@ random.monad}
+ (do {! random.monad}
[expected ..$Long::random
dummy ..$Long::random
- minimum (:: @ map (|>> (n.% 100) .int /signed.s4 try.assume)
+ minimum (:: ! map (|>> (n.% 100) .int /signed.s4 try.assume)
random.nat)
- afterwards (:: @ map (n.% 10) random.nat)])
+ afterwards (:: ! map (n.% 10) random.nat)])
(..bytecode ((!::= java/lang/Long "jvm leq" "jvm long =") expected))
(do /.monad
[@right /.new-label
@@ -1489,14 +1489,14 @@
_ (/.set-label @return)]
..$Long::wrap))
(<| (_.lift "LOOKUPSWITCH")
- (do {@ random.monad}
- [options (:: @ map (|>> (n.% 10) (n.+ 1))
+ (do {! random.monad}
+ [options (:: ! map (|>> (n.% 10) (n.+ 1))
random.nat)
- choice (:: @ map (n.% options) random.nat)
+ choice (:: ! map (n.% options) random.nat)
options (|> random.int
- (:: @ map (|>> (:coerce java/lang/Long) host.long-to-int host.int-to-long (:coerce Int)))
+ (:: ! map (|>> (:coerce java/lang/Long) host.long-to-int host.int-to-long (:coerce Int)))
(random.set i.hash options)
- (:: @ map set.to-list))
+ (:: ! map set.to-list))
#let [choice (maybe.assume (list.nth choice options))]
expected ..$Long::random
dummy ..$Long::random])