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