1 files changed, 128 insertions, 0 deletions
diff --git a/stdlib/source/test/lux/data/color/rgb.lux b/stdlib/source/test/lux/data/color/rgb.lux
new file mode 100644
index 000000000..5781c9efa
--- /dev/null
+++ b/stdlib/source/test/lux/data/color/rgb.lux
@@ -0,0 +1,128 @@
+(.require
+ [library
+  [lux (.except)
+   [abstract
+    [monad (.only do)]
+    [\\specification
+     ["[0]S" equivalence]
+     ["[0]S" hash]
+     ["[0]S" monoid]]]
+   [control
+    ["[0]" try (.use "[1]#[0]" functor)]
+    ["[0]" exception]]
+   [math
+    ["[0]" random (.only Random) (.use "[1]#[0]" functor)]
+    [number
+     ["n" nat]]]
+   [test
+    ["_" property (.only Test)]]]]
+ [\\library
+  ["[0]" /]])
+
+(def .public value
+  (Random /.Value)
+  (random.one (|>> (n.% /.limit)
+                   /.value
+                   try.maybe)
+              random.nat))
+
+(def .public random
+  (Random /.RGB)
+  (do random.monad
+    [red ..value
+     green ..value
+     blue ..value]
+    (in [/.#red red
+         /.#green green
+         /.#blue blue])))
+
+(def .public test
+  Test
+  (<| (_.covering /._)
+      (do [! random.monad]
+        [expected_value ..value
+         expected ..random])
+      (all _.and
+           (_.for [/.Value]
+                  (all _.and
+                       (_.coverage [/.number /.value]
+                         (|> expected_value
+                             /.number
+                             /.value
+                             (try#each (|>> /.number
+                                            (n.= (/.number expected_value))))
+                             (try.else false)))
+                       (_.coverage [/.limit]
+                         (and (when (/.value /.limit)
+                                {try.#Failure _} true
+                                {try.#Success _} false)
+                              (when (/.value (-- /.limit))
+                                {try.#Failure _} false
+                                {try.#Success _} true)))
+                       (_.coverage [/.least]
+                         (when (/.value (++ (/.number /.least)))
+                           {try.#Failure _} false
+                           {try.#Success _} true))
+                       (_.coverage [/.most]
+                         (when (/.value (-- (/.number /.most)))
+                           {try.#Failure _} false
+                           {try.#Success _} true))
+                       (_.coverage [/.invalid]
+                         (and (when (/.value (-- (/.number /.least)))
+                                {try.#Failure it} (exception.match? /.invalid it)
+                                {try.#Success _} false)
+                              (when (/.value (++ (/.number /.most)))
+                                {try.#Failure it} (exception.match? /.invalid it)
+                                {try.#Success _} false)))
+                       ))
+           (_.for [/.RGB]
+                  (all _.and
+                       (_.for [/.equivalence]
+                              (equivalenceS.spec /.equivalence ..random))
+                       (_.for [/.hash]
+                              (hashS.spec /.hash ..random))
+                       (_.for [/.addition]
+                              (monoidS.spec /.equivalence /.addition ..random))
+                       (_.for [/.subtraction]
+                              (monoidS.spec /.equivalence /.subtraction ..random))
+
+                       (_.coverage [/.rgb]
+                         (`` (and (let [red (/.number expected_value)
+                                        green (/.number expected_value)
+                                        blue (/.number expected_value)]
+                                    (when (/.rgb red green blue)
+                                      {try.#Failure _}
+                                      false
+                                      
+                                      {try.#Success it}
+                                      (and (n.= (/.number expected_value)
+                                                (/.number (the /.#red it)))
+                                           (n.= (/.number expected_value)
+                                                (/.number (the /.#green it)))
+                                           (n.= (/.number expected_value)
+                                                (/.number (the /.#blue it))))))
+                                  (,, (with_template [<red_offset> <green_offset> <blue_offset>]
+                                        [(let [red (n.+ <red_offset> (/.number expected_value))
+                                               green (n.+ <green_offset> (/.number expected_value))
+                                               blue (n.+ <blue_offset> (/.number expected_value))]
+                                           (when (/.rgb red green blue)
+                                             {try.#Failure it}
+                                             (exception.match? /.invalid it)
+                                             
+                                             {try.#Success _}
+                                             false))]
+
+                                        [/.limit 0 0]
+                                        [0 /.limit 0]
+                                        [0 0 /.limit]
+                                        )))))
+                       (_.coverage [/.complement]
+                         (let [~expected (/.complement expected)
+                               (open "/#[0]") /.equivalence]
+                           (and (not (/#= expected ~expected))
+                                (/#= expected (/.complement ~expected)))))
+                       (_.coverage [/.black /.white]
+                         (and (at /.equivalence = /.white (/.complement /.black))
+                              (at /.equivalence = /.black (/.complement /.white))))
+                       ))
+           )))