core/parser/parser-tests.factor

   1 USING: arrays math parser tools.test kernel generic words
   2 io.streams.string namespaces classes effects source-files assocs
   3 sequences strings io.files io.pathnames definitions
   4 continuations sorting classes.tuple compiler.units debugger
   5 vocabs vocabs.loader accessors eval combinators lexer
   6 vocabs.parser words.symbol multiline source-files.errors
   7 tools.crossref grouping ;
   8 IN: parser.tests
   9
  10 [ 1 [ 2 [ 3 ] 4 ] 5 ]
  11 [ "1\n[\n2\n[\n3\n]\n4\n]\n5" eval( -- a b c ) ]
  12 unit-test
  13
  14 [ t t f f ]
  15 [ "t t f f" eval( -- ? ? ? ? ) ]
  16 unit-test
  17
  18 [ "hello world" ]
  19 [ "\"hello world\"" eval( -- string ) ]
  20 unit-test
  21
  22 [ "\n\r\t\\" ]
  23 [ "\"\\n\\r\\t\\\\\"" eval( -- string ) ]
  24 unit-test
  25
  26 [ "hello world" ]
  27 [
  28     "IN: parser.tests : hello ( -- str ) \"hello world\" ;"
  29     eval( -- ) "USE: parser.tests hello" eval( -- string )
  30 ] unit-test
  31
  32 [ ]
  33 [ "! This is a comment, people." eval( -- ) ]
  34 unit-test
  35
  36 ! Test escapes
  37
  38 [ " " ]
  39 [ "\"\\u000020\"" eval( -- string ) ]
  40 unit-test
  41
  42 [ "'" ]
  43 [ "\"\\u000027\"" eval( -- string ) ]
  44 unit-test
  45
  46 ! Test EOL comments in multiline strings.
  47 [ "Hello" ] [ "#! This calls until-eol.\n\"Hello\"" eval( -- string ) ] unit-test
  48
  49 [ word ] [ \ f class ] unit-test
  50
  51 ! Test stack effect parsing
  52
  53 : effect-parsing-test ( a b -- c ) + ;
  54
  55 [ t ] [
  56     "effect-parsing-test" "parser.tests" lookup
  57     \ effect-parsing-test eq?
  58 ] unit-test
  59
  60 [ T{ effect f { "a" "b" } { "c" } f } ]
  61 [ \ effect-parsing-test "declared-effect" word-prop ] unit-test
  62
  63 : baz ( a b -- * ) 2array throw ;
  64
  65 [ t ]
  66 [ \ baz "declared-effect" word-prop terminated?>> ]
  67 unit-test
  68
  69 [ ] [ "IN: parser.tests USE: math : effect-parsing-test ( a b -- d ) - ;" eval( -- ) ] unit-test
  70
  71 [ t ] [
  72     "effect-parsing-test" "parser.tests" lookup
  73     \ effect-parsing-test eq?
  74 ] unit-test
  75
  76 [ T{ effect f { "a" "b" } { "d" } f } ]
  77 [ \ effect-parsing-test "declared-effect" word-prop ] unit-test
  78
  79 [ "IN: parser.tests : missing-- ( a b ) ;" eval( -- ) ] must-fail
  80
  81 ! Funny bug
  82 [ 2 ] [ "IN: parser.tests : \0. ( -- x ) 2 ; \0." eval( -- n ) ] unit-test
  83
  84 ! These should throw errors
  85 [ "HEX: zzz" eval( -- obj ) ] must-fail
  86 [ "OCT: 999" eval( -- obj ) ] must-fail
  87 [ "BIN: --0" eval( -- obj ) ] must-fail
  88
  89 DEFER: foo
  90
  91 "IN: parser.tests USING: math prettyprint ; SYNTAX: foo 2 2 + . ;" eval( -- )
  92
  93 [ ] [ "USE: parser.tests foo" eval( -- ) ] unit-test
  94
  95 "IN: parser.tests USING: math prettyprint ; : foo ( -- ) 2 2 + . ;" eval( -- )
  96
  97 [ t ] [
  98     "USE: parser.tests \\ foo" eval( -- word )
  99     "foo" "parser.tests" lookup eq?
 100 ] unit-test
 101
 102 ! parse-tokens should do the right thing on EOF
 103 [ "USING: kernel" eval( -- ) ]
 104 [ error>> T{ unexpected { want "token" } } = ] must-fail-with
 105
 106 ! Test smudging
 107
 108 [ 1 ] [
 109     "IN: parser.tests : smudge-me ( -- ) ;" <string-reader> "foo"
 110     parse-stream drop
 111
 112     "foo" source-file definitions>> first assoc-size
 113 ] unit-test
 114
 115 [ t ] [ "smudge-me" "parser.tests" lookup >boolean ] unit-test
 116
 117 [ ] [
 118     "IN: parser.tests : smudge-me-more ( -- ) ;" <string-reader> "foo"
 119     parse-stream drop
 120 ] unit-test
 121
 122 [ t ] [ "smudge-me-more" "parser.tests" lookup >boolean ] unit-test
 123 [ f ] [ "smudge-me" "parser.tests" lookup >boolean ] unit-test
 124
 125 [ 3 ] [
 126     "IN: parser.tests USING: math strings ; GENERIC: smudge-me ( a -- b ) M: integer smudge-me ; M: string smudge-me ;" <string-reader> "foo"
 127     parse-stream drop
 128
 129     "foo" source-file definitions>> first assoc-size
 130 ] unit-test
 131
 132 [ 1 ] [
 133     "IN: parser.tests USING: arrays ; M: array smudge-me ;" <string-reader> "bar"
 134     parse-stream drop
 135
 136     "bar" source-file definitions>> first assoc-size
 137 ] unit-test
 138
 139 [ 2 ] [
 140     "IN: parser.tests USING: math strings ; GENERIC: smudge-me ( a -- b ) M: integer smudge-me ;" <string-reader> "foo"
 141     parse-stream drop
 142
 143     "foo" source-file definitions>> first assoc-size
 144 ] unit-test
 145
 146 [ t ] [
 147     array "smudge-me" "parser.tests" lookup order member-eq?
 148 ] unit-test
 149
 150 [ t ] [
 151     integer "smudge-me" "parser.tests" lookup order member-eq?
 152 ] unit-test
 153
 154 [ f ] [
 155     string "smudge-me" "parser.tests" lookup order member-eq?
 156 ] unit-test
 157
 158 [ ] [
 159     "IN: parser.tests USE: math 2 2 +" <string-reader> "a"
 160     parse-stream drop
 161 ] unit-test
 162
 163 [ t ] [
 164     "a" <pathname> \ + usage member?
 165 ] unit-test
 166
 167 [ ] [
 168     "IN: parser.tests USE: math 2 2 -" <string-reader> "a"
 169     parse-stream drop
 170 ] unit-test
 171
 172 [ f ] [
 173     "a" <pathname> \ + usage member?
 174 ] unit-test
 175
 176 [ ] [
 177     "a" source-files get delete-at
 178     2 [
 179         "IN: parser.tests DEFER: x : y ( -- ) x ; : x ( -- ) y ;"
 180         <string-reader> "a" parse-stream drop
 181     ] times
 182 ] unit-test
 183
 184 "a" source-files get delete-at
 185
 186 [
 187     "IN: parser.tests : x ( -- ) ; : y ( -- * ) 3 throw ; this is an error"
 188     <string-reader> "a" parse-stream
 189 ] [ source-file-error? ] must-fail-with
 190
 191 [ t ] [
 192     "y" "parser.tests" lookup >boolean
 193 ] unit-test
 194
 195 [ f ] [
 196     "IN: parser.tests : x ( -- ) ;"
 197     <string-reader> "a" parse-stream drop
 198
 199     "y" "parser.tests" lookup
 200 ] unit-test
 201
 202 ! Test new forward definition logic
 203 [ ] [
 204     "IN: axx : axx ( -- ) ;"
 205     <string-reader> "axx" parse-stream drop
 206 ] unit-test
 207
 208 [ ] [
 209     "USE: axx IN: bxx : bxx ( -- ) ; : cxx ( -- ) axx bxx ;"
 210     <string-reader> "bxx" parse-stream drop
 211 ] unit-test
 212
 213 ! So we move the bxx word to axx...
 214 [ ] [
 215     "IN: axx : axx ( -- ) ; : bxx ( -- ) ;"
 216     <string-reader> "axx" parse-stream drop
 217 ] unit-test
 218
 219 [ t ] [ "bxx" "axx" lookup >boolean ] unit-test
 220
 221 ! And reload the file that uses it...
 222 [ ] [
 223     "USE: axx IN: bxx ( -- ) : cxx ( -- ) axx bxx ;"
 224     <string-reader> "bxx" parse-stream drop
 225 ] unit-test
 226
 227 ! And hope not to get a forward-error!
 228
 229 ! Turning a generic into a non-generic could cause all
 230 ! kinds of funnyness
 231 [ ] [
 232     "IN: ayy USE: kernel GENERIC: ayy ( a -- b ) M: object ayy ;"
 233     <string-reader> "ayy" parse-stream drop
 234 ] unit-test
 235
 236 [ ] [
 237     "IN: ayy USE: kernel : ayy ( -- ) ;"
 238     <string-reader> "ayy" parse-stream drop
 239 ] unit-test
 240
 241 [ ] [
 242     "IN: azz TUPLE: my-class ; GENERIC: a-generic ( a -- b )"
 243     <string-reader> "azz" parse-stream drop
 244 ] unit-test
 245
 246 [ ] [
 247     "USE: azz M: my-class a-generic ;"
 248     <string-reader> "azz-2" parse-stream drop
 249 ] unit-test
 250
 251 [ ] [
 252     "IN: azz GENERIC: a-generic ( a -- b )"
 253     <string-reader> "azz" parse-stream drop
 254 ] unit-test
 255
 256 [ ] [
 257     "USE: azz USE: math M: integer a-generic ;"
 258     <string-reader> "azz-2" parse-stream drop
 259 ] unit-test
 260
 261 [ ] [
 262     "IN: parser.tests : <bogus-error> ( -- ) ; : bogus ( -- error ) <bogus-error> ;"
 263     <string-reader> "bogus-error" parse-stream drop
 264 ] unit-test
 265
 266 [ ] [
 267     "IN: parser.tests TUPLE: bogus-error ; C: <bogus-error> bogus-error : bogus ( -- error ) <bogus-error> ;"
 268     <string-reader> "bogus-error" parse-stream drop
 269 ] unit-test
 270
 271 ! Problems with class predicates -vs- ordinary words
 272 [ ] [
 273     "IN: parser.tests TUPLE: killer ;"
 274     <string-reader> "removing-the-predicate" parse-stream drop
 275 ] unit-test
 276
 277 [ ] [
 278     "IN: parser.tests GENERIC: killer? ( a -- b )"
 279     <string-reader> "removing-the-predicate" parse-stream drop
 280 ] unit-test
 281
 282 [ t ] [
 283     "killer?" "parser.tests" lookup >boolean
 284 ] unit-test
 285
 286 [
 287     "IN: parser.tests TUPLE: another-pred-test ; GENERIC: another-pred-test? ( a -- b )"
 288     <string-reader> "removing-the-predicate" parse-stream
 289 ] [ error>> error>> error>> redefine-error? ] must-fail-with
 290
 291 [
 292     "IN: parser.tests TUPLE: class-redef-test ; TUPLE: class-redef-test ;"
 293     <string-reader> "redefining-a-class-1" parse-stream
 294 ] [ error>> error>> error>> redefine-error? ] must-fail-with
 295
 296 [ ] [
 297     "IN: parser.tests TUPLE: class-redef-test ; SYMBOL: class-redef-test"
 298     <string-reader> "redefining-a-class-2" parse-stream drop
 299 ] unit-test
 300
 301 [
 302     "IN: parser.tests TUPLE: class-redef-test ; SYMBOL: class-redef-test : class-redef-test ( -- ) ;"
 303     <string-reader> "redefining-a-class-3" parse-stream drop
 304 ] [ error>> error>> error>> redefine-error? ] must-fail-with
 305
 306 [ ] [
 307     "IN: parser.tests TUPLE: class-fwd-test ;"
 308     <string-reader> "redefining-a-class-3" parse-stream drop
 309 ] unit-test
 310
 311 [
 312     "IN: parser.tests \\ class-fwd-test"
 313     <string-reader> "redefining-a-class-3" parse-stream drop
 314 ] [ error>> error>> error>> no-word-error? ] must-fail-with
 315
 316 [ ] [
 317     "IN: parser.tests TUPLE: class-fwd-test ; SYMBOL: class-fwd-test"
 318     <string-reader> "redefining-a-class-3" parse-stream drop
 319 ] unit-test
 320
 321 [
 322     "IN: parser.tests \\ class-fwd-test"
 323     <string-reader> "redefining-a-class-3" parse-stream drop
 324 ] [ error>> error>> error>> no-word-error? ] must-fail-with
 325
 326 [
 327     "IN: parser.tests : foo ( -- ) ; TUPLE: foo ;"
 328     <string-reader> "redefining-a-class-4" parse-stream drop
 329 ] [ error>> error>> error>> redefine-error? ] must-fail-with
 330
 331 [ ] [
 332     "IN: parser.tests : foo ( x y -- z ) 1 2 ; : bar ( a -- b ) ;" eval( -- )
 333 ] unit-test
 334
 335 [
 336     "IN: parser.tests : foo ( x y -- z) 1 2 ; : bar ( a -- b ) ;" eval( -- )
 337 ] must-fail
 338
 339 [ ] [
 340     "IN: parser.tests USE: kernel PREDICATE: foo < object ;" eval( -- )
 341 ] unit-test
 342
 343 [ t ] [
 344     "foo" "parser.tests" lookup word eq?
 345 ] unit-test
 346
 347 [ ] [
 348     [
 349         "redefining-a-class-5" forget-source
 350         "redefining-a-class-6" forget-source
 351         "redefining-a-class-7" forget-source
 352     ] with-compilation-unit
 353 ] unit-test
 354
 355 2 [
 356     [ ] [
 357         "IN: parser.tests TUPLE: foo ; GENERIC: foo ( a -- b )"
 358         <string-reader> "redefining-a-class-5" parse-stream drop
 359     ] unit-test
 360
 361     [ ] [
 362         "IN: parser.tests M: f foo ;"
 363         <string-reader> "redefining-a-class-6" parse-stream drop
 364     ] unit-test
 365
 366     [ f ] [ f "foo" "parser.tests" lookup execute ] unit-test
 367
 368     [ ] [
 369         "IN: parser.tests TUPLE: foo ; GENERIC: foo ( a -- b )"
 370         <string-reader> "redefining-a-class-5" parse-stream drop
 371     ] unit-test
 372
 373     [ f ] [ f "foo" "parser.tests" lookup execute ] unit-test
 374
 375     [ ] [
 376         "IN: parser.tests TUPLE: foo ; GENERIC: foo ( a -- b )"
 377     <string-reader> "redefining-a-class-7" parse-stream drop
 378     ] unit-test
 379
 380     [ f ] [ f "foo" "parser.tests" lookup execute ] unit-test
 381
 382     [ ] [
 383         "IN: parser.tests TUPLE: foo ;"
 384         <string-reader> "redefining-a-class-7" parse-stream drop
 385     ] unit-test
 386
 387     [ t ] [ "foo" "parser.tests" lookup symbol? ] unit-test
 388 ] times
 389
 390 [ "vocab:parser/test/assert-depth.factor" run-file ] must-fail
 391
 392 2 [
 393     [ ] [
 394         "IN: parser.tests DEFER: d-f-s d-f-s SYMBOL: d-f-s d-f-s"
 395         <string-reader> "d-f-s-test" parse-stream drop
 396     ] unit-test
 397
 398     [ ] [
 399         "IN: parser.tests DEFER: d-f-s d-f-s FORGET: d-f-s SYMBOL: d-f-s d-f-s"
 400         <string-reader> "d-f-s-test" parse-stream drop
 401     ] unit-test
 402
 403     [ ] [
 404         "IN: parser.tests DEFER: d-f-s d-f-s SYMBOL: d-f-s d-f-s"
 405         <string-reader> "d-f-s-test" parse-stream drop
 406     ] unit-test
 407 ] times
 408
 409 [ ] [
 410     [ "this-better-not-exist" forget-vocab ] with-compilation-unit
 411 ] unit-test
 412
 413 [
 414     "USE: this-better-not-exist" eval( -- )
 415 ] must-fail
 416
 417 [ ": foo ;" eval( -- ) ] [ error>> error>> no-current-vocab? ] must-fail-with
 418
 419 [ 92 ] [ "CHAR: \\" eval( -- n ) ] unit-test
 420 [ 92 ] [ "CHAR: \\\\" eval( -- n ) ] unit-test
 421
 422 [ ] [
 423     {
 424         "IN: parser.tests"
 425         "USING: math arrays kernel ;"
 426         "GENERIC: change-combination ( obj a -- b )"
 427         "M: integer change-combination 2drop 1 ;"
 428         "M: array change-combination 2drop 2 ;"
 429     } "\n" join <string-reader> "change-combination-test" parse-stream drop
 430 ] unit-test
 431
 432 [ ] [
 433     {
 434         "IN: parser.tests"
 435         "USING: math arrays kernel ;"
 436         "GENERIC# change-combination 1 ( obj a -- b )"
 437         "M: integer change-combination 2drop 1 ;"
 438         "M: array change-combination 2drop 2 ;"
 439     } "\n" join <string-reader> "change-combination-test" parse-stream drop
 440 ] unit-test
 441
 442 [ 2 ] [
 443     "change-combination" "parser.tests" lookup
 444     "methods" word-prop assoc-size
 445 ] unit-test
 446
 447 [ ] [
 448     2 [
 449         "IN: parser.tests DEFER: twice-fails FORGET: twice-fails MIXIN: twice-fails"
 450         <string-reader> "twice-fails-test" parse-stream drop
 451     ] times
 452 ] unit-test
 453
 454 [ [ ] ] [
 455     "IN: parser.tests : staging-problem-test-1 ( -- a ) 1 ; : staging-problem-test-2 ( -- a ) staging-problem-test-1 ;"
 456     <string-reader> "staging-problem-test" parse-stream
 457 ] unit-test
 458
 459 [ t ] [ "staging-problem-test-1" "parser.tests" lookup >boolean ] unit-test
 460
 461 [ t ] [ "staging-problem-test-2" "parser.tests" lookup >boolean ] unit-test
 462
 463 [ [ ] ] [
 464     "IN: parser.tests << : staging-problem-test-1 ( -- a ) 1 ; >> : staging-problem-test-2 ( -- a ) staging-problem-test-1 ;"
 465     <string-reader> "staging-problem-test" parse-stream
 466 ] unit-test
 467
 468 [ t ] [ "staging-problem-test-1" "parser.tests" lookup >boolean ] unit-test
 469
 470 [ t ] [ "staging-problem-test-2" "parser.tests" lookup >boolean ] unit-test
 471
 472 [ "DEFER: blahy" eval( -- ) ] [ error>> error>> no-current-vocab? ] must-fail-with
 473
 474 [
 475     "IN: parser.tests SYNTAX: blahy ; FORGET: blahy" eval( -- )
 476 ] [
 477     error>> staging-violation?
 478 ] must-fail-with
 479
 480 ! Bogus error message
 481 DEFER: blahy
 482
 483 [ "IN: parser.tests USE: kernel TUPLE: blahy < tuple ; : blahy ( -- ) ; TUPLE: blahy < tuple ; : blahy ( -- ) ;" eval( -- ) ]
 484 [ error>> error>> def>> \ blahy eq? ] must-fail-with
 485
 486 [ "CHAR: \\u9999999999999" eval( -- n ) ] must-fail
 487
 488 SYMBOLS: a b c ;
 489
 490 [ a ] [ a ] unit-test
 491 [ b ] [ b ] unit-test
 492 [ c ] [ c ] unit-test
 493
 494 DEFER: blah
 495
 496 [ ] [ "IN: parser.tests GENERIC: blah ( -- )" eval( -- ) ] unit-test
 497 [ ] [ "IN: parser.tests SYMBOLS: blah ;" eval( -- ) ] unit-test
 498
 499 [ f ] [ \ blah generic? ] unit-test
 500 [ t ] [ \ blah symbol? ] unit-test
 501
 502 DEFER: blah1
 503
 504 [ "IN: parser.tests SINGLETONS: blah1 blah1 blah1 ;" eval( -- ) ]
 505 [ error>> error>> def>> \ blah1 eq? ]
 506 must-fail-with
 507
 508 IN: qualified.tests.foo
 509 : x ( -- a ) 1 ;
 510 : y ( -- a ) 5 ;
 511 IN: qualified.tests.bar
 512 : x ( -- a ) 2 ;
 513 : y ( -- a ) 4 ;
 514 IN: qualified.tests.baz
 515 : x ( -- a ) 3 ;
 516
 517 QUALIFIED: qualified.tests.foo
 518 QUALIFIED: qualified.tests.bar
 519 [ 1 2 3 ] [ qualified.tests.foo:x qualified.tests.bar:x x ] unit-test
 520
 521 QUALIFIED-WITH: qualified.tests.bar p
 522 [ 2 ] [ p:x ] unit-test
 523
 524 RENAME: x qualified.tests.baz => y
 525 [ 3 ] [ y ] unit-test
 526
 527 FROM: qualified.tests.baz => x ;
 528 [ 3 ] [ x ] unit-test
 529 [ 3 ] [ y ] unit-test
 530
 531 EXCLUDE: qualified.tests.bar => x ;
 532 [ 3 ] [ x ] unit-test
 533 [ 4 ] [ y ] unit-test
 534
 535 ! Two similar bugs
 536
 537 ! Replace : def with something in << >>
 538 /* [ [ ] ] [
 539     "IN: parser.tests : was-once-a-word-bug ( -- ) ;"
 540     <string-reader> "was-once-a-word-test" parse-stream
 541 ] unit-test
 542
 543 [ t ] [ "was-once-a-word-bug" "parser.tests" lookup >boolean ] unit-test
 544
 545 [ [ ] ] [
 546     "IN: parser.tests USE: words << \"was-once-a-word-bug\" \"parser.tests\" create [ ] ( -- ) define-declared >>"
 547     <string-reader> "was-once-a-word-test" parse-stream
 548 ] unit-test
 549
 550 [ t ] [ "was-once-a-word-bug" "parser.tests" lookup >boolean ] unit-test */
 551
 552 ! Replace : def with DEFER:
 553 [ [ ] ] [
 554     "IN: parser.tests : is-not-deferred ( -- ) ;"
 555     <string-reader> "is-not-deferred" parse-stream
 556 ] unit-test
 557
 558 [ t ] [ "is-not-deferred" "parser.tests" lookup >boolean ] unit-test
 559 [ f ] [ "is-not-deferred" "parser.tests" lookup deferred? ] unit-test
 560
 561 [ [ ] ] [
 562     "IN: parser.tests DEFER: is-not-deferred"
 563     <string-reader> "is-not-deferred" parse-stream
 564 ] unit-test
 565
 566 [ t ] [ "is-not-deferred" "parser.tests" lookup >boolean ] unit-test
 567 [ t ] [ "is-not-deferred" "parser.tests" lookup deferred? ] unit-test
 568
 569 ! Forward-reference resolution case iterated using list in the wrong direction
 570 [ [ ] ] [
 571     "IN: parser.tests.forward-ref-1 DEFER: x DEFER: y"
 572     <string-reader> "forward-ref-1" parse-stream
 573 ] unit-test
 574
 575 [ [ ] ] [
 576     "IN: parser.tests.forward-ref-2 DEFER: x DEFER: y"
 577     <string-reader> "forward-ref-2" parse-stream
 578 ] unit-test
 579
 580 [ [ ] ] [
 581     "IN: parser.tests.forward-ref-3 FROM: parser.tests.forward-ref-1 => x y ; FROM: parser.tests.forward-ref-2 => x y ; : z ( -- ) x y ;"
 582     <string-reader> "forward-ref-3" parse-stream
 583 ] unit-test
 584
 585 [ t ] [
 586     "z" "parser.tests.forward-ref-3" lookup def>> [ vocabulary>> ] map all-equal?
 587 ] unit-test
 588
 589 [ [ ] ] [
 590     "FROM: parser.tests.forward-ref-1 => x y ; FROM: parser.tests.forward-ref-2 => x y ; IN: parser.tests.forward-ref-3 : x ( -- ) ; : z ( -- ) x y ;"
 591     <string-reader> "forward-ref-3" parse-stream
 592 ] unit-test
 593
 594 [ f ] [
 595     "z" "parser.tests.forward-ref-3" lookup def>> [ vocabulary>> ] map all-equal?
 596 ] unit-test
 597
 598 [ [ ] ] [
 599     "IN: parser.tests.forward-ref-3 FROM: parser.tests.forward-ref-1 => x y ; FROM: parser.tests.forward-ref-2 => x y ; : z ( -- ) x y ;"
 600     <string-reader> "forward-ref-3" parse-stream
 601 ] unit-test
 602
 603 [ t ] [
 604     "z" "parser.tests.forward-ref-3" lookup def>> [ vocabulary>> ] map all-equal?
 605 ] unit-test
 606
 607 [ [ dup ] ] [
 608     "USE: kernel dup" <string-reader> "unuse-test" parse-stream
 609 ] unit-test
 610
 611 [
 612     "dup" <string-reader> "unuse-test" parse-stream
 613 ] [ error>> error>> error>> no-word-error? ] must-fail-with
 614
 615 [
 616     "USE: kernel UNUSE: kernel dup" <string-reader> "unuse-test" parse-stream
 617 ] [ error>> error>> error>> no-word-error? ] must-fail-with
 618
 619 [ ] [ [ "vocabs.loader.test.l" forget-vocab ] with-compilation-unit ] unit-test
 620
 621 [
 622     [ "vocabs.loader.test.l" use-vocab ] must-fail
 623     [ f ] [ "vocabs.loader.test.l" manifest get search-vocab-names>> key? ] unit-test
 624     [ ] [ "vocabs.loader.test.l" unuse-vocab ] unit-test
 625     [ f ] [ "vocabs.loader.test.l" manifest get search-vocab-names>> key? ] unit-test
 626 ] with-file-vocabs
 627
 628 ! Test cases for #183
 629 [ "SINGLETON: 33" <string-reader> "class identifier test" parse-stream ]
 630 [ error>> lexer-error? ] must-fail-with
 631
 632 [ ": 44 ( -- ) ;" <string-reader> "word identifier test" parse-stream ]
 633 [ error>> lexer-error? ] must-fail-with
 634
 635 [ "GENERIC: 33 ( -- )" <string-reader> "generic identifier test" parse-stream ]
 636 [ error>> lexer-error? ] must-fail-with