aboutsummaryrefslogtreecommitdiff
path: root/stdlib/source/test/lux/control/parser/synthesis.lux
diff options
context:
space:
mode:
Diffstat (limited to 'stdlib/source/test/lux/control/parser/synthesis.lux')
-rw-r--r--stdlib/source/test/lux/control/parser/synthesis.lux160
1 files changed, 80 insertions, 80 deletions
diff --git a/stdlib/source/test/lux/control/parser/synthesis.lux b/stdlib/source/test/lux/control/parser/synthesis.lux
index addb7c149..4cf859a46 100644
--- a/stdlib/source/test/lux/control/parser/synthesis.lux
+++ b/stdlib/source/test/lux/control/parser/synthesis.lux
@@ -68,16 +68,16 @@
[expected <random>
dummy (|> <random> (random.only (|>> (# <equivalence> = expected) not)))]
(all _.and
- (_.cover [<query>]
- (|> (/.result <query> (list (<synthesis> expected)))
- (!expect (^.multi {try.#Success actual}
- (# <equivalence> = expected actual)))))
- (_.cover [<check>]
- (and (|> (/.result (<check> expected) (list (<synthesis> expected)))
- (!expect {try.#Success _}))
- (|> (/.result (<check> expected) (list (<synthesis> dummy)))
- (!expect (^.multi {try.#Failure error}
- (exception.match? /.cannot_parse error))))))
+ (_.coverage [<query>]
+ (|> (/.result <query> (list (<synthesis> expected)))
+ (!expect (^.multi {try.#Success actual}
+ (# <equivalence> = expected actual)))))
+ (_.coverage [<check>]
+ (and (|> (/.result (<check> expected) (list (<synthesis> expected)))
+ (!expect {try.#Success _}))
+ (|> (/.result (<check> expected) (list (<synthesis> dummy)))
+ (!expect (^.multi {try.#Failure error}
+ (exception.match? /.cannot_parse error))))))
))]
[/.bit /.this_bit random.bit synthesis.bit bit.equivalence]
@@ -98,66 +98,66 @@
expected_i64 random.i64
expected_f64 random.safe_frac
expected_text (random.unicode 1)]
- (_.cover [/.tuple]
- (and (|> (/.result (/.tuple (all <>.and /.bit /.i64 /.f64 /.text))
- (list (synthesis.tuple (list (synthesis.bit expected_bit)
- (synthesis.i64 expected_i64)
- (synthesis.f64 expected_f64)
- (synthesis.text expected_text)))))
- (!expect (^.multi {try.#Success [actual_bit actual_i64 actual_f64 actual_text]}
- (and (# bit.equivalence = expected_bit actual_bit)
- (# i64.equivalence = expected_i64 actual_i64)
- (# frac.equivalence = expected_f64 actual_f64)
- (# text.equivalence = expected_text actual_text)))))
- (|> (/.result (/.tuple (all <>.and /.bit /.i64 /.f64 /.text))
- (list (synthesis.text expected_text)))
- (!expect (^.multi {try.#Failure error}
- (exception.match? /.cannot_parse error)))))))
+ (_.coverage [/.tuple]
+ (and (|> (/.result (/.tuple (all <>.and /.bit /.i64 /.f64 /.text))
+ (list (synthesis.tuple (list (synthesis.bit expected_bit)
+ (synthesis.i64 expected_i64)
+ (synthesis.f64 expected_f64)
+ (synthesis.text expected_text)))))
+ (!expect (^.multi {try.#Success [actual_bit actual_i64 actual_f64 actual_text]}
+ (and (# bit.equivalence = expected_bit actual_bit)
+ (# i64.equivalence = expected_i64 actual_i64)
+ (# frac.equivalence = expected_f64 actual_f64)
+ (# text.equivalence = expected_text actual_text)))))
+ (|> (/.result (/.tuple (all <>.and /.bit /.i64 /.f64 /.text))
+ (list (synthesis.text expected_text)))
+ (!expect (^.multi {try.#Failure error}
+ (exception.match? /.cannot_parse error)))))))
(do [! random.monad]
[arity random.nat
expected_environment ..random_environment
expected_body (random.unicode 1)]
- (_.cover [/.function]
- (and (|> (/.result (/.function arity /.text)
- (list (synthesis.function/abstraction [expected_environment arity (synthesis.text expected_body)])))
- (!expect (^.multi {try.#Success [actual_environment actual_body]}
- (and (# (list.equivalence synthesis.equivalence) =
- expected_environment
- actual_environment)
- (# text.equivalence = expected_body actual_body)))))
- (|> (/.result (/.function arity /.text)
- (list (synthesis.text expected_body)))
- (!expect (^.multi {try.#Failure error}
- (exception.match? /.cannot_parse error)))))))
+ (_.coverage [/.function]
+ (and (|> (/.result (/.function arity /.text)
+ (list (synthesis.function/abstraction [expected_environment arity (synthesis.text expected_body)])))
+ (!expect (^.multi {try.#Success [actual_environment actual_body]}
+ (and (# (list.equivalence synthesis.equivalence) =
+ expected_environment
+ actual_environment)
+ (# text.equivalence = expected_body actual_body)))))
+ (|> (/.result (/.function arity /.text)
+ (list (synthesis.text expected_body)))
+ (!expect (^.multi {try.#Failure error}
+ (exception.match? /.cannot_parse error)))))))
(do [! random.monad]
[arity random.nat
expected_environment ..random_environment
expected_body (random.unicode 1)]
- (_.cover [/.wrong_arity]
- (|> (/.result (/.function (++ arity) /.text)
- (list (synthesis.function/abstraction [expected_environment arity (synthesis.text expected_body)])))
- (!expect (^.multi {try.#Failure error}
- (exception.match? /.wrong_arity error))))))
+ (_.coverage [/.wrong_arity]
+ (|> (/.result (/.function (++ arity) /.text)
+ (list (synthesis.function/abstraction [expected_environment arity (synthesis.text expected_body)])))
+ (!expect (^.multi {try.#Failure error}
+ (exception.match? /.wrong_arity error))))))
(do [! random.monad]
[arity (# ! each (|>> (n.% 10) ++) random.nat)
expected_offset random.nat
expected_inits (random.list arity random.bit)
expected_body (random.unicode 1)]
- (_.cover [/.loop]
- (and (|> (/.result (/.loop (<>.many /.bit) /.text)
- (list (synthesis.loop/scope [expected_offset
- (list#each (|>> synthesis.bit) expected_inits)
- (synthesis.text expected_body)])))
- (!expect (^.multi {try.#Success [actual_offset actual_inits actual_body]}
- (and (# n.equivalence = expected_offset actual_offset)
- (# (list.equivalence bit.equivalence) =
- expected_inits
- actual_inits)
- (# text.equivalence = expected_body actual_body)))))
- (|> (/.result (/.loop (<>.many /.bit) /.text)
- (list (synthesis.text expected_body)))
- (!expect (^.multi {try.#Failure error}
- (exception.match? /.cannot_parse error)))))))
+ (_.coverage [/.loop]
+ (and (|> (/.result (/.loop (<>.many /.bit) /.text)
+ (list (synthesis.loop/scope [expected_offset
+ (list#each (|>> synthesis.bit) expected_inits)
+ (synthesis.text expected_body)])))
+ (!expect (^.multi {try.#Success [actual_offset actual_inits actual_body]}
+ (and (# n.equivalence = expected_offset actual_offset)
+ (# (list.equivalence bit.equivalence) =
+ expected_inits
+ actual_inits)
+ (# text.equivalence = expected_body actual_body)))))
+ (|> (/.result (/.loop (<>.many /.bit) /.text)
+ (list (synthesis.text expected_body)))
+ (!expect (^.multi {try.#Failure error}
+ (exception.match? /.cannot_parse error)))))))
))
(def: .public test
@@ -167,35 +167,35 @@
(all _.and
(do [! random.monad]
[expected (# ! each (|>> synthesis.i64) random.i64)]
- (_.cover [/.result /.any]
- (|> (/.result /.any (list expected))
- (!expect (^.multi {try.#Success actual}
- (# synthesis.equivalence = expected actual))))))
- (_.cover [/.empty_input]
- (|> (/.result /.any (list))
- (!expect (^.multi {try.#Failure error}
- (exception.match? /.empty_input error)))))
+ (_.coverage [/.result /.any]
+ (|> (/.result /.any (list expected))
+ (!expect (^.multi {try.#Success actual}
+ (# synthesis.equivalence = expected actual))))))
+ (_.coverage [/.empty_input]
+ (|> (/.result /.any (list))
+ (!expect (^.multi {try.#Failure error}
+ (exception.match? /.empty_input error)))))
(do [! random.monad]
[expected (# ! each (|>> synthesis.i64) random.i64)]
- (_.cover [/.unconsumed_input]
- (|> (/.result /.any (list expected expected))
- (!expect (^.multi {try.#Failure error}
- (exception.match? /.unconsumed_input error))))))
+ (_.coverage [/.unconsumed_input]
+ (|> (/.result /.any (list expected expected))
+ (!expect (^.multi {try.#Failure error}
+ (exception.match? /.unconsumed_input error))))))
(do [! random.monad]
[dummy (# ! each (|>> synthesis.i64) random.i64)]
- (_.cover [/.end /.expected_empty_input]
- (and (|> (/.result /.end (list))
- (!expect {try.#Success _}))
- (|> (/.result /.end (list dummy))
- (!expect (^.multi {try.#Failure error}
- (exception.match? /.expected_empty_input error)))))))
+ (_.coverage [/.end /.expected_empty_input]
+ (and (|> (/.result /.end (list))
+ (!expect {try.#Success _}))
+ (|> (/.result /.end (list dummy))
+ (!expect (^.multi {try.#Failure error}
+ (exception.match? /.expected_empty_input error)))))))
(do [! random.monad]
[dummy (# ! each (|>> synthesis.i64) random.i64)]
- (_.cover [/.end?]
- (and (|> (/.result /.end? (list))
- (!expect {try.#Success #1}))
- (|> (/.result (<>.before /.any /.end?) (list dummy))
- (!expect {try.#Success #0})))))
+ (_.coverage [/.end?]
+ (and (|> (/.result /.end? (list))
+ (!expect {try.#Success #1}))
+ (|> (/.result (<>.before /.any /.end?) (list dummy))
+ (!expect {try.#Success #0})))))
(_.for [/.cannot_parse]
(all _.and
..simple
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-22 23:25:03 +0000