ocean-lang.org Git - ocean/blob - csrc/oceani-tests.mdc

   1 # Ocean Interpreter test code
   2
   3 Regular testing is, of course, important for developing any software.
   4 The Ocean interpreted is no exception.  This document allows easy
   5 testing by providing:
   6
   7 - a collection of test program
   8 - the expected output of these programs when run with various arguments
   9 - some "Makefile" code to tie it all together.
  10
  11 Three different sorts of tests are run.  As soon as any fail, the whole
  12 test stops.
  13
  14 1/ Each program is run and the output is compared against the expected
  15     output
  16 2/ Each program is then run under valgrind, and an error is reported
  17     if valgrind detects an error, or if it reports and lost or unfreed
  18     memory.
  19 3/ Each program is parsed and printed, then the result is parsed and printed.
  20     The two results must match.
  21 4/ Each program is run with a version of `oceani` with test-coverage
  22     recording enabled.  Once all programs have successfully run and
  23     all the coverage data is available, we check that all lines have
  24     been tested at least once. A few exceptions are allowed such as
  25     lines that call `abort()`.  If any non-exceptional lines have not
  26     been run, this final test fails.
  27     Until the tests suite is (more) completed, we only throw and error
  28     if fewer than 75% of the lines have been tested.
  29
  30 Each test has a name, which used to identify the section in this file, and optionally some
  31 arguments separated from the name by commas.  For each test, there is a section named
  32 "output:" followed by the name-and-arguments.
  33
  34 ###### File: oceani-tests.mk
  35
  36         oceani_tests :=
  37         ## test list
  38
  39         tests:: oceani_test_suite
  40         oceani_test_suite: oceani coverage_oceani
  41                 @rm -rf coverage; mkdir -p coverage
  42                 @cp *.gcno coverage
  43                 @for T in $(oceani_tests); do \
  44                     echo -n "Test $$T ... "; \
  45                     i="$$IFS"; IFS=,; set $$T; IFS="$$i"; t=$$1; shift; \
  46                     ./md2c oceani-tests.mdc "output: $$T" | grep -v '^#' > .tmp.want; \
  47                     ./oceani --section "test: $$t" oceani-tests.mdc $${1+"$$@"} > .tmp.have; \
  48                     if ! cmp -s .tmp.want .tmp.have; then \
  49                        echo "FAILED"; diff -u .tmp.want .tmp.have ; exit 1; fi ;\
  50                     echo -n "passed ... "; \
  51                     if ! valgrind ./oceani --section "test: $$t" oceani-tests.mdc $${1+"$$@"} \
  52                          > /dev/null 2> .tmp.valg; then \
  53                        echo "valgrind FAILED"; cat .tmp.valg; exit 1; fi ; \
  54                     echo -n "valgrind passed ... "; \
  55                     echo '``````' > .tmp.code1; echo '``````' > .tmp.code2 ;\
  56                     ./oceani --noexec --print --section "test: $$t" oceani-tests.mdc >> .tmp.code1; \
  57                     ./oceani --noexec --print .tmp.code1 >> .tmp.code2 ;\
  58                     if ! cmp -s .tmp.code1 .tmp.code2; then \
  59                        echo "Printing Failed"; diff -u .tmp.code1 .tmp.code2; exit1 ; fi ; \
  60                     echo "Printing passed"; \
  61                     ./coverage_oceani --print --section "test: $$t" oceani-tests.mdc $${1+"$$@"} > /dev/null ; \
  62                     ./coverage_oceani -tpbn --section "test: $$t" oceani-tests.mdc > /dev/null 2>&1; \
  63                 done
  64
  65                 ## test code
  66
  67                 @gcov -o coverage oceani.mdc > /dev/null 2> /dev/null
  68                 @mv *.gcov coverage ; [ -f .gcov ] && mv .gcov coverage
  69                 @ awk '/^ *[1-9]/ {ran+=1} /^ *###/ {skip+=1} \
  70                     END {printf "coverage: %6.2f%%\n", ran * 100 / (ran + skip); \
  71                          if (ran < (ran + skip) *0.75) exit(1) }' \
  72                         coverage/oceani.mdc.gcov
  73                 @rm -f .tmp*
  74
  75         coverage_oceani: oceani.c
  76                 $(CC) $(CFLAGS) --coverage -fprofile-dir=coverage -o coverage_oceani oceani.c $(LDLIBS)
  77
  78 ## Values and variables
  79
  80 The first test stores values in variables and performs various
  81 calculations on them.
  82
  83 ###### test list
  84        oceani_tests += "valvar"
  85
  86
  87 ###### test: valvar
  88
  89         program:
  90                 a := 23; b:=12
  91                 print a, b, a+b, a-b, a*b, a/b, a%b
  92                 print a<b, a<=b, a>b, a>=b, a<a, a==b, a==a
  93
  94                 c ::= "This is a string"
  95                 d ::= " field theory"
  96                 print c, d, c++d
  97
  98 ###### output: valvar
  99
 100         23 12 35 11 276 1.91667 11
 101         False False True True False False True
 102         This is a string  field theory This is a string field theory
 103
 104 Next we change the value of variables
 105
 106 ###### test list
 107        oceani_tests += "setvar"
 108
 109 ###### test: setvar
 110
 111         program:
 112                 a := 4
 113                 a = a * a
 114                 a = (a + a) * (a + a)
 115                 a = a * a * a
 116                 print a, a/a
 117
 118 ###### output: setvar
 119         1.07374e+09 1
 120
 121 ## Conditions and Loops
 122
 123 Now we need to test if/else and some different loops
 124
 125 ###### test list
 126        oceani_tests += cond_loop
 127
 128 ###### test: cond_loop
 129
 130         program:
 131                 a := 4
 132                 if a < 5:
 133                         print "Success"
 134                 else:
 135                         print "Failure"
 136                 for b:=1; then b=b+b; while b < 100:
 137                         print '', b,
 138                 print
 139                 // Newtons method for square root of 2
 140                 target ::= 2
 141                 guess := target
 142                 for:
 143                         count: number = 0
 144                 while:
 145                         current := guess * guess
 146                         use +(current - target) > 0.000000001
 147                 do:
 148                         guess = (guess + (target / guess) ) / 2
 149                         print count, guess
 150                         count = count + 1
 151                 print "error is ", target - guess * guess
 152
 153 ###### output: cond_loop
 154         Success
 155          1 2 4 8 16 32 64
 156         0 1.5
 157         1 1.41667
 158         2 1.41422
 159         3 1.41421
 160         error is  -4.51095e-12
 161
 162 ## Say Hello
 163
 164 The demonstration code presented in the interpreted is suitable for the test suite.
 165 Here I break it into two parts, keeping the array code separate.
 166
 167 ###### test list
 168         oceani_tests += "sayhello,55,33"
 169         oceani_tests += "sayhello,12,60"
 170
 171 ###### test: sayhello
 172
 173         program A B:
 174                 print "Hello World, what lovely oceans you have!"
 175                 /* When a variable is defined in both branches of an 'if',
 176                  * and used afterwards, the variables are merged.
 177                  */
 178                 if A > B:
 179                         bigger := "yes"
 180                 else:
 181                         bigger := "no"
 182                 print "Is", A, "bigger than", B,"? ", bigger
 183                 /* If a variable is not used after the 'if', no
 184                  * merge happens, so types can be different
 185                  */
 186                 if A > B * 2:
 187                         double:string = "yes"
 188                         print A, "is more than twice", B, "?", double
 189                 else:
 190                         double := B*2
 191                         print "double", B, "is", double
 192
 193                 a : number
 194                 a = A;
 195                 b:number = B
 196                 if a > 0 and b > 0:
 197                         while a != b:
 198                                 if a < b:
 199                                         b = b - a
 200                                 else:
 201                                         a = a - b
 202                         print "GCD of", A, "and", B,"is", a
 203                 else if a <= 0:
 204                         print a, "is not positive, cannot calculate GCD"
 205                 else:
 206                         print b, "is not positive, cannot calculate GCD"
 207
 208                 for:
 209                         togo := 10
 210                         f1 := 1; f2 := 1
 211                         print "Fibonacci:", f1,f2,
 212                 then togo = togo - 1
 213                 while togo > 0:
 214                         f3 := f1 + f2
 215                         print "", f3,
 216                         f1 = f2
 217                         f2 = f3
 218                 print ""
 219
 220                 /* Binary search... */
 221                 for:
 222                         lo:= 0; hi := 100
 223                         target := 77
 224                 while:
 225                         mid := (lo + hi) / 2
 226                         if mid == target:
 227                                 use Found
 228                         if mid < target:
 229                                 lo = mid
 230                         else:
 231                                 hi = mid
 232                         if hi - lo < 1:
 233                                 use GiveUp
 234                         use True
 235                 do: pass
 236                 case Found:
 237                         print "Yay, I found", target
 238                 case GiveUp:
 239                         print "Closest I found was", mid
 240
 241 ###### output: sayhello,55,33
 242         Hello World, what lovely oceans you have!
 243         Is 55 bigger than 33 ?  yes
 244         double 33 is 66
 245         GCD of 55 and 33 is 11
 246         Fibonacci: 1 1 2 3 5 8 13 21 34 55 89 144
 247         Closest I found was 77.3438
 248
 249 ###### output: sayhello,12,60
 250         Hello World, what lovely oceans you have!
 251         Is 12 bigger than 60 ?  no
 252         double 60 is 120
 253         GCD of 12 and 60 is 12
 254         Fibonacci: 1 1 2 3 5 8 13 21 34 55 89 144
 255         Closest I found was 77.3438
 256
 257 ###### test list
 258         oceani_tests += "insert_sort"
 259 ###### test: insert_sort
 260         program:
 261                 size::=55
 262                 list:[size]number
 263                 list[0] = 1234
 264                 for i:=1; then i = i + 1; while i < size:
 265                         n := list[i-1] * list[i-1]
 266                         list[i] = (n / 100) % 10000
 267
 268                 print "Before sort:"
 269                 for i:=0; then i = i + 1; while i < size:
 270                         print "list[",i,"]=",list[i]
 271
 272                 for i := 1; then i=i+1; while i < size:
 273                         for j:=i-1; then j=j-1; while j >= 0:
 274                                 if list[j] > list[j+1]:
 275                                         t:= list[j]
 276                                         list[j] = list[j+1]
 277                                         list[j+1] = t
 278                 print "After sort:"
 279                 for i:=0; then i = i + 1; while i < size:
 280                         print "list[",i,"]=",list[i]
 281
 282 ###### output: insert_sort
 283         Before sort:
 284         list[ 0 ]= 1234
 285         list[ 1 ]= 5227
 286         list[ 2 ]= 3215
 287         list[ 3 ]= 3362
 288         list[ 4 ]= 3030
 289         list[ 5 ]= 1809
 290         list[ 6 ]= 2724
 291         list[ 7 ]= 4201
 292         list[ 8 ]= 6484
 293         list[ 9 ]= 422
 294         list[ 10 ]= 1780
 295         list[ 11 ]= 1684
 296         list[ 12 ]= 8358
 297         list[ 13 ]= 8561
 298         list[ 14 ]= 2907
 299         list[ 15 ]= 4506
 300         list[ 16 ]= 3040
 301         list[ 17 ]= 2416
 302         list[ 18 ]= 8370
 303         list[ 19 ]= 569
 304         list[ 20 ]= 3237
 305         list[ 21 ]= 4781
 306         list[ 22 ]= 8579
 307         list[ 23 ]= 5992
 308         list[ 24 ]= 9040
 309         list[ 25 ]= 7216
 310         list[ 26 ]= 706
 311         list[ 27 ]= 4984
 312         list[ 28 ]= 8402
 313         list[ 29 ]= 5936
 314         list[ 30 ]= 2360
 315         list[ 31 ]= 5696
 316         list[ 32 ]= 4444
 317         list[ 33 ]= 7491
 318         list[ 34 ]= 1150
 319         list[ 35 ]= 3225
 320         list[ 36 ]= 4006
 321         list[ 37 ]= 480
 322         list[ 38 ]= 2304
 323         list[ 39 ]= 3084
 324         list[ 40 ]= 5110
 325         list[ 41 ]= 1121
 326         list[ 42 ]= 2566
 327         list[ 43 ]= 5843
 328         list[ 44 ]= 1406
 329         list[ 45 ]= 9768
 330         list[ 46 ]= 4138
 331         list[ 47 ]= 1230
 332         list[ 48 ]= 5129
 333         list[ 49 ]= 3066
 334         list[ 50 ]= 4003
 335         list[ 51 ]= 240
 336         list[ 52 ]= 576
 337         list[ 53 ]= 3317
 338         list[ 54 ]= 24
 339         After sort:
 340         list[ 0 ]= 24
 341         list[ 1 ]= 240
 342         list[ 2 ]= 422
 343         list[ 3 ]= 480
 344         list[ 4 ]= 569
 345         list[ 5 ]= 576
 346         list[ 6 ]= 706
 347         list[ 7 ]= 1121
 348         list[ 8 ]= 1150
 349         list[ 9 ]= 1230
 350         list[ 10 ]= 1234
 351         list[ 11 ]= 1406
 352         list[ 12 ]= 1684
 353         list[ 13 ]= 1780
 354         list[ 14 ]= 1809
 355         list[ 15 ]= 2304
 356         list[ 16 ]= 2360
 357         list[ 17 ]= 2416
 358         list[ 18 ]= 2566
 359         list[ 19 ]= 2724
 360         list[ 20 ]= 2907
 361         list[ 21 ]= 3030
 362         list[ 22 ]= 3040
 363         list[ 23 ]= 3066
 364         list[ 24 ]= 3084
 365         list[ 25 ]= 3215
 366         list[ 26 ]= 3225
 367         list[ 27 ]= 3237
 368         list[ 28 ]= 3317
 369         list[ 29 ]= 3362
 370         list[ 30 ]= 4003
 371         list[ 31 ]= 4006
 372         list[ 32 ]= 4138
 373         list[ 33 ]= 4201
 374         list[ 34 ]= 4444
 375         list[ 35 ]= 4506
 376         list[ 36 ]= 4781
 377         list[ 37 ]= 4984
 378         list[ 38 ]= 5110
 379         list[ 39 ]= 5129
 380         list[ 40 ]= 5227
 381         list[ 41 ]= 5696
 382         list[ 42 ]= 5843
 383         list[ 43 ]= 5936
 384         list[ 44 ]= 5992
 385         list[ 45 ]= 6484
 386         list[ 46 ]= 7216
 387         list[ 47 ]= 7491
 388         list[ 48 ]= 8358
 389         list[ 49 ]= 8370
 390         list[ 50 ]= 8402
 391         list[ 51 ]= 8561
 392         list[ 52 ]= 8579
 393         list[ 53 ]= 9040
 394         list[ 54 ]= 9768
 395
 396 ## Test erroneous command line args
 397
 398 To improve coverage, we want to test correct handling of strange command
 399 line arguments.  These tests won't use code, so the exiting test types
 400 won't work.  So we need to be able to explicitly give the command line,
 401 and the expected output, and have that tested and the coverage assessed.
 402 Rather than having to spell out the whole command name, just give "cmd",
 403 and discard that.  Requiring but discarding the command make an empty
 404 command list possible.
 405
 406 ###### test code
 407         @for t in $(oceani_special_tests); do \
 408             echo -n "Test $$t ... ";\
 409             i="$$IFS"; IFS=,; set $$t; IFS="$$i"; shift ;\
 410             ./md2c oceani-tests.mdc "output: $$t" | grep -v '^#' > .tmp.want; \
 411             ./oceani $${1+"$$@"} > .tmp.have 2>&1 ;\
 412             if ! cmp -s .tmp.want .tmp.have; then \
 413                echo "FAILED"; diff -u .tmp.want .tmp.have ; exit 1; fi ;\
 414             echo  "passed"; \
 415             ./coverage_oceani $${1+"$$@"} > /dev/null 2>&1 ;\
 416         done || true
 417
 418
 419 ###### test list
 420         oceani_special_tests += "cmd"
 421         oceani_special_tests += "cmd,-zyx"
 422         oceani_special_tests += "cmd,nofile"
 423         oceani_special_tests += "cmd,/dev/null"
 424         oceani_special_tests += "cmd,--section,toast:nothing,oceani-tests.mdc"
 425
 426 ###### output: cmd
 427         oceani: no input file given
 428
 429 ###### output: cmd,-zyx
 430         ./oceani: invalid option -- 'z'
 431         Usage: oceani --trace --print --noexec --brackets--section=SectionName prog.ocn
 432
 433 ###### output: cmd,nofile
 434         oceani: cannot open nofile
 435
 436 ###### output: cmd,/dev/null
 437         oceani: could not find any code in /dev/null
 438
 439 ###### output: cmd,--section,toast:nothing,oceani-tests.mdc
 440         oceani: cannot find section toast:nothing
 441