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                 @ 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.94) exit(1) }' \
  84                         coverage/oceani.mdc.gcov
  85                 @rm -f .tmp*
  86
  87                 @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         program:
 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         program:
 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         program:
 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         program:
 191                 for i:=0; then i=i+1; while i < 5:
 192                         switch i:
 193                                 case 0: num:="zero"
 194                                 case 1: num:="one"
 195                                 case 2: num:="two"
 196                                 case 3: num:="three"
 197                                 else    num:="many"
 198                         print num,", ",
 199                 print
 200
 201 ###### output: varmerge
 202         zero , one , two , three , many ,
 203
 204 ## Conditions and Loops
 205
 206 Now we need to test if/else and some different loops
 207
 208 ###### test list
 209        oceani_tests += cond_loop
 210
 211 ###### test: cond_loop
 212
 213         program:
 214                 a := 4
 215                 if a < 5:
 216                         print "Success"
 217                 else
 218                         print "Failure"
 219                 for b:=1; then b=b+b; while b < 100:
 220                         print '', b,
 221                 print
 222                 // Newtons method for square root of 2
 223                 target ::= 2
 224                 guess := target
 225                 for
 226                         count: number = 0
 227                 while
 228                         current := guess * guess
 229                         use +(current - target) > 0.000000001
 230                 do
 231                         guess = (guess + (target / guess) ) / 2
 232                         print count, guess
 233                         count = count + 1
 234                 print "error is ", target - guess * guess
 235
 236                 for j:=0; then j = j+3 ; while j < 10:
 237                         if j != 0 and then 20 / j > 3:
 238                                 print "20 /", j," =", 20 / j
 239                         else
 240                                 print "I won't calculate 20 /", j
 241                 pi ::= 3.1415926535897
 242                 if 355/113 == pi or else +(pi - 355/113) < 0.001:
 243                         print "Close enough"
 244                 print "lower" if 355/113 < pi else "higher"
 245
 246                 if pi > 3 then print "pi exceeds three"; else print "need more pie"
 247                 if (pi < 3) { print "not enough pi" } else { print "pi sufficient" }
 248                 for { i := 0; sum := 0 }
 249                 then { i = i+1 }
 250                 while i <= 10:
 251                         sum = sum + i
 252                 else
 253                         pass
 254                         print "sum 1..10 is", sum
 255
 256 ###### output: cond_loop
 257         Success
 258          1 2 4 8 16 32 64
 259         0 1.5
 260         1 1.41667
 261         2 1.41422
 262         3 1.41421
 263         error is  -4.51095e-12
 264         I won't calculate 20 / 0
 265         20 / 3  = 6.66667
 266         20 / 6  = 3.33333
 267         I won't calculate 20 / 9
 268         Close enough
 269         higher
 270         pi exceeds three
 271         pi sufficient
 272         sum 1..10 is 55
 273
 274 ## Say Hello
 275
 276 The demonstration code presented in the interpreted is suitable for the test suite.
 277 Here I break it into two parts, keeping the array code separate.
 278
 279 ###### test list
 280         oceani_tests += "sayhello,55,33,hello,True"
 281         oceani_tests += "sayhello,12,60,there,False"
 282
 283 ###### test: sayhello
 284
 285         program As Bs astr bbools:
 286                 A := $As; B := $Bs
 287                 bbool := bbools == "True"
 288                 print "Hello World, what lovely oceans you have!"
 289                 /* When a variable is defined in both branches of an 'if',
 290                  * and used afterwards, the variables are merged.
 291                  */
 292                 if A > B:
 293                         bigger := "yes"
 294                 else
 295                         bigger := "no"
 296                 print "Is", A, "bigger than", B,"? ", bigger
 297                 /* If a variable is not used after the 'if', no
 298                  * merge happens, so types can be different
 299                  */
 300                 if A > B * 2:
 301                         double:string = "yes"
 302                         print A, "is more than twice", B, "?", double
 303                 else
 304                         double := B*2
 305                         print "double", B, "is", double
 306
 307                 a : number
 308                 a = A;
 309                 b:number = B
 310                 if a > 0 and b > 0:
 311                         while a != b:
 312                                 if a < b:
 313                                         b = b - a
 314                                 else
 315                                         a = a - b
 316                         print "GCD of", A, "and", B,"is", a
 317                 else if a <= 0:
 318                         print a, "is not positive, cannot calculate GCD"
 319                 else
 320                         print b, "is not positive, cannot calculate GCD"
 321
 322                 for
 323                         togo := 10
 324                         f1 := 1; f2 := 1
 325                         print "Fibonacci:", f1,f2,
 326                 then togo = togo - 1
 327                 while togo > 0:
 328                         f3 := f1 + f2
 329                         print "", f3,
 330                         f1 = f2
 331                         f2 = f3
 332                 print ""
 333
 334                 if bbool:
 335                         print astr ++ " was the str"
 336                 else
 337                         print "I found the str over " ++ astr
 338
 339                 /* Binary search... */
 340                 for
 341                         lo:= 0; hi := 100
 342                         target := 77
 343                 while
 344                         mid := (lo + hi) / 2
 345                         if mid == target:
 346                                 use Found
 347                         if mid < target:
 348                                 lo = mid
 349                         else
 350                                 hi = mid
 351                         if hi - lo < 1:
 352                                 use GiveUp
 353                         use True
 354                 do pass
 355                 case Found:
 356                         print "Yay, I found", target
 357                 case GiveUp:
 358                         print "Closest I found was", mid
 359
 360 ###### output: sayhello,55,33,hello,True
 361         Hello World, what lovely oceans you have!
 362         Is 55 bigger than 33 ?  yes
 363         double 33 is 66
 364         GCD of 55 and 33 is 11
 365         Fibonacci: 1 1 2 3 5 8 13 21 34 55 89 144
 366         hello was the str
 367         Closest I found was 77.3438
 368
 369 ###### output: sayhello,12,60,there,False
 370         Hello World, what lovely oceans you have!
 371         Is 12 bigger than 60 ?  no
 372         double 60 is 120
 373         GCD of 12 and 60 is 12
 374         Fibonacci: 1 1 2 3 5 8 13 21 34 55 89 144
 375         I found the str over there
 376         Closest I found was 77.3438
 377
 378 ###### test list
 379         oceani_tests += "insert_sort"
 380 ###### test: insert_sort
 381         program:
 382                 size::=55
 383                 list:[size]number
 384                 list[0] = 1_234
 385                 for i:=1; then i = i + 1; while i < size:
 386                         n := list[i-1] * list[i-1]
 387                         list[i] = (n / 100) % 10000
 388
 389                 print "Before sort:"
 390                 for i:=0; then i = i + 1; while i < size:
 391                         print "list[",i,"]=",list[i]
 392
 393                 for i := 1; then i=i+1; while i < size:
 394                         for j:=i-1; then j=j-1; while j >= 0:
 395                                 if list[j] > list[j+1]:
 396                                         t:= list[j]
 397                                         list[j] = list[j+1]
 398                                         list[j+1] = t
 399                 print "After sort:"
 400                 for i:=0; then i = i + 1; while i < size:
 401                         print "list[",i,"]=",list[i]
 402
 403 ###### output: insert_sort
 404         Before sort:
 405         list[ 0 ]= 1234
 406         list[ 1 ]= 5227
 407         list[ 2 ]= 3215
 408         list[ 3 ]= 3362
 409         list[ 4 ]= 3030
 410         list[ 5 ]= 1809
 411         list[ 6 ]= 2724
 412         list[ 7 ]= 4201
 413         list[ 8 ]= 6484
 414         list[ 9 ]= 422
 415         list[ 10 ]= 1780
 416         list[ 11 ]= 1684
 417         list[ 12 ]= 8358
 418         list[ 13 ]= 8561
 419         list[ 14 ]= 2907
 420         list[ 15 ]= 4506
 421         list[ 16 ]= 3040
 422         list[ 17 ]= 2416
 423         list[ 18 ]= 8370
 424         list[ 19 ]= 569
 425         list[ 20 ]= 3237
 426         list[ 21 ]= 4781
 427         list[ 22 ]= 8579
 428         list[ 23 ]= 5992
 429         list[ 24 ]= 9040
 430         list[ 25 ]= 7216
 431         list[ 26 ]= 706
 432         list[ 27 ]= 4984
 433         list[ 28 ]= 8402
 434         list[ 29 ]= 5936
 435         list[ 30 ]= 2360
 436         list[ 31 ]= 5696
 437         list[ 32 ]= 4444
 438         list[ 33 ]= 7491
 439         list[ 34 ]= 1150
 440         list[ 35 ]= 3225
 441         list[ 36 ]= 4006
 442         list[ 37 ]= 480
 443         list[ 38 ]= 2304
 444         list[ 39 ]= 3084
 445         list[ 40 ]= 5110
 446         list[ 41 ]= 1121
 447         list[ 42 ]= 2566
 448         list[ 43 ]= 5843
 449         list[ 44 ]= 1406
 450         list[ 45 ]= 9768
 451         list[ 46 ]= 4138
 452         list[ 47 ]= 1230
 453         list[ 48 ]= 5129
 454         list[ 49 ]= 3066
 455         list[ 50 ]= 4003
 456         list[ 51 ]= 240
 457         list[ 52 ]= 576
 458         list[ 53 ]= 3317
 459         list[ 54 ]= 24
 460         After sort:
 461         list[ 0 ]= 24
 462         list[ 1 ]= 240
 463         list[ 2 ]= 422
 464         list[ 3 ]= 480
 465         list[ 4 ]= 569
 466         list[ 5 ]= 576
 467         list[ 6 ]= 706
 468         list[ 7 ]= 1121
 469         list[ 8 ]= 1150
 470         list[ 9 ]= 1230
 471         list[ 10 ]= 1234
 472         list[ 11 ]= 1406
 473         list[ 12 ]= 1684
 474         list[ 13 ]= 1780
 475         list[ 14 ]= 1809
 476         list[ 15 ]= 2304
 477         list[ 16 ]= 2360
 478         list[ 17 ]= 2416
 479         list[ 18 ]= 2566
 480         list[ 19 ]= 2724
 481         list[ 20 ]= 2907
 482         list[ 21 ]= 3030
 483         list[ 22 ]= 3040
 484         list[ 23 ]= 3066
 485         list[ 24 ]= 3084
 486         list[ 25 ]= 3215
 487         list[ 26 ]= 3225
 488         list[ 27 ]= 3237
 489         list[ 28 ]= 3317
 490         list[ 29 ]= 3362
 491         list[ 30 ]= 4003
 492         list[ 31 ]= 4006
 493         list[ 32 ]= 4138
 494         list[ 33 ]= 4201
 495         list[ 34 ]= 4444
 496         list[ 35 ]= 4506
 497         list[ 36 ]= 4781
 498         list[ 37 ]= 4984
 499         list[ 38 ]= 5110
 500         list[ 39 ]= 5129
 501         list[ 40 ]= 5227
 502         list[ 41 ]= 5696
 503         list[ 42 ]= 5843
 504         list[ 43 ]= 5936
 505         list[ 44 ]= 5992
 506         list[ 45 ]= 6484
 507         list[ 46 ]= 7216
 508         list[ 47 ]= 7491
 509         list[ 48 ]= 8358
 510         list[ 49 ]= 8370
 511         list[ 50 ]= 8402
 512         list[ 51 ]= 8561
 513         list[ 52 ]= 8579
 514         list[ 53 ]= 9040
 515         list[ 54 ]= 9768
 516
 517 ## Arrays
 518
 519 We already have some array tests, but this is where we put other
 520 ad-hoc things array related.
 521
 522 ###### test list
 523         oceani_tests += arrays
 524
 525 ###### test: arrays
 526
 527         program:
 528                 bools:[5]Boolean
 529                 strings:[4]string
 530
 531                 bools[3] = strings[1] == "Hello"
 532                 bools[1] = strings[2] <= "there"
 533
 534                 for i:=0; then i=i+1; while i<5:
 535                         print '', bools[i],
 536                 print
 537
 538 ###### output: arrays
 539          False True False False False
 540
 541 ## Structures
 542
 543 Time to test if structure declarations and accesses work correctly.
 544
 545 ###### test list
 546         oceani_tests += structs
 547
 548 ###### test: structs
 549
 550         struct foo
 551                 size:[3]number
 552                 name:string
 553                 active:Boolean
 554
 555         struct baz { a:number; b:Boolean; }
 556
 557         program:
 558                 info:[4]foo
 559
 560                 for i:=0; then i=i+1; while i < 4:
 561                         switch i
 562                         case 2: nm:= "peter"
 563                         case 0: nm:= "bob"
 564                         case 1: nm:= "jane"
 565                         else    nm:= "janine"
 566
 567                         info[i].name = nm
 568                         info[i].size[0] = i*i
 569                         info[i].active = nm == "jane"
 570
 571                 for i:=0; then i=i+1; while i < 4:
 572                         print info[i].name, info[i].active, info[i].size[0]
 573
 574 ###### output: structs
 575
 576         bob False 0
 577         jane True 1
 578         peter False 4
 579         janine False 9
 580
 581 ## Test code with syntax errors
 582
 583 Syntax errors aren't handled well yet - the result is almost always a
 584 single message about the first error.  So this section will be fairly
 585 thin until we add proper parsing recovery in the face of common errors.
 586
 587 A special case of syntax errors is token errors, when a token is only
 588 accepted because the parser doesn't know quite enough to reject it.
 589 There are handled better as they are quite local, so a single test
 590 program can trigger most of the possible errors.
 591
 592 To handle erronous code, we need a different set of tests, as we need to
 593 capture `stderr`. The same test code will be used for type errors too.
 594 As error messages contain the line number, and we don't want changes to
 595 this file to change the reported numbers, we copy the code into a
 596 separate file first, then run from there.
 597
 598 ###### test code
 599         @for t in $(oceani_failing_tests); do \
 600             echo -n "Test $$t ... "; \
 601             ./md2c oceani-tests.mdc "output: $$t" | grep -v '^#' > .tmp.want; \
 602             echo '``````' > .tmp.code; \
 603             ./md2c oceani-tests.mdc "test: $$t" | grep -v '^#' >> .tmp.code; \
 604             ./oceani .tmp.code > .tmp.have 2>&1; \
 605             if ! cmp -s .tmp.want .tmp.have; then \
 606                echo "FAILED"; diff -u .tmp.want .tmp.have ; exit 1; fi ;\
 607             echo  "passed"; \
 608             ./coverage_oceani --section "test: $$t" oceani-tests.mdc > /dev/null 2>&1 ;\
 609         done || true
 610
 611 ###### test list
 612         oceani_failing_tests := syn1
 613         oceani_failing_tests += tokerr
 614
 615 ###### test: syn1
 616
 617         program:
 618                 if then else while do
 619
 620 ###### output: syn1
 621         .tmp.code:3:11: Syntax error in statement: then
 622
 623 ###### test: tokerr
 624         program:
 625                 a := 1i  // imaginary numbers aren't understood
 626                 b:[2i]number // array sizes are handled separately
 627                 c:[3.14159]Boolean // array sizes must be integers
 628                 d:[1_000_000_000_000]number // they mustn't be huge
 629                 patn: string = "foo[ ,_]*bar"re // regexp strings are just a dream
 630
 631                 multi := """
 632                 This is a multiline string
 633                 With an unsupportable suffix
 634                 """Aa
 635
 636                 xx:unknown = 24
 637                 yy:[unknowable]number
 638                 zzsize := 4
 639                 zz:[zzsize]string // size must be constant, use ::=
 640
 641                 // These numbers should be bad in all contexts: FIXME
 642                 aa:[00123]number
 643
 644 ###### output: tokerr
 645         .tmp.code:3:13: error: unsupported number suffix: 1i
 646         .tmp.code:4:11: error: unsupported number suffix: 2i
 647         .tmp.code:5:11: error: array size must be an integer: 3.14159
 648         .tmp.code:6:11: error: array size is too large: 1_000_000_000_000
 649         .tmp.code:7:23: error: unsupported string suffix: "foo[ ,_]*bar"re
 650         .tmp.code:9:17: error: unsupported string suffix: """
 651                 This is a multiline string
 652                 With an unsupportable suffix
 653                 """Aa
 654         .tmp.code:14:11: error: undefined type: unknown
 655         .tmp.code:15:12: error: name undeclared: unknowable
 656         .tmp.code:17:12: error: array size must be a constant: zzsize
 657         .tmp.code:20:12: error: unrecognised number: 00123
 658
 659 ## Tests for type errors
 660
 661 Type error don't cause parsing to abort, so we can fit many in the
 662 one test program.  Some type errors are found during the parse, others
 663 during type analysis which doesn't run if parsing failed.  So we cannot
 664 fit everything in one.
 665
 666 These programs were generated by looking for the
 667 various places that `type_err()` are called.
 668
 669 ###### test list
 670         oceani_failing_tests += type_err1 type_err2 type_err3 type_err4
 671
 672 ###### test: type_err1
 673
 674         program:
 675                 print "hello" ++ 5, 5 ++ "hello"
 676
 677                 b ::= 3
 678                 b = b + 1
 679
 680                 if 3 * 4 and not True: print "Weird"
 681
 682 ###### output: type_err1
 683         .tmp.code:3:25: error: expected string found number
 684         .tmp.code:3:28: error: expected string found number
 685         .tmp.code:6:8: error: Cannot assign to a constant: b
 686         .tmp.code:5:8: info: name was defined as a constant here
 687         .tmp.code:6:8: error: Cannot assign to a constant: b
 688         .tmp.code:5:8: info: name was defined as a constant here
 689         .tmp.code:8:11: error: Arithmetic returns number but Boolean expected
 690         oceani: type error in program - not running.
 691
 692 ###### test: type_err2
 693
 694         program:
 695                 a := 1
 696                 a := 2
 697                 a ::= 3
 698                 a:number = 4
 699                 a ::number = 5
 700                 c:
 701
 702 ###### output: type_err2
 703         .tmp.code:4:8: error: variable 'a' redeclared
 704         .tmp.code:3:8: info: this is where 'a' was first declared
 705         .tmp.code:5:8: error: variable 'a' redeclared
 706         .tmp.code:3:8: info: this is where 'a' was first declared
 707         .tmp.code:6:8: error: variable 'a' redeclared
 708         .tmp.code:3:8: info: this is where 'a' was first declared
 709         .tmp.code:7:8: error: variable 'a' redeclared
 710         .tmp.code:3:8: info: this is where 'a' was first declared
 711         .tmp.code:8:8: Variable declared with no type or value: c
 712
 713 ###### test: type_err3
 714
 715         struct foo
 716                 a: number
 717                 b:string = "hello"
 718
 719         program:
 720                 c := "hello"
 721                 c = c + 1
 722                 c = "hello" ++ (True and False)
 723                 c = 4 < 5
 724                 print 45 + ( "Hello" ++ "there")
 725                 c[5] = 1
 726
 727                 while
 728                         use 1
 729                         use True
 730                         use "Hello"
 731                 do
 732                         print
 733                 case 1: print "one"
 734                 case "Hello": print "Hello"
 735
 736                 a1:[5]number; a2:[5]number; a3:[10]number; a4:[5]string
 737                 a1 = a2
 738                 a1 = a3
 739                 a1 = a4
 740                 a1[2] = "hello"
 741                 a4[1] = True
 742                 c = a2[3]
 743
 744                 bar:foo
 745                 foo.c = 43
 746                 print c.foo
 747
 748 ###### output: type_err3
 749         .tmp.code:8:12: error: expected number but variable 'c' is string
 750         .tmp.code:7:8: info: this is where 'c' was set to string
 751         .tmp.code:8:12: error: Arithmetic returns number but string expected
 752         .tmp.code:7:8: info: variable 'c' was set as string here.
 753         .tmp.code:9:24: error: Boolean operation found where string expected
 754         .tmp.code:10:12: error: Comparison returns Boolean but string expected
 755         .tmp.code:7:8: info: variable 'c' was set as string here.
 756         .tmp.code:11:21: error: Concat returns string but number expected
 757         .tmp.code:12:8: error: string cannot be indexed
 758         .tmp.code:12:8: error: string cannot be indexed
 759         .tmp.code:21:13: error: expected number found string
 760         .tmp.code:17:16: error: expected number, found string
 761         .tmp.code:24:8: error: cannot assign value of type [5]number
 762         .tmp.code:25:13: error: expected [5]number but variable 'a3' is [10]number
 763         .tmp.code:23:36: info: this is where 'a3' was set to [10]number
 764         .tmp.code:25:8: error: cannot assign value of type [5]number
 765         .tmp.code:26:13: error: expected [5]number but variable 'a4' is [5]string
 766         .tmp.code:23:51: info: this is where 'a4' was set to [5]string
 767         .tmp.code:26:8: error: cannot assign value of type [5]number
 768         .tmp.code:27:16: error: expected number found string
 769         .tmp.code:28:16: error: expected string found Boolean
 770         .tmp.code:29:12: error: have number but need string
 771         .tmp.code:7:8: info: variable 'c' was set as string here.
 772         .tmp.code:32:8: error: variable used but not declared: foo
 773         .tmp.code:32:8: error: field reference attempted on none, not a struct
 774         .tmp.code:32:16: error: expected none found number
 775         .tmp.code:33:14: error: field reference attempted on string, not a struct
 776         oceani: type error in program - not running.
 777
 778 ###### test: type_err4
 779         program:
 780                 a:=1; b=2; c::=3
 781                 print a, b, c
 782
 783 ###### output: type_err4
 784         .tmp.code:3:14: error: variable used but not declared: b
 785         .tmp.code:3:16: error: expected none found number
 786         .tmp.code:3:14: info: variable 'b' was set as none here.
 787         oceani: type error in program - not running.
 788
 789 ###### test list
 790         oceani_failing_tests += type_err_const type_err_const1
 791
 792 ###### test: type_err_const
 793         const
 794                 foo :: number = 45
 795                 bar ::= "string" + 56
 796         const
 797                 bar ::= "baz"
 798         program:
 799                 foo := 4
 800                 print foo, bar
 801
 802 ###### output: type_err_const
 803         .tmp.code:4:16: error: expected number found string
 804         .tmp.code:6:8: error: name already declared: bar
 805         .tmp.code:4:8: info: this is where 'bar' was first declared
 806         .tmp.code:8:8: error: variable 'foo' redeclared
 807         .tmp.code:3:8: info: this is where 'foo' was first declared
 808
 809 ###### test: type_err_const1
 810         const
 811                 foo : number = 45
 812                 bar := "string"
 813         program:
 814                 foo := 4
 815                 print foo, bar
 816
 817 ###### output: type_err_const1
 818         .tmp.code:3:12: Syntax error in constant: :
 819         .tmp.code:4:12: Syntax error in constant: :
 820
 821 ## Test erroneous command line args
 822
 823 To improve coverage, we want to test correct handling of strange command
 824 line arguments.  These tests won't use code, so the exiting test types
 825 won't work.  So we need to be able to explicitly give the command line,
 826 and the expected output, and have that tested and the coverage assessed.
 827 Rather than having to spell out the whole command name, just give "cmd",
 828 and discard that.  Requiring but discarding the command make an empty
 829 command list possible.
 830
 831 ###### test code
 832         @for t in $(oceani_special_tests); do \
 833             echo -n "Test $$t ... ";\
 834             i="$$IFS"; IFS=,; set $$t; IFS="$$i"; shift ;\
 835             ./md2c oceani-tests.mdc "output: $$t" | grep -v '^#' > .tmp.want; \
 836             ./oceani $${1+"$$@"} > .tmp.have 2>&1 ;\
 837             if ! cmp -s .tmp.want .tmp.have; then \
 838                echo "FAILED"; diff -u .tmp.want .tmp.have ; exit 1; fi ;\
 839             echo  "passed"; \
 840             ./coverage_oceani $${1+"$$@"} > /dev/null 2>&1 ;\
 841         done || true
 842
 843 ###### test list
 844         oceani_special_tests += "cmd"
 845         oceani_special_tests += "cmd,-zyx"
 846         oceani_special_tests += "cmd,nofile"
 847         oceani_special_tests += "cmd,/dev/null"
 848         oceani_special_tests += "cmd,--section,toast:nothing,oceani-tests.mdc"
 849
 850 ###### output: cmd
 851         oceani: no input file given
 852
 853 ###### output: cmd,-zyx
 854         ./oceani: invalid option -- 'z'
 855         Usage: oceani --trace --print --noexec --brackets --section=SectionName prog.ocn
 856
 857 ###### output: cmd,nofile
 858         oceani: cannot open nofile
 859
 860 ###### output: cmd,/dev/null
 861         oceani: could not find any code in /dev/null
 862
 863 ###### output: cmd,--section,toast:nothing,oceani-tests.mdc
 864         oceani: cannot find section toast:nothing