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                 @echo -n Checking grammar ...
  42                 @./parsergen --report --LALR --tag Parser oceani.mdc | grep " - no conflicts" > /dev/null || \
  43                     { echo "Grammar contains conflicts, please review" ; exit 1; }
  44                 @echo ok
  45                 @rm -rf coverage; mkdir -p coverage
  46                 @cp *.gcno coverage
  47                 @for T in $(oceani_tests); do \
  48                     echo -n "Test $$T.. "; \
  49                     i="$$IFS"; IFS=,; set $$T; IFS="$$i"; t=$$1; shift; \
  50                     ./md2c oceani-tests.mdc "output: $$T" | grep -v '^#' > .tmp.want; \
  51                     ./oceani --section "test: $$t" oceani-tests.mdc $${1+"$$@"} > .tmp.have; \
  52                     if ! cmp -s .tmp.want .tmp.have; then \
  53                        echo "FAILED"; diff -u .tmp.want .tmp.have ; exit 1; fi ;\
  54                     echo -n "printing.. "; \
  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 || exit 1;\
  58                     if ! cmp -s .tmp.code1 .tmp.code2; then \
  59                        echo " Failed"; diff -u .tmp.code1 .tmp.code2; exit 1 ; fi ; \
  60                     echo -n "extra-newlines.. "; \
  61                     sed -e 'i\
  62                     ' .tmp.code1 > .tmp.code1a; \
  63                     echo '``````' > .tmp.code2a ;\
  64                     ./oceani --noexec --print .tmp.code1a >> .tmp.code2a || exit 1;\
  65                     if ! cmp -s .tmp.code1 .tmp.code2a; then \
  66                        echo " Failed"; diff -u .tmp.code1 .tmp.code2a; exit 1; fi ; \
  67                     echo -n "exec-after-print.. "; \
  68                     ./oceani .tmp.code1 $${1+"$$@"} > .tmp.have ; \
  69                     if ! cmp -s .tmp.want .tmp.have; then \
  70                        echo " FAILED"; diff -u .tmp.want .tmp.have; exit 1;fi; \
  71                     echo " all passed"; \
  72                     ./coverage_oceani --print --section "test: $$t" oceani-tests.mdc $${1+"$$@"} > /dev/null ; \
  73                     ./coverage_oceani -tpbn --section "test: $$t" oceani-tests.mdc > /dev/null 2>&1; \
  74                 done
  75
  76                 ## test code
  77
  78                 @for i in coverage/#*.gcda; do mv $$i coverage/$${i##*#}; done
  79                 @gcov -o coverage oceani.mdc > /dev/null 2> /dev/null
  80                 @mv *.gcov coverage ; [ -f .gcov ] && mv .gcov coverage || true
  81                 @[ -n "$$SKIP_COVERAGE_CHECK" ] || awk '/NOTEST/ { next } /^ *[1-9]/ {ran+=1} /^ *###/ {skip+=1} \
  82                     END {printf "coverage: %6.2f%%\n", ran * 100 / (ran + skip); \
  83                          if (ran < (ran + skip) *0.968) exit(1) }' \
  84                         coverage/oceani.mdc.gcov
  85                 @rm -f .tmp*
  86
  87                 @[ -n "$$SKIP_VALGRIND" ] || for T in $(oceani_tests); do \
  88                     echo -n "Valgrind $$T.. "; \
  89                     i="$$IFS"; IFS=,; set $$T; IFS="$$i"; t=$$1; shift; \
  90                     if ! valgrind --error-exitcode=1 --log-file=.tmp.valg ./oceani --section "test: $$t" oceani-tests.mdc $${1+"$$@"} \
  91                          > /dev/null 2>&1 ; then \
  92                        echo "FAILED"; cat .tmp.valg; exit 1; fi ; \
  93                     if grep 'LEAK SUMMARY' .tmp.valg > /dev/null; then \
  94                        echo "valgrind found LEAKS"; cat .tmp.valg ; exit 1 ; fi; \
  95                     if grep 'in use at exit [1-9]' .tmp.valg > /dev/null; then \
  96                        echo "valgrind found memory in use at exit"; cat .tmp.valg ; exit 1 ; fi; \
  97                     echo " passed"; \
  98                 done
  99
 100         coverage_oceani: oceani.c
 101                 $(CC) $(CFLAGS) --coverage -fprofile-dir=coverage -o coverage_oceani oceani.c $(LDLIBS)
 102
 103 ## Values and variables
 104
 105 The first test stores values in variables and performs various
 106 calculations on them.
 107
 108 ###### test list
 109        oceani_tests += "valvar"
 110
 111 ###### test: valvar
 112
 113         func main(argv:[argc::]string)
 114                 a := 23; b:=12 ; b1 := -b
 115                 print a, b, a+b, a-b, a*b, a/b, a%b
 116                 print a<b, a<=b, a>b, a>=b, a<a, a==b, a==a
 117                 print +a, +b, +b1, -a, -b, -b1
 118                 x := True; y := False
 119                 print x and y, x or y, x and x, y or y, x and not x, x < y
 120
 121                 c ::= "This is a string"
 122                 d ::= " field theory"
 123                 print c, d, c++d
 124
 125                 aconst :: string = "unchanging"
 126
 127                 // Check wrapping
 128                 print
 129                   a + b
 130                   + (a*2)
 131                   + b1
 132                   + b
 133
 134 ###### output: valvar
 135
 136         23 12 35 11 276 1.91667 11
 137         False False True True False False True
 138         23 12 12 -23 -12 12
 139         False True True False False False
 140         This is a string  field theory This is a string field theory
 141         81
 142
 143 Next we change the value of variables
 144
 145 ###### test list
 146        oceani_tests += "setvar"
 147
 148 ###### test: setvar
 149
 150         func main()
 151                 a := 4
 152                 a = a * a
 153                 a = (a + a) * (a + a)
 154                 a = a * a * a
 155                 print a, a/a
 156
 157 ###### output: setvar
 158         1.07374e+09 1
 159
 160 Now some contants
 161
 162 ###### test list
 163         oceani_tests += "consts"
 164
 165 ###### test: consts
 166         const
 167                 pi ::= 3.141 592 653
 168                 four ::= 2 + 2 ; five ::= 10/2
 169         const pie ::= "I like Pie";
 170                 cake ::= "The cake is"
 171                   ++ " a lie"
 172
 173         func main()
 174                 print "Hello World, what lovely oceans you have!"
 175                 print "are there", five, "?"
 176                 print pi, pie, "but", cake
 177
 178 ###### output: consts
 179         Hello World, what lovely oceans you have!
 180         are there 5 ?
 181         3.14159 I like Pie but The cake is a lie
 182
 183 Test merging of variables from multiple cases
 184
 185 ###### test list
 186         oceani_tests += varmerge
 187
 188 ###### test: varmerge
 189
 190         func main()
 191                 for i:=0; then i=i+1; while i < 5:
 192                         switch i:
 193                                 case 0: num:="zero"
 194                                 case 1: scratch:=42; num:="one"
 195                                 case 2: num:="two"
 196                                 case 3: num:="three"
 197                                 else    num:="many"
 198                         print num,", ",
 199                 print
 200
 201                 for i:=0; then i=i+1; while i < 5:
 202                         switch i:
 203                                 case 0: num:="zero"
 204                                 case 1: num:="one"
 205                                 case 2: num:="two"
 206                                 case 3: num:="three"
 207                                 else    num:="many"
 208                         // re-declare a CondScope variable
 209                         num := i*i
 210                         print num,", ",
 211                 print
 212
 213 ###### output: varmerge
 214         zero , one , two , three , many ,
 215         0 , 1 , 4 , 9 , 16 ,
 216
 217 ## Conditions and Loops
 218
 219 Now we need to test if/else and some different loops
 220
 221 ###### test list
 222        oceani_tests += cond_loop
 223
 224 ###### test: cond_loop
 225
 226         func main()
 227                 a := 4
 228                 if a < 5:
 229                         print "Success"
 230                 else
 231                         print "Failure"
 232                 for b:=1; then b=b+b; while b < 100:
 233                         print '', b,
 234                 print
 235                 // Newtons method for square root of 2
 236                 target ::= 2
 237                 guess := target
 238                 for
 239                         count: number = 0
 240                 while
 241                         current := guess * guess
 242                         use +(current - target) > 0.000000001
 243                 do
 244                         guess = (guess + (target / guess) ) / 2
 245                         print count, guess
 246                         count = count + 1
 247                 print "error is ", target - guess * guess
 248
 249                 for j:=0; then j = j+3 ; while j < 10:
 250                         if j != 0 and then 20 / j > 3:
 251                                 print "20 /", j," =", 20 / j
 252                         else
 253                                 print "I won't calculate 20 /", j
 254                 pi ::= 3.1415926535897
 255                 if 355/113 == pi or else +(pi - 355/113) < 0.001:
 256                         print "Close enough"
 257                 print "lower" if 355/113 < pi else "higher"
 258
 259                 if pi > 3 then print "pi exceeds three"; else print "need more pie"
 260                 if (pi < 3) { print "not enough pi" } else { print "pi sufficient" }
 261                 for { i := 0; sum := 0 }
 262                 then { i = i+1 }
 263                 while i <= 10:
 264                         sum = sum + i
 265                 else
 266                         pass
 267                         print "sum 1..10 is", sum
 268                 if
 269                         PI1 := 22/7
 270                         use PI1 < pi
 271                 then
 272                         print "Smaller"
 273                 else
 274                         print 'larger'
 275
 276 ###### output: cond_loop
 277         Success
 278          1 2 4 8 16 32 64
 279         0 1.5
 280         1 1.41667
 281         2 1.41422
 282         3 1.41421
 283         error is  -4.51095e-12
 284         I won't calculate 20 / 0
 285         20 / 3  = 6.66667
 286         20 / 6  = 3.33333
 287         I won't calculate 20 / 9
 288         Close enough
 289         higher
 290         pi exceeds three
 291         pi sufficient
 292         sum 1..10 is 55
 293         larger
 294
 295 ## Say Hello
 296
 297 The demonstration code presented in the interpreted is suitable for the test suite.
 298 Here I break it into two parts, keeping the array code separate.
 299
 300 ###### test list
 301         oceani_tests += "sayhello,55,33,hello,True"
 302         oceani_tests += "sayhello,12,60,there,False"
 303
 304 ###### test: sayhello
 305
 306         func main(av:[ac::number]string)
 307                 A := $av[1]; B := $av[2]
 308                 astr := av[3]
 309                 bbool := av[ac-1] == "True"
 310                 print "Hello World, what lovely oceans you have!"
 311                 /* When a variable is defined in both branches of an 'if',
 312                  * and used afterwards, the variables are merged.
 313                  */
 314                 if A > B:
 315                         bigger := "yes"
 316                 else
 317                         bigger := "no"
 318                 print "Is", A, "bigger than", B,"? ", bigger
 319                 /* If a variable is not used after the 'if', no
 320                  * merge happens, so types can be different
 321                  */
 322                 if A > B * 2:
 323                         double:string = "yes"
 324                         print A, "is more than twice", B, "?", double
 325                 else
 326                         double := B*2
 327                         print "double", B, "is", double
 328
 329                 a : number
 330                 a = A;
 331                 b:number = B
 332                 print "still", bigger // check for regression in scoping
 333                 if a > 0 and b > 0:
 334                         while a != b:
 335                                 if a < b:
 336                                         b = b - a
 337                                 else
 338                                         a = a - b
 339                         print "GCD of", A, "and", B,"is", a
 340                 else if a <= 0:
 341                         print a, "is not positive, cannot calculate GCD"
 342                 else
 343                         print b, "is not positive, cannot calculate GCD"
 344
 345                 for
 346                         togo := 10
 347                         f1 := 1; f2 := 1
 348                         print "Fibonacci:", f1,f2,
 349                 then togo = togo - 1
 350                 while togo > 0:
 351                         f3 := f1 + f2
 352                         print "", f3,
 353                         f1 = f2
 354                         f2 = f3
 355                 print ""
 356
 357                 if bbool:
 358                         print astr ++ " was the str"
 359                 else
 360                         print "I found the str over " ++ astr
 361
 362                 /* Binary search... */
 363                 for
 364                         lo:= 0; hi := 100
 365                         target := 77
 366                 while
 367                         mid := (lo + hi) / 2
 368                         if mid == target:
 369                                 use Found
 370                         if mid < target:
 371                                 lo = mid
 372                         else
 373                                 hi = mid
 374                         if hi - lo < 1:
 375                                 lo = mid
 376                                 use GiveUp
 377                         use True
 378                 do pass
 379                 case Found:
 380                         print "Yay, I found", target
 381                 case GiveUp:
 382                         print "Closest I found was", lo
 383
 384 ###### output: sayhello,55,33,hello,True
 385         Hello World, what lovely oceans you have!
 386         Is 55 bigger than 33 ?  yes
 387         double 33 is 66
 388         still yes
 389         GCD of 55 and 33 is 11
 390         Fibonacci: 1 1 2 3 5 8 13 21 34 55 89 144
 391         hello was the str
 392         Closest I found was 77.3438
 393
 394 ###### output: sayhello,12,60,there,False
 395         Hello World, what lovely oceans you have!
 396         Is 12 bigger than 60 ?  no
 397         double 60 is 120
 398         still no
 399         GCD of 12 and 60 is 12
 400         Fibonacci: 1 1 2 3 5 8 13 21 34 55 89 144
 401         I found the str over there
 402         Closest I found was 77.3438
 403
 404 ###### test list
 405         oceani_tests += "insert_sort"
 406 ###### test: insert_sort
 407         func main()
 408                 size::=55
 409                 list:[size]number
 410                 list[0] = 1_234
 411                 for i:=1; then i = i + 1; while i < size:
 412                         n := list[i-1] * list[i-1]
 413                         list[i] = (n / 100) % 10000
 414
 415                 print "Before sort:"
 416                 for i:=0; then i = i + 1; while i < size:
 417                         print "list[",i,"]=",list[i]
 418
 419                 for i := 1; then i=i+1; while i < size:
 420                         for j:=i-1; then j=j-1; while j >= 0:
 421                                 if list[j] > list[j+1]:
 422                                         t:= list[j]
 423                                         list[j] = list[j+1]
 424                                         list[j+1] = t
 425                 print "After sort:"
 426                 for i:=0; then i = i + 1; while i < size:
 427                         print "list[",i,"]=",list[i]
 428
 429 ###### output: insert_sort
 430         Before sort:
 431         list[ 0 ]= 1234
 432         list[ 1 ]= 5227
 433         list[ 2 ]= 3215
 434         list[ 3 ]= 3362
 435         list[ 4 ]= 3030
 436         list[ 5 ]= 1809
 437         list[ 6 ]= 2724
 438         list[ 7 ]= 4201
 439         list[ 8 ]= 6484
 440         list[ 9 ]= 422
 441         list[ 10 ]= 1780
 442         list[ 11 ]= 1684
 443         list[ 12 ]= 8358
 444         list[ 13 ]= 8561
 445         list[ 14 ]= 2907
 446         list[ 15 ]= 4506
 447         list[ 16 ]= 3040
 448         list[ 17 ]= 2416
 449         list[ 18 ]= 8370
 450         list[ 19 ]= 569
 451         list[ 20 ]= 3237
 452         list[ 21 ]= 4781
 453         list[ 22 ]= 8579
 454         list[ 23 ]= 5992
 455         list[ 24 ]= 9040
 456         list[ 25 ]= 7216
 457         list[ 26 ]= 706
 458         list[ 27 ]= 4984
 459         list[ 28 ]= 8402
 460         list[ 29 ]= 5936
 461         list[ 30 ]= 2360
 462         list[ 31 ]= 5696
 463         list[ 32 ]= 4444
 464         list[ 33 ]= 7491
 465         list[ 34 ]= 1150
 466         list[ 35 ]= 3225
 467         list[ 36 ]= 4006
 468         list[ 37 ]= 480
 469         list[ 38 ]= 2304
 470         list[ 39 ]= 3084
 471         list[ 40 ]= 5110
 472         list[ 41 ]= 1121
 473         list[ 42 ]= 2566
 474         list[ 43 ]= 5843
 475         list[ 44 ]= 1406
 476         list[ 45 ]= 9768
 477         list[ 46 ]= 4138
 478         list[ 47 ]= 1230
 479         list[ 48 ]= 5129
 480         list[ 49 ]= 3066
 481         list[ 50 ]= 4003
 482         list[ 51 ]= 240
 483         list[ 52 ]= 576
 484         list[ 53 ]= 3317
 485         list[ 54 ]= 24
 486         After sort:
 487         list[ 0 ]= 24
 488         list[ 1 ]= 240
 489         list[ 2 ]= 422
 490         list[ 3 ]= 480
 491         list[ 4 ]= 569
 492         list[ 5 ]= 576
 493         list[ 6 ]= 706
 494         list[ 7 ]= 1121
 495         list[ 8 ]= 1150
 496         list[ 9 ]= 1230
 497         list[ 10 ]= 1234
 498         list[ 11 ]= 1406
 499         list[ 12 ]= 1684
 500         list[ 13 ]= 1780
 501         list[ 14 ]= 1809
 502         list[ 15 ]= 2304
 503         list[ 16 ]= 2360
 504         list[ 17 ]= 2416
 505         list[ 18 ]= 2566
 506         list[ 19 ]= 2724
 507         list[ 20 ]= 2907
 508         list[ 21 ]= 3030
 509         list[ 22 ]= 3040
 510         list[ 23 ]= 3066
 511         list[ 24 ]= 3084
 512         list[ 25 ]= 3215
 513         list[ 26 ]= 3225
 514         list[ 27 ]= 3237
 515         list[ 28 ]= 3317
 516         list[ 29 ]= 3362
 517         list[ 30 ]= 4003
 518         list[ 31 ]= 4006
 519         list[ 32 ]= 4138
 520         list[ 33 ]= 4201
 521         list[ 34 ]= 4444
 522         list[ 35 ]= 4506
 523         list[ 36 ]= 4781
 524         list[ 37 ]= 4984
 525         list[ 38 ]= 5110
 526         list[ 39 ]= 5129
 527         list[ 40 ]= 5227
 528         list[ 41 ]= 5696
 529         list[ 42 ]= 5843
 530         list[ 43 ]= 5936
 531         list[ 44 ]= 5992
 532         list[ 45 ]= 6484
 533         list[ 46 ]= 7216
 534         list[ 47 ]= 7491
 535         list[ 48 ]= 8358
 536         list[ 49 ]= 8370
 537         list[ 50 ]= 8402
 538         list[ 51 ]= 8561
 539         list[ 52 ]= 8579
 540         list[ 53 ]= 9040
 541         list[ 54 ]= 9768
 542
 543 ## Arrays
 544
 545 We already have some array tests, but this is where we put other
 546 ad-hoc things array related.
 547
 548 ###### test list
 549         oceani_tests += arrays
 550
 551 ###### test: arrays
 552
 553         func main()
 554                 bools:[5]Boolean
 555                 strings:[4]string
 556
 557                 bools[3] = strings[1] == "Hello"
 558                 bools[1] = strings[2] <= "there"
 559
 560                 for i:=0; then i=i+1; while i<5:
 561                         j ::= i
 562                         ra:[j]number
 563                         ra[i-1] = i*i
 564                         ra[6] = 42 // mustn't crash
 565                         print '', bools[i], ra[j-1],
 566                 print
 567
 568 ###### output: arrays
 569          False 0 True 1 False 4 False 9 False 16
 570
 571 ## Structures
 572
 573 Time to test if structure declarations and accesses work correctly.
 574
 575 ###### test list
 576         oceani_tests += structs
 577
 578 ###### test: structs
 579
 580         const three ::= 3
 581         struct foo
 582                 size:[three]number
 583                 name:string
 584                 active:Boolean = True
 585
 586         struct baz { a:number; b:Boolean; }
 587
 588         func main
 589         do
 590                 info:[4]foo
 591
 592                 for i:=0; then i=i+1; while i < 4:
 593                         switch i
 594                         case 2: nm:= "peter"
 595                         case 0: nm:= "bob"
 596                         case 1: nm:= "jane"
 597                         else    nm:= "janine"
 598
 599                         info[i].name = nm
 600                         info[i].size[0] = i*i
 601                         if nm != "jane":
 602                                 info[i].active = False
 603
 604                 for i:=0; then i=i+1; while i < 4:
 605                         print info[i].name, info[i].active, info[i].size[0]
 606
 607 ###### output: structs
 608
 609         bob False 0
 610         jane True 1
 611         peter False 4
 612         janine False 9
 613
 614 ## Functions
 615
 616 Test functions.  They don't return anything, so we need to get them to print
 617
 618 ###### test list
 619         oceani_tests += functions
 620
 621 ###### test: functions
 622
 623         func test1
 624                 t: Boolean
 625         do
 626                 if t:
 627                         print "true"
 628
 629         func noarg
 630         do
 631                 pass
 632
 633         func twoarg
 634                 a:number
 635                 b:string
 636         do
 637                 while a > 0:
 638                         print b
 639                         a = a - 1
 640
 641         func test(n:number; s:string)
 642                 if n >= 1:
 643                         print n,s,
 644                         test(n-1, "."++s)
 645                 else
 646                         print "done"
 647         func main()
 648                 for i:=0; then i = i + 1; while i < 5:
 649                         test(i, " ")
 650
 651 ###### output: functions
 652         done
 653         1  done
 654         2  1 . done
 655         3  2 . 1 .. done
 656         4  3 . 2 .. 1 ... done
 657
 658 ## Test code with syntax errors
 659
 660 Syntax errors aren't handled well yet - the result is almost always a
 661 single message about the first error.  So this section will be fairly
 662 thin until we add proper parsing recovery in the face of common errors.
 663
 664 A special case of syntax errors is token errors, when a token is only
 665 accepted because the parser doesn't know quite enough to reject it.
 666 There are handled better as they are quite local, so a single test
 667 program can trigger most of the possible errors.
 668
 669 To handle erronous code, we need a different set of tests, as we need to
 670 capture `stderr`. The same test code will be used for type errors too.
 671 As error messages contain the line number, and we don't want changes to
 672 this file to change the reported numbers, we copy the code into a
 673 separate file first, then run from there.
 674
 675 ###### test code
 676         @for t in $(oceani_failing_tests); do \
 677             echo -n "Test $$t ... "; \
 678             ./md2c oceani-tests.mdc "output: $$t" | grep -v '^#' > .tmp.want; \
 679             echo '``````' > .tmp.code; \
 680             ./md2c oceani-tests.mdc "test: $$t" | grep -v '^#' >> .tmp.code; \
 681             ./oceani .tmp.code > .tmp.have 2>&1; \
 682             if ! cmp -s .tmp.want .tmp.have; then \
 683                echo "FAILED"; diff -u .tmp.want .tmp.have ; exit 1; fi ;\
 684             echo  "passed"; \
 685             ./coverage_oceani --section "test: $$t" oceani-tests.mdc > /dev/null 2>&1 ;\
 686         done || true
 687
 688 ###### test list
 689         oceani_failing_tests := syn1
 690         oceani_failing_tests += tokerr
 691
 692 ###### test: syn1
 693
 694         func main()
 695                 if then else while do
 696
 697 ###### output: syn1
 698         .tmp.code:3:11: Syntax error in statement: then
 699
 700 ###### test: tokerr
 701         func main()
 702                 a := 1i  // imaginary numbers aren't understood
 703                 b:[2i]number // array sizes are handled separately
 704                 c:[3.14159]Boolean // array sizes must be integers
 705                 d:[1_000_000_000_000]number // they mustn't be huge
 706                 patn: string = "foo[ ,_]*bar"re // regexp strings are just a dream
 707
 708                 multi := """
 709                 This is a multiline string
 710                 With an unsupportable suffix
 711                 """Aa
 712
 713                 xx:unknown = 24
 714                 yy:[unknowable]number
 715                 zzsize := 4
 716                 zz:[zzsize]string // size must be constant, use ::=
 717
 718                 // These numbers should be bad in all contexts: FIXME
 719                 aa:[00123]number
 720
 721 ###### output: tokerr
 722         .tmp.code:3:13: error: unsupported number suffix: 1i
 723         .tmp.code:4:11: error: unsupported number suffix: 2i
 724         .tmp.code:5:11: error: array size must be an integer: 3.14159
 725         .tmp.code:6:11: error: array size is too large: 1_000_000_000_000
 726         .tmp.code:7:23: error: unsupported string suffix: "foo[ ,_]*bar"re
 727         .tmp.code:9:17: error: unsupported string suffix: """
 728                 This is a multiline string
 729                 With an unsupportable suffix
 730                 """Aa
 731         .tmp.code:14:11: error: undefined type: unknown
 732         .tmp.code:15:12: error: name undeclared: unknowable
 733         .tmp.code:17:12: error: array size must be a constant: zzsize
 734         .tmp.code:20:12: error: unrecognised number: 00123
 735
 736 ## Tests for type errors
 737
 738 Type error don't cause parsing to abort, so we can fit many in the
 739 one test program.  Some type errors are found during the parse, others
 740 during type analysis which doesn't run if parsing failed.  So we cannot
 741 fit everything in one.
 742
 743 These programs were generated by looking for the
 744 various places that `type_err()` are called.
 745
 746 ###### test list
 747         oceani_failing_tests += type_err1 type_err2 type_err3 type_err4
 748
 749 ###### test: type_err1
 750
 751         func main()
 752                 print "hello" ++ 5, 5 ++ "hello"
 753
 754                 b ::= 3
 755                 b = b + 1
 756
 757                 if 3 * 4 and not True: print "Weird"
 758
 759 ###### output: type_err1
 760         .tmp.code:3:25: error: expected string found number
 761         .tmp.code:3:28: error: expected string found number
 762         .tmp.code:6:8: error: Cannot assign to a constant: b
 763         .tmp.code:5:8: info: name was defined as a constant here
 764         .tmp.code:6:8: error: Cannot assign to a constant: b
 765         .tmp.code:5:8: info: name was defined as a constant here
 766         .tmp.code:8:11: error: Arithmetic returns number but Boolean expected
 767         oceani: type error in program - not running.
 768
 769 ###### test: type_err2
 770
 771         func main()
 772                 a := 1
 773                 a := 2
 774                 a ::= 3
 775                 a:number = 4
 776                 a ::number = 5
 777                 c:
 778
 779 ###### output: type_err2
 780         .tmp.code:4:8: error: variable 'a' redeclared
 781         .tmp.code:3:8: info: this is where 'a' was first declared
 782         .tmp.code:5:8: error: variable 'a' redeclared
 783         .tmp.code:3:8: info: this is where 'a' was first declared
 784         .tmp.code:6:8: error: variable 'a' redeclared
 785         .tmp.code:3:8: info: this is where 'a' was first declared
 786         .tmp.code:7:8: error: variable 'a' redeclared
 787         .tmp.code:3:8: info: this is where 'a' was first declared
 788         .tmp.code:8:8: Variable declared with no type or value: c
 789
 790 ###### test: type_err3
 791
 792         struct foo
 793                 a: number
 794                 b:string = "hello"
 795
 796         func main()
 797                 c := "hello"
 798                 c = c + 1
 799                 c = "hello" ++ (True and False)
 800                 c = 4 < 5
 801                 print 45 + ( "Hello" ++ "there")
 802                 c[5] = 1
 803
 804                 while
 805                         use 1
 806                         use True
 807                         use "Hello"
 808                 do
 809                         print
 810                 case 1: print "one"
 811                 case "Hello": print "Hello"
 812
 813                 a1:[5]number; a2:[5]number; a3:[10]number; a4:[5]string
 814                 a1 = a2
 815                 a1 = a3
 816                 a1 = a4
 817                 a1[2] = "hello"
 818                 a4[1] = True
 819                 c = a2[3]
 820
 821                 bar:foo
 822                 foo.c = 43
 823                 print c.foo
 824                 print bar.c
 825                 print bar.b + 42
 826
 827
 828                 // trigger 'labels not permitted' error message
 829                 while 1 if True else False:
 830                         print
 831                 case 2: print "two"
 832
 833 ###### output: type_err3
 834         .tmp.code:8:12: error: expected number but variable 'c' is string
 835         .tmp.code:7:8: info: this is where 'c' was set to string
 836         .tmp.code:8:12: error: Arithmetic returns number but string expected
 837         .tmp.code:7:8: info: variable 'c' was set as string here.
 838         .tmp.code:9:24: error: Boolean operation found where string expected
 839         .tmp.code:10:12: error: Comparison returns Boolean but string expected
 840         .tmp.code:7:8: info: variable 'c' was set as string here.
 841         .tmp.code:11:21: error: Concat returns string but number expected
 842         .tmp.code:12:8: error: string cannot be indexed
 843         .tmp.code:12:8: error: string cannot be indexed
 844         .tmp.code:21:13: error: expected number found string
 845         .tmp.code:17:16: error: expected number, found string
 846         .tmp.code:24:8: error: cannot assign value of type [5]number
 847         .tmp.code:25:13: error: expected [5]number but variable 'a3' is [10]number
 848         .tmp.code:23:36: info: this is where 'a3' was set to [10]number
 849         .tmp.code:25:8: error: cannot assign value of type [5]number
 850         .tmp.code:26:13: error: expected [5]number but variable 'a4' is [5]string
 851         .tmp.code:23:51: info: this is where 'a4' was set to [5]string
 852         .tmp.code:26:8: error: cannot assign value of type [5]number
 853         .tmp.code:27:16: error: expected number found string
 854         .tmp.code:28:16: error: expected string found Boolean
 855         .tmp.code:29:12: error: have number but need string
 856         .tmp.code:7:8: info: variable 'c' was set as string here.
 857         .tmp.code:32:8: error: variable used but not declared: foo
 858         .tmp.code:32:8: error: field reference attempted on none, not a struct
 859         .tmp.code:32:16: error: expected none found number
 860         .tmp.code:33:14: error: field reference attempted on string, not a struct
 861         .tmp.code:34:14: error: cannot find requested field in foo
 862         .tmp.code:35:17: error: have string but need number
 863         .tmp.code:39:29: error: expected number (labels not permitted) found Boolean
 864         oceani: type error in program - not running.
 865
 866 ###### test: type_err4
 867         func main()
 868                 a:=1; b=2; c::=3
 869                 print a, b, c
 870
 871 ###### output: type_err4
 872         .tmp.code:3:14: error: variable used but not declared: b
 873         .tmp.code:3:16: error: expected none found number
 874         .tmp.code:3:14: info: variable 'b' was set as none here.
 875         oceani: type error in program - not running.
 876
 877 ###### test list
 878         oceani_failing_tests += type_err_const type_err_const1 missing_program bad_main
 879
 880 ###### test: type_err_const
 881         const
 882                 foo :: number = 45
 883                 bar ::= "string" + 56
 884         const
 885                 bar ::= "baz"
 886         func main()
 887                 foo := 4
 888                 print foo, bar
 889
 890         // trigger duplicate-main error
 891         func main()
 892                 foo := 6
 893                 print bar, foo
 894
 895 ###### output: type_err_const
 896         .tmp.code:4:16: error: expected number found string
 897         .tmp.code:6:8: error: name already declared: bar
 898         .tmp.code:4:8: info: this is where 'bar' was first declared
 899         .tmp.code:8:8: error: variable 'foo' redeclared
 900         .tmp.code:3:8: info: this is where 'foo' was first declared
 901         .tmp.code:12:5: error: function 'main' redeclared
 902         .tmp.code:7:5: info: this is where 'main' was first declared
 903         .tmp.code:13:8: error: variable 'foo' redeclared
 904         .tmp.code:3:8: info: this is where 'foo' was first declared
 905
 906 ###### test: type_err_const1
 907         const
 908                 foo : number = 45
 909                 bar := "string"
 910         func main()
 911                 foo := 4
 912                 print foo, bar
 913
 914 ###### output: type_err_const1
 915         .tmp.code:3:12: Syntax error in constant: :
 916         .tmp.code:4:12: Syntax error in constant: :
 917
 918 ###### test: missing_program
 919         const
 920                 foo::="bar"
 921
 922 ###### output: missing_program
 923         oceani: no main function found.
 924
 925 ###### test: bad_main
 926         func main(foo:string)
 927                 print foo
 928
 929 ###### output: bad_main
 930         .tmp.code:??:??: error: expected  argv but variable 'foo' is string
 931         .tmp.code:??:??: info: this is where 'NOTVAR' was set to string
 932         oceani: main has wrong type.
 933
 934 Test for type errors with functions
 935
 936 ###### test list
 937         oceani_failing_tests += func_err_args func_err_redeclare
 938
 939 ###### test: func_err_args
 940
 941         func test1(a:number; b:string; c:[3]Boolean)
 942                 print a, b, c[1]
 943
 944         func test2(a:number; b:string; c:[3]Boolean)
 945                 print a, b, c[1]
 946
 947         func test3()
 948                 # use undefined names
 949                 print a, z
 950
 951         func main()
 952                 truth:[3]Boolean
 953                 truth[1] = True
 954                 test1(1,"hello")
 955                 test1("hello",1)
 956                 test1(1, "two", truth)
 957                 test1(1, 2, truth)
 958                 test1(1, "lo", truth, 4)
 959                 print test(), test1(1,2,3)
 960                 if test1 == test2:
 961                         pass
 962
 963 ###### output: func_err_args
 964         .tmp.code:15:14: error: insufficient arguments to function.
 965         .tmp.code:16:14: error: expected number found string
 966         .tmp.code:16:22: error: expected string found number
 967         .tmp.code:16:14: error: insufficient arguments to function.
 968         .tmp.code:18:17: error: expected string found number
 969         .tmp.code:19:14: error: too many arguments to function.
 970         .tmp.code:20:14: error: attempt to call a non-function.
 971         .tmp.code:20:32: error: expected string found number
 972         .tmp.code:20:28: error: insufficient arguments to function.
 973         .tmp.code:21:20: error: expected  func but variable 'test2' is  func
 974         .tmp.code:??:??: info: this is where 'NOTVAR' was set to  func
 975         .tmp.code:10:14: error: variable used but not declared: a
 976         .tmp.code:10:17: error: variable used but not declared: z
 977         oceani: type error in program - not running.
 978
 979 ###### test: func_err_redeclare
 980
 981         func test1(a:number; b:string; c:[3]Boolean)
 982                 print a, b, c[1]
 983
 984         func test1
 985         do
 986                 pass
 987
 988         func test1
 989                 b:Boolean
 990         do
 991                 pass
 992
 993 ###### output: func_err_redeclare
 994         .tmp.code:5:5: error: function 'test1' redeclared
 995         .tmp.code:2:5: info: this is where 'test1' was first declared
 996         .tmp.code:9:5: error: function 'test1' redeclared
 997         .tmp.code:2:5: info: this is where 'test1' was first declared
 998
 999 ## Test erroneous command line args
1000
1001 To improve coverage, we want to test correct handling of strange command
1002 line arguments.  These tests won't use code, so the exiting test types
1003 won't work.  So we need to be able to explicitly give the command line,
1004 and the expected output, and have that tested and the coverage assessed.
1005 Rather than having to spell out the whole command name, just give "cmd",
1006 and discard that.  Requiring but discarding the command make an empty
1007 command list possible.
1008
1009 ###### test code
1010         @for t in $(oceani_special_tests); do \
1011             echo -n "Test $$t ... ";\
1012             i="$$IFS"; IFS=,; set $$t; IFS="$$i"; shift ;\
1013             ./md2c oceani-tests.mdc "output: $$t" | grep -v '^#' > .tmp.want; \
1014             ./oceani $${1+"$$@"} > .tmp.have 2>&1 ;\
1015             if ! cmp -s .tmp.want .tmp.have; then \
1016                echo "FAILED"; diff -u .tmp.want .tmp.have ; exit 1; fi ;\
1017             echo  "passed"; \
1018             ./coverage_oceani $${1+"$$@"} > /dev/null 2>&1 ;\
1019         done || true
1020
1021 ###### test list
1022         oceani_special_tests += "cmd"
1023         oceani_special_tests += "cmd,-zyx"
1024         oceani_special_tests += "cmd,nofile"
1025         oceani_special_tests += "cmd,/dev/null"
1026         oceani_special_tests += "cmd,--section,toast:nothing,oceani-tests.mdc"
1027
1028 ###### output: cmd
1029         oceani: no input file given
1030
1031 ###### output: cmd,-zyx
1032         ./oceani: invalid option -- 'z'
1033         Usage: oceani --trace --print --noexec --brackets --section=SectionName prog.ocn
1034
1035 ###### output: cmd,nofile
1036         oceani: cannot open nofile
1037
1038 ###### output: cmd,/dev/null
1039         oceani: could not find any code in /dev/null
1040
1041 ###### output: cmd,--section,toast:nothing,oceani-tests.mdc
1042         oceani: cannot find section toast:nothing