files/practicum/LijstGeneratorTest.icl

   1 module LijstGeneratorTest
   2
   3 /*      Test module LijstGenerator
   4         Voor werken met Gast:
   5                 (*) gebruik Environment 'Gast'
   6                 (*) zet Project Options op 'Basic Values Only' en '2M' Maximum Heap Size
   7 */
   8
   9 import gast
  10 import LijstGenerator
  11
  12 Start
  13                                                                                                 = testn 1000
  14                                                                                                         (\x y z ->
  15                                                                                                            eersten_gelijk                           x     /\
  16                                                                                                            vanaf_verhoogt_met_one                   x     /\
  17                                                                                                            vanaf_met_stap_verhoogt_met_stap         x y   /\
  18                                                                                                            vanaf_tot_verhoogt_met_one               x y   /\
  19                                                                                                            vanaf_tot_met_stap_verhoogt_met_stap     x y z /\
  20                                                                                                            vanaf_tot_met_stap_0_is_leeg             x y   /\
  21                                                                                                            True
  22                                                                                                         )
  23
  24 max_list_length                                                                 = 1000
  25
  26 eersten_gelijk                                                                  :: Int -> Property
  27 eersten_gelijk x                                                                = name "eersten in lijst zijn gelijk"
  28                                                                                                (let l` = take max_list_length (allemaal x)
  29                                                                                                     n  = length l`
  30                                                                                                  in n == max_list_length && all ((==) x) l`
  31                                                                                                )
  32
  33 vanaf_verhoogt_met_one                                                  :: Int -> Property
  34 vanaf_verhoogt_met_one x                                                = name "vanaf verhoogt met one"
  35                                                                                            (let l` = take max_list_length (vanaf x)
  36                                                                                                     n  = length l`
  37                                                                                              in n == max_list_length && all ((==) one) (verschil l`)
  38                                                                                            )
  39
  40 vanaf_met_stap_verhoogt_met_stap                                :: Int Int -> Property
  41 vanaf_met_stap_verhoogt_met_stap x y                    = name "vanaf_met_stap verhoogt met stap"
  42                                                                                            (let l` = take max_list_length (vanaf_met_stap x y)
  43                                                                                                     n  = length l`
  44                                                                                              in n == max_list_length && all ((==) y) (verschil l`)
  45                                                                                            )
  46
  47 vanaf_tot_verhoogt_met_one                                              :: Int Int -> Property
  48 vanaf_tot_verhoogt_met_one x y                                  = name "vanaf_tot verhoogt met one"
  49                                                                                            (let l` = take max_list_length (vanaf_tot x y)
  50                                                                                                 n  = length l`
  51                                                                                              in if (x > y) (n == 0) (all ((==) one) (verschil l`))
  52                                                                                            )
  53
  54 vanaf_tot_met_stap_verhoogt_met_stap                    :: Int Int Int -> Property
  55 vanaf_tot_met_stap_verhoogt_met_stap x y z      = name "vanaf_tot_met_stap verhoogt met stap"
  56                                                                                            (ok ==> let l` = take max_list_length (vanaf_tot_met_stap x y z)
  57                                                                                                        n  = length l`
  58                                                                                                     in if (x <= y && z > 0) (all ((==) z) (verschil l`))
  59                                                                                                       (if (x >= y && z < 0) (all ((==) z) (verschil l`))
  60                                                                                                                             (n == 0)
  61                                                                                                       )
  62                                                                                            )
  63         where ok = z <> 0
  64                      &&
  65                    all (\x->x <> abs x || x==0) [abs x, abs y, abs z]
  66
  67 vanaf_tot_met_stap_0_is_leeg                                    :: Int Int -> Property
  68 vanaf_tot_met_stap_0_is_leeg x y                                = name "vanaf_tot_met stap 0 is leeg"
  69                                                                                            (isEmpty (vanaf_tot_met_stap x y 0))
  70
  71 verschil                                                                                :: [a] -> [a] | - a
  72 verschil [a,b:as]                                                               = [b-a : verschil [b:as]]
  73 verschil _                                                                              = []