home *** CD-ROM | disk | FTP | other *** search
/ ftp.cs.arizona.edu / ftp.cs.arizona.edu.tar / ftp.cs.arizona.edu / icon / historic / v941.tgz / icon.v941src.tar / icon.v941src / tests / general / gener.icn < prev    next >
Text File  |  2001-12-06  |  3KB  |  142 lines
  1. #SRC: V9GEN
  2.  
  3. ##    gener.icn -- test generation in parallel with inserts/deletes
  4. #
  5. #     This is a torture test for the set generation code.  Items are inserted
  6. #     in or deleted from the set while the set is being generated.  We check
  7. #     every item not inserted or deleted is generated exactly once, and every
  8. #     other item is generated no more than once.
  9. #
  10. #     If every line of output says '[ok]', the test has passed.  "gener -v"
  11. #     gives a little more information; in this case, the output is sensitive
  12. #     to the runtime system's configuration parameters.
  13.  
  14.  
  15. global verbose
  16.  
  17.  
  18. procedure main (args)
  19.    if args[1] == "-v" then
  20.       verbose := 1
  21.    every tdel (41 | 619 | 991,  3 | 11 |  23)
  22.    every tins (40 | 103 | 233,  239 | 419 | 503,  3 | 11 | 23)
  23.    stale()
  24.    write ("[done]")
  25.    end
  26.  
  27.  
  28. ##  tins (init, limit, n) -- test insertions
  29. #
  30. #   The initial set consists of the integers 1 through <init>.
  31. #   Then the set is generated, and <n> more integers are added
  32. #   for each element generated until the set reaches <limit>
  33. #   entries.
  34.  
  35. procedure tins (init, limit, n)
  36.    writes ("test insert:",
  37.       right(init,6), ",", right(limit,5), ",", right(n,3))
  38.    s := set()
  39.    every insert (s, 1 to init)
  40.    s1 := copy (s)
  41.    l := list()
  42.    every put (l, e := !s) do
  43.       if *s < limit then
  44.          every 1 to n do
  45.             insert (s, *s + 1)
  46.    check (s1, s, l)
  47.    end
  48.  
  49.  
  50. ##  tdel (limit, n) -- test deletions
  51. #
  52. #   The set initially contains the first <limit> integers.
  53. #   Then, for each one generated, n elements are deleted.
  54.  
  55. procedure tdel (limit, n)
  56.    writes ("test delete:", right(limit,6), ",", right(n,5))
  57.    s := set()
  58.    every insert (s, 1 to limit)
  59.    s2 := copy(s)
  60.    l := list()
  61.    k := 0
  62.    every put (l, !s) do
  63.       every 1 to n do 
  64.          delete (s, k +:= 1)
  65.    check (s, s2, l)
  66.    end
  67.  
  68.  
  69.  
  70. ##  check (s1, s2, l) -- check results of generation
  71. #
  72. #   s1    small set (before insertion / after deletion)
  73. #   s2  large set (after insertion / before deletion)
  74. #   l   generated list
  75.  
  76. procedure check (s1, s2, l)
  77.    sg := set(l)
  78.    if \verbose then
  79.        writes ("  \tsizes ",right(*s1,5)," <=",right(*sg,5)," <=",right(*s2,5))
  80.    ok := "\t[ok]"
  81.  
  82.    if *(s := (s1 -- sg)) > 0 then {
  83.       writes ("\n not generated:")
  84.       every writes (" ", !sort(s))
  85.       ok := &null
  86.       }
  87.  
  88.    if *(s := (sg -- s2)) > 0 then {
  89.       writes ("\n unknown values generated:")
  90.       every writes (" ", !sort(s))
  91.       ok := &null
  92.       }
  93.  
  94.    if *sg < *l then {
  95.       writes("\n generated twice:")
  96.       every e := !l do
  97.          delete(sg,member(sg,e)) | writes (" ", e)
  98.       ok := &null
  99.    }
  100.  
  101.    write (ok)
  102.    end
  103.  
  104.  
  105.  
  106. ##  check for generation of stale (already deleted) elements of sets and tables
  107.  
  108. procedure stale()
  109.    local i, N, S, T
  110.  
  111.    N := 100
  112.    T := table()
  113.    S := set()
  114.  
  115.    write()
  116.    every i := 1 to N do {
  117.       T[i] := i
  118.       insert(S, i)
  119.       }
  120.  
  121.    write("checking !S:")
  122.    every i := !S do {
  123.       if not member(S, i) then write("S[", i, "] stale")
  124.       delete(S, ?N)
  125.       }
  126.  
  127.    write("checking !T:")
  128.    every i := !T do {
  129.       if /T[i] then write("T[", i, "] stale")
  130.       delete(T, ?N)
  131.       }
  132.  
  133.    write("checking key(T):")
  134.    every i := key(T) do {
  135.       if /T[i] then write("T[", i, "] stale")
  136.       delete(T, ?N)
  137.       }
  138.  
  139.    write()
  140.    return
  141. end
  142.