1 files changed, 101 insertions, 0 deletions
diff --git a/stdlib/source/test/lux/world/time/month.lux b/stdlib/source/test/lux/world/time/month.lux
new file mode 100644
index 000000000..c87a956cd
--- /dev/null
+++ b/stdlib/source/test/lux/world/time/month.lux
@@ -0,0 +1,101 @@
+(.require
+ [library
+  [lux (.except)
+   ["_" test (.only Test)]
+   [abstract
+    [monad (.only do)]
+    [\\specification
+     ["$[0]" equivalence]
+     ["$[0]" hash]
+     ["$[0]" order]
+     ["$[0]" enum]
+     ["$[0]" codec]]]
+   [control
+    ["[0]" try (.use "[1]#[0]" functor)]
+    ["[0]" exception]
+    [function
+     ["[0]" predicate]]]
+   [data
+    [collection
+     ["[0]" set]
+     ["[0]" list (.use "[1]#[0]" functor mix)]]]
+   [math
+    ["[0]" random (.only Random)]
+    [number
+     ["n" nat]]]]]
+ [\\library
+  ["[0]" / (.only)
+   [//
+    ["[0]" duration]]]])
+
+(def .public random
+  (Random /.Month)
+  (let [december (/.number {/.#December})]
+    (|> random.nat
+        (at random.monad each (|>> (n.% december) ++))
+        (random.one (|>> /.by_number try.maybe)))))
+
+(def .public test
+  Test
+  (<| (_.covering /._)
+      (_.for [/.Month])
+      (all _.and
+           (_.for [/.equivalence]
+                  ($equivalence.spec /.equivalence ..random))
+           (_.for [/.hash]
+                  ($hash.spec /.hash ..random))
+           (_.for [/.order]
+                  ($order.spec /.order ..random))
+           (_.for [/.enum]
+                  ($enum.spec /.enum ..random))
+           (_.for [/.codec]
+                  ($codec.spec /.equivalence /.codec ..random))
+
+           (do random.monad
+             [expected ..random
+              invalid (random.only (predicate.or (n.< (/.number {/.#January}))
+                                                 (n.> (/.number {/.#December})))
+                                   random.nat)]
+             (all _.and
+                  (_.coverage [/.number /.by_number]
+                    (|> expected
+                        /.number
+                        /.by_number
+                        (try#each (at /.equivalence = expected))
+                        (try.else false)))
+                  (_.coverage [/.invalid_month]
+                    (case (/.by_number invalid)
+                      {try.#Failure error}
+                      (exception.match? /.invalid_month error)
+                      
+                      {try.#Success _}
+                      false))
+                  (_.coverage [/.year]
+                    (let [all (list.size /.year)
+                          uniques (set.size (set.of_list /.hash /.year))]
+                      (and (n.= (/.number {/.#December})
+                                all)
+                           (n.= all
+                                uniques))))
+                  (_.coverage [/.days]
+                    (let [expected (.nat (duration.ticks duration.day duration.normal_year))]
+                      (|> /.year
+                          (list#each /.days)
+                          (list#mix n.+ 0)
+                          (n.= expected))))
+                  (_.coverage [/.leap_year_days]
+                    (let [expected (.nat (duration.ticks duration.day duration.leap_year))]
+                      (|> /.year
+                          (list#each /.leap_year_days)
+                          (list#mix n.+ 0)
+                          (n.= expected))))
+                  (do random.monad
+                    [not_a_month (random.upper_case 1)]
+                    (_.coverage [/.not_a_month_of_the_year]
+                      (case (at /.codec decoded not_a_month)
+                        {try.#Failure error}
+                        (exception.match? /.not_a_month_of_the_year error)
+                        
+                        {try.#Success _}
+                        false)))
+                  )))))