(.using
 [library
  [lux (.full)
   ["_" test (.only Test)]
   [abstract
    [monad (.only do)]
    [\\specification
     ["$[0]" equivalence]
     ["$[0]" functor (.only Injection)]]]
   [data
    ["[0]" bit ("[1]#[0]" equivalence)]
    [collection
     ["[0]" set]
     ["[0]" list ("[1]#[0]" monoid)]]]
   [math
    ["[0]" random]
    [number
     ["n" nat]]]]]
 [\\library
  ["[0]" /]])

(def: injection
  (Injection /.Queue)
  (|>> list /.of_list))

(def: .public test
  Test
  (<| (_.covering /._)
      (_.for [/.Queue])
      (do [! random.monad]
        [size (# ! each (n.% 100) random.nat)
         members (random.set n.hash size random.nat)
         non_member (random.only (|>> (set.member? members) not)
                                 random.nat)
         .let [members (set.list members)
               sample (/.of_list members)]]
        (all _.and
             (_.for [/.equivalence]
                    ($equivalence.spec (/.equivalence n.equivalence) (random.queue size random.nat)))
             (_.for [/.functor]
                    ($functor.spec ..injection /.equivalence /.functor))

             (_.coverage [/.of_list /.list]
               (|> members /.of_list /.list
                   (# (list.equivalence n.equivalence) = members)))
             (_.coverage [/.size]
               (n.= size (/.size sample)))
             (_.coverage [/.empty?]
               (bit#= (n.= 0 size) (/.empty? sample)))
             (_.coverage [/.empty]
               (let [empty_is_empty!
                     (/.empty? /.empty)

                     all_empty_queues_look_the_same!
                     (bit#= (/.empty? sample)
                            (# (/.equivalence n.equivalence) =
                               sample
                               /.empty))]
                 (and empty_is_empty!
                      all_empty_queues_look_the_same!)))
             (_.coverage [/.front]
               (case [members (/.front sample)]
                 [{.#Item head tail} {.#Some first}]
                 (n.= head first)
                 
                 [{.#End} {.#None}]
                 true

                 _
                 false))
             (_.coverage [/.member?]
               (let [every_member_is_identified!
                     (list.every? (/.member? n.equivalence sample)
                                  (/.list sample))

                     non_member_is_not_identified!
                     (not (/.member? n.equivalence sample non_member))]
                 (and every_member_is_identified!
                      non_member_is_not_identified!)))
             (_.coverage [/.end]
               (let [pushed (/.end non_member sample)

                     size_increases!
                     (n.= (++ (/.size sample)) (/.size pushed))

                     new_member_is_identified!
                     (/.member? n.equivalence pushed non_member)

                     has_expected_order!
                     (# (list.equivalence n.equivalence) =
                        (list#composite (/.list sample) (list non_member))
                        (/.list pushed))]
                 (and size_increases!
                      new_member_is_identified!
                      has_expected_order!)))
             (_.coverage [/.next]
               (case members
                 {.#Item target expected}
                 (let [popped (/.next sample)

                       size_decreases!
                       (n.= (-- (/.size sample))
                            (/.size popped))

                       popped_member_is_not_identified!
                       (not (/.member? n.equivalence popped target))

                       has_expected_order!
                       (# (list.equivalence n.equivalence) =
                          expected
                          (/.list popped))]
                   (and size_decreases!
                        popped_member_is_not_identified!
                        has_expected_order!))
                 
                 {.#End}
                 (and (/.empty? sample)
                      (/.empty? (/.next sample)))))
             ))))