week3/camil/StdSortListTest.icl

   1 module StdSortListTest
   2
   3 /*      Test module StdSortList
   4         Voor werken met Gast:
   5                 (*) gebruik Environment 'Gast'
   6                 (*) zet Project Options op 'Basic Values Only' en '16M' Maximum Heap Size.
   7 */
   8
   9 import gast
  10 import GenLexOrd
  11 import StdSortList
  12
  13 Start = testn 10000
  14                 (\n` n2` m -> let       n  = lst2slst (cast [A,B,C] n` )
  15                                                         n2 = lst2slst (cast [A,B,C] n2`)
  16                                    in
  17                                                         leeg_is_leeg                   /\
  18                                                         count_matches_elems     n      /\
  19                                                         is_sorted_elems         n      /\
  20                                                         member_is_member        n m    /\
  21                                                         member_na_insert        n m    /\
  22                                                         member_na_remove        n m    /\
  23                                                         insert_remove_invariant n m    /\
  24                                                         minimum_property        n      /\
  25                                                         maximum_property        n      /\
  26                                                         merge_additive          n n2   /\
  27                                                         merge_member            n n2 m /\
  28                                                         True
  29                 )
  30
  31 :: Enum = A | B | C
  32
  33 derive bimap []
  34 derive ggen Enum
  35 derive genShow Enum
  36 derive gEq Enum
  37 derive gLexOrd Enum
  38 instance == Enum where (==) x y = gEq{|*|} x y
  39 instance <  Enum where  (<) x y = gEq{|*|} (gLexOrd{|*|} x y) LT
  40
  41 // clean should have something like this!
  42 cast :: a a -> a
  43 cast _ x = x
  44
  45 leeg_is_leeg :: Property
  46 leeg_is_leeg
  47  = name "leeg_is_leeg"
  48     (count newSortList == 0)
  49
  50 count_matches_elems :: (SortList a) -> Property | Eq, Ord a
  51 count_matches_elems n
  52  = name "count_matches_elems"
  53     (length (elements n) == count n)
  54
  55 is_sorted_elems :: (SortList a) -> Property | Eq, Ord a
  56 is_sorted_elems n
  57  = name "is_sorted_elems"
  58     (isSorted (elements n))
  59     where isSorted lst = and [ x<=y \\ x<-lst & y<-tl lst ]
  60
  61 member_is_member :: (SortList a) a -> Property | Eq, Ord a
  62 member_is_member lst e
  63  = name "member_is_member"
  64     ((isMember e (elements lst)) <==> (memberSort e lst))
  65
  66 member_na_insert :: (SortList a) a -> Property | Eq, Ord a
  67 member_na_insert lst e
  68  = name "member_na_insert"
  69     (memberSort e (insertSort e lst))
  70
  71 member_na_remove :: (SortList a) a -> Property | Eq, Ord a
  72 member_na_remove lst e
  73  = name "member_na_remove"
  74     (not (memberSort e (removeAll e lst)))
  75
  76 insert_remove_invariant :: (SortList a) a -> Property | Eq, Ord a
  77 insert_remove_invariant lst e
  78  = name "insert_remove_invariant"
  79     (memberSort e lst <==> memberSort e lst`)
  80     where lst` = removeFirst e (insertSort e lst)
  81
  82 minimum_property :: (SortList a) -> Property | Eq,Ord a
  83 minimum_property n
  84  = name "minimum_property"
  85     (count n > 0 ==> (memberSort min n /\ all ((<=) min) (elements n)))
  86     where min = minimum n
  87
  88 maximum_property :: (SortList a) -> Property | Eq,Ord a
  89 maximum_property n
  90  = name "maximum_property"
  91     (count n > 0 ==> (memberSort max n /\ all ((>=) max) (elements n)))
  92     where max = maximum n
  93
  94 merge_member :: (SortList a) (SortList a) a -> Property | Eq,Ord a
  95 merge_member n m e
  96  = name "merge_member"
  97         (memberSort e nm <==> (memberSort e n \/ memberSort e m))
  98         where nm = mergeSortList n m
  99
 100 merge_additive :: (SortList a) (SortList a) -> Property | Eq,Ord a
 101 merge_additive n m
 102  = name "merge_additive"
 103         (count n + count m == count nm)
 104         where nm = mergeSortList n m
 105
 106 lst2slst :: [a] -> SortList a | Eq,Ord a
 107 lst2slst xs = seq (map insertSort xs) newSortList