1 "{ Package: 'stx:goodies/petitparser/compiler/tests' }"

     2 

     3 PPAbstractParserTest subclass:#PetitCompilerTest

     4 	instanceVariableNames:'parser result context'

     5 	classVariableNames:''

     6 	poolDictionaries:''

     7 	category:'PetitCompiler-Tests-Core'

     8 !

     9 

    10 !PetitCompilerTest methodsFor:'context'!

    11 

    12 context	

    13 	^ context := PPCProfilingContext new

    14 ! !

    15 

    16 !PetitCompilerTest methodsFor:'test support'!

    17 

    18 assert: p parse: whatever

    19 	^ result := super assert: p parse: whatever.

    20 !

    21 

    22 compile: aPPParser

    23 	| compiler |

    24 	compiler := PPCCompiler new.

    25 	compiler profile: true.

    26 	^ (compiler compile: aPPParser as: #PPGeneratedParser) new.

    27 !

    28 

    29 compile: aPPParser params: params

    30 	| compiler |

    31 	compiler := PPCCompiler new.

    32 	compiler profile: true.

    33 	^ (compiler compile: aPPParser as: #PPGeneratedParser params: params) new.

    34 !

    35 

    36 compileInlining: aPPParser

    37 	| compiler |

    38 	compiler := PPCCompiler new.

    39 	compiler inlining: true.

    40 	compiler profile: true.

    41 	^ (compiler compile: aPPParser as: #PPGeneratedParser) new.

    42 !

    43 

    44 compileTree: tree params: params

    45 	| compiler mock |

    46 	compiler := PPCCompiler new.

    47 	compiler profile: true.

    48 	mock := nil asParser.

    49 	^ (compiler compileTree: tree as: #PPGeneratedParser parser: mock params: params) new.

    50 !

    51 

    52 parse: whatever

    53 	^ result := super parse: whatever.

    54 ! !

    55 

    56 !PetitCompilerTest methodsFor:'tests - compiling'!

    57 

    58 testCompileAnd

    59 	parser := #digit asParser and compile.

    60 	

    61 	self assert: parser parse: '1' to: $1 end: 0.

    62 	self assert: parser fail: 'a'.

    63 	self assert: parser fail: ''.

    64 

    65 	parser := ('foo' asParser, ($: asParser and)) compile.

    66 	self assert: parser parse: 'foo:' to: { 'foo'. $: } end: 3.

    67 !

    68 

    69 testCompileAny

    70 	parser := #any asParser compile.

    71 	

    72 	self assert: parser parse: 'a' to: $a.

    73 	self assert: parser parse: '_' to: $_.

    74 	self assert: parser parse: '

    75 ' to: Character cr.

    76 !

    77 

    78 testCompileAnyStar

    79 	parser := #any asParser star compile.

    80 	

    81 	self assert: parser parse: 'aaa' to: { $a. $a . $a }.

    82 	self assert: parser parse: '' to: { }.

    83 	

    84 !

    85 

    86 testCompileBlock

    87 	parser := (#letter asParser) plus ==> [ :res | res collect: [:each | each asUppercase ]].

    88 	parser := parser compile.

    89 	

    90 	self assert: parser parse: 'foo' to: { $F . $O . $O}.

    91 	self assert: parser parse: 'bar' to: { $B . $A . $R}.

    92 	self assert: parser fail: ''.

    93 !

    94 

    95 testCompileCharacter

    96 	parser := $a asParser compile.

    97 	

    98 	self assert: parser parse: 'a'  to: $a.

    99 	self assert: parser fail: 'b'.

   100 

   101 	parser := $# asParser compile.

   102 	self assert: parser parse: '#'.

   103 !

   104 

   105 testCompileChoice

   106 	parser := (#digit asParser / #letter asParser) compile.

   107 	

   108 	self assert: parser parse: '1' to: $1.

   109 	self assert: parser parse: 'a' to: $a.

   110 	self assert: parser fail: '_'.

   111 	

   112 !

   113 

   114 testCompileLiteral

   115 	parser := 'foo' asParser compile.

   116 	

   117 	self assert: parser parse: 'foo'  to: 'foo'.

   118 	self assert: parser parse: 'foobar'  to: 'foo' end: 3.

   119 	self assert: parser fail: 'boo'.

   120 	

   121 	parser := '#[' asParser compile.

   122 	self assert: parser parse: '#[1]' to: '#[' end: 2.

   123 !

   124 

   125 testCompileLiteral2

   126 	| quote |

   127 	quote := '''' asParser.

   128 	parser := (quote, $a asParser )compile: #PPCompilerTest.	

   129 	self assert: parser parse: '''a'  to: {'''' . $a}.	

   130 !

   131 

   132 testCompileNegate

   133 	parser := #letter asParser negate star, #letter asParser.

   134 	parser := parser compile.

   135 	

   136 	self assert: parser parse: '...a' to: { { $. . $. . $. } . $a }.

   137 	self assert: parser parse: 'aaa' to: { {} . $a } end: 1.

   138 	self assert: parser fail: '...'.

   139 !

   140 

   141 testCompileNil

   142 	parser := nil asParser compile.

   143 	

   144 	self assert: parser parse: 'a' to: nil end: 0.

   145 	self assert: parser parse: '' to: nil end: 0.

   146 	

   147 	parser := nil asParser, 'foo' asParser.

   148 	self assert: parser parse: 'foo' to: { nil . 'foo' }

   149 !

   150 

   151 testCompileNot

   152 	parser := #digit asParser not compile.

   153 	

   154 	self assert: parser parse: 'a' to: nil end: 0.

   155 	self assert: parser fail: '1'.

   156 	self assert: parser parse: '' to: nil end: 0.

   157 

   158 	parser := 'foo' asParser, $: asParser not.

   159 	parser := parser compile: #PPCompilerTest.	

   160 	self assert: parser parse: 'foo' to: { 'foo'. nil } end: 3.

   161 	

   162 	parser := 'foo' asParser, $: asParser not, 'bar' asParser.

   163 	parser := parser compile: #PPCompilerTest.	

   164 	self assert: parser parse: 'foobar' to: { 'foo'. nil . 'bar' } end: 6.

   165 !

   166 

   167 testCompileNot2

   168 	parser := ($a asParser, $b asParser) not compile.

   169 		

   170 	self assert: parser parse: '' to: nil end: 0.

   171 	self assert: parser parse: 'a' to: nil end: 0.

   172 	self assert: parser parse: 'aa' to: nil end: 0.

   173 	self assert: parser fail: 'ab'.

   174 !

   175 

   176 testCompileNotLiteral

   177 	parser := 'foo' asParser not compile.

   178 	self assert: parser class methods size = 2.

   179 

   180 	self assert: parser parse: 'bar' to: nil end: 0.

   181 		

   182 	self assert: parser fail: 'foo'.

   183 	self assert: parser parse: '' to: nil end: 0.

   184 

   185 	parser := '''' asParser not compile.

   186 	self assert: parser class methods size = 2.

   187 

   188 	self assert: parser parse: 'a' to: nil end: 0.

   189 	self assert: parser fail: ''''.

   190 	self assert: parser parse: '' to: nil end: 0.

   191 

   192 

   193 	parser := ('foo' asParser, 'bar' asParser not) compile.

   194 	self assert: parser parse: 'foofoo' to: { 'foo'. nil } end: 3.

   195 	

   196 	parser := ('foo' asParser, 'foo' asParser not, #any asParser star) compile.

   197 	self assert: parser parse: 'foobar' to: { 'foo'. nil . #($b $a $r) } end: 6.

   198 	self assert: parser fail: 'foofoo'.

   199 !

   200 

   201 testCompileOptional

   202 	parser := #digit asParser optional compile.

   203 	

   204 	self assert: parser parse: '1' to: $1.

   205 	self assert: parser parse: 'a' to: nil end: 0.

   206 	self assert: parser class parsers isEmpty.

   207 	

   208 	parser := (#digit asParser optional, #letter asParser) compile.

   209 	self assert: parser parse: '1a' to: { $1 . $a }.

   210 	self assert: parser parse: 'a' to: { nil . $a }.

   211 	self assert: parser class parsers isEmpty.

   212 !

   213 

   214 testCompilePlus

   215 	parser := #letter asParser plus compile: #PPCompilerTest.

   216 	

   217 	self assert: parser parse: 'lorem' to: {$l. $o. $r. $e. $m} .

   218 	self assert: parser parse: 'a123' to: {$a} end: 1.

   219 	self assert: parser parse: 'ab123' to: {$a . $b} end: 2.

   220 

   221 	self assert: parser fail: ''.

   222 	self assert: parser fail: '123'.

   223 !

   224 

   225 testCompilePredicate

   226 	parser := #digit asParser compile.

   227 	

   228 	self assert: parser parse: '1' to: $1.

   229 	self assert: parser parse: '0' to: $0.

   230 	self assert: parser fail: 'a'.

   231 !

   232 

   233 testCompilePredicate2

   234 	parser := #space asParser compile.

   235 	

   236 	self assert: parser parse: ' ' to: Character space.

   237 	self assert: parser fail: 'a'.

   238 !

   239 

   240 testCompileSequence

   241 	parser := (#digit asParser, #letter asParser) compile.

   242 	

   243 	self assert: parser parse: '1a' to: {$1 .$a}.

   244 	

   245 	

   246 !

   247 

   248 testCompileSequence2

   249 	parser := (#digit asParser, #space asParser, #letter asParser) compile: #PPCompilerTest.

   250 	

   251 	self assert: parser parse: '9 c' to: {$9 . Character space. $c }.	

   252 	self assert: parser fail: '9c'.

   253 	

   254 !

   255 

   256 testCompileSequence3

   257 	parser := (#any asParser, #any asParser, #any asParser) compile.

   258 	

   259 	self assert: parser parse: 'foo' to: #($f $o $o).	

   260 	self assert: parser fail: 'fo'.

   261 	

   262 !

   263 

   264 testCompileStar

   265 	parser := #letter asParser star compile.

   266 	

   267 	self assert: parser parse: 'lorem' to: {$l. $o. $r. $e. $m} .

   268 	self assert: parser parse: '' to: {}.

   269 	self assert: parser parse: '123' to: {} end: 0.

   270 	self assert: parser parse: 'ab123' to: {$a . $b} end: 2.

   271 !

   272 

   273 testCompileStarLiteral

   274 	parser := 'foo' asParser star compile.

   275 	

   276 	self assert: parser parse: 'foo' to: #('foo' ) .

   277 	self assert: parser parse: 'foofoo' to: #('foo' 'foo') .

   278 	self assert: parser parse: 'foofoofoo' to: #('foo' 'foo' 'foo') .

   279 	self assert: parser parse: '' to: #().

   280 	self assert: parser parse: 'bar' to: #() end: 0.

   281 !

   282 

   283 testCompileStarPredicate

   284 	parser := #letter asParser star compile.

   285 	

   286 	self assert: parser parse: 'foo' to: #($f $o $o ) .

   287 	self assert: parser parse: '' to: #().

   288 	self assert: parser parse: '123' to: #() end: 0.

   289 !

   290 

   291 testCompileSymbolBlock

   292 	parser := (#letter asParser) plus ==> #second.

   293 	parser := parser compile: #PPCompilerTest.

   294 	

   295 	self assert: parser parse: 'foo' to: $o.

   296 	self assert: parser parse: 'bar' to: $a.

   297 	self assert: parser fail: ''.

   298 	self should: [ parser parse: 'f' ] raise: Error.

   299 !

   300 

   301 testTrim

   302 	parser := self compile: $a asParser trim.

   303 	

   304 	self assert: parser fail: ''.

   305 	self assert: parser parse: 'a' to: $a.

   306 	self assert: parser parse: '   a' to: $a.

   307 	self assert: parser parse: 'a    ' to: $a.

   308 	self assert: parser parse: '  a    ' to: $a.

   309 ! !

   310 

   311 !PetitCompilerTest methodsFor:'tests - extra'!

   312 

   313 testCompileSmalltalkToken

   314 	parser := (#letter asParser, ((#letter asParser / #digit asParser) star)) smalltalkToken compile.

   315 	

   316 	self assert: parser parse: 'foo'.

   317 	self assert: result inputValue = 'foo'.

   318 	self assert: parser parse: 'a'.

   319 	self assert: result inputValue = 'a'.

   320 	self assert: parser parse: 'f123a'.

   321 	self assert: result inputValue = 'f123a'.

   322 	

   323 	self assert: parser fail: ''.

   324 	self assert: parser fail: '12'.

   325 

   326 	self assert: parser parse: ' "comment" foo'.

   327 	self assert: result inputValue = 'foo'.

   328 	

   329 	self assert: parser parse: ' "comment" bar "another comment" '.

   330 	self assert: result inputValue = 'bar'.

   331 	self assert: parser parse: '

   332 		"b"

   333 		"b"

   334 		foo

   335 		"and yet, another comment"

   336 

   337 		"one more to make sure :)"

   338 	'.

   339 	self assert: result inputValue = 'foo'.

   340 !

   341 

   342 testCycle

   343 	| p1 block |

   344 	

   345 	p1 := PPDelegateParser new.

   346 	block := ${ asParser, p1, $} asParser / nil asParser.

   347 	p1 setParser: block.

   348 	

   349 	parser := block compile: #PPCompilerTest.

   350 	self assert: parser parse: '{}' to: { ${. nil . $} }.

   351 	self assert: parser parse: '{{}}' to: { ${. { ${ . nil . $} } . $} }.

   352 	

   353 !

   354 

   355 testGuardSmalltlakToken

   356 	| charSet |

   357 	charSet := PPCCompiler new guardCharSet: 'foo' asParser smalltalkToken.

   358 	self assert: (charSet equals: (PPCharSetPredicate on: [ :char | char = $f ])).

   359 	

   360 	parser := (#letter asParser, #word asParser star) smalltalkToken compileWithParameters: { #profile -> true }.

   361 	self assert: parser parse: 'bar'.

   362 	self assert: (context invocations anySatisfy: [ :e | e beginsWith: 'seq' ]).

   363 	

   364 	self assert: parser fail: '123'.

   365 	self assert: (context invocations noneSatisfy: [ :e | e beginsWith: 'seq' ]).

   366 !

   367 

   368 testSmalltalkToken

   369 	parser := (#letter asParser, (#digit asParser / #letter asParser) star) smalltalkToken compileWithParameters: {#profile -> true}.

   370 	

   371 	self assert: parser class methods size = 6.

   372 	self assert: parser parse: 'foo'.

   373 	self assert: result inputValue = 'foo'.

   374 	self assert: context invocationCount = 9.

   375 	self assert: context rememberCount = 0.

   376 	self assert: context lwRememberCount = 1.

   377 	self assert: context lwRestoreCount = 0.	

   378 !

   379 

   380 testSmalltalkToken2

   381 	|id|

   382 	id := (#letter asParser, (#digit asParser / #letter asParser) star)

   383 		name: 'identifier';

   384 		yourself.

   385 		

   386 	parser := (id, $: asParser) smalltalkToken 

   387 		name: 'kw';

   388 		yourself.

   389 	

   390 	parser := parser compileWithParameters: {#profile -> true}.

   391 	

   392 	self assert: parser parse: 'foo:'.

   393 	self assert: result inputValue = 'foo:'.

   394 !

   395 

   396 testToken

   397 	parser := (#letter asParser, (#digit asParser / #letter asParser) star) flatten compile.

   398 	

   399 	self assert: parser parse: 'foo' to: 'foo'.

   400 	self assert: parser parse: 'a' to: 'a'.

   401 	self assert: parser parse: 'f123a' to: 'f123a'.

   402 	self assert: parser fail: ''.

   403 !

   404 

   405 testToken2

   406 	parser := (#letter asParser, (#digit asParser / #letter asParser) star) token compileWithParameters: {#profile -> true}.

   407 	

   408 	self assert: parser class methods size = 5.

   409 	self assert: parser parse: 'foo'.

   410 	self assert: result inputValue = 'foo'.

   411 	self assert: context invocationCount = 7.

   412 	self assert: context rememberCount = 0.

   413 	self assert: context lwRememberCount = 1.

   414 	self assert: context lwRestoreCount = 0.	

   415 !

   416 

   417 testTrimmingToken

   418 	parser := (#letter asParser, (#digit asParser / #letter asParser) star) trimmingToken compileWithParameters: { #profile -> true }.

   419 

   420 	self assert: parser class methods size = 6.

   421 	

   422 	self assert: parser parse: 'foo'.

   423 	self assert: result inputValue = 'foo'.

   424 

   425 	self assert: context invocationCount = 9.

   426 	self assert: context rememberCount = 0.

   427 	self assert: context lwRememberCount = 1.

   428 	self assert: context lwRestoreCount = 0.	

   429 

   430 	self assert: parser parse: ' foo '.

   431 	self assert: result inputValue = 'foo'.

   432 

   433 

   434 

   435 	self assert: parser fail: '123'.

   436 

   437 	self assert: context invocationCount = 3.

   438 	self assert: context rememberCount = 0.

   439 	self assert: context lwRememberCount = 0.

   440 	self assert: context lwRestoreCount = 0.	

   441 

   442 

   443 	self assert: parser fail: ''.

   444 ! !

   445 

   446 !PetitCompilerTest methodsFor:'tests - first set'!

   447 

   448 testFirstSetSuchThat

   449 	| a b fs at |

   450 	a := $a asParser.

   451 	at := a trim.

   452 	b := $b asParser.

   453 	parser := b optional, at.

   454 	fs :=	parser firstSetSuchThat: [ :e | (e isKindOf: PPTrimmingParser) or: [ e isTerminal  ] ].

   455 	self assert: (fs anySatisfy: [ :e | e = at ]).

   456 	self assert: (fs anySatisfy: [ :e | e = b ]).

   457 	self assert: (fs noneSatisfy: [ :e | e = a ]).	

   458 !

   459 

   460 testFirstSetSuchThat2

   461 	| a b fs at bt |

   462 	a := $a asParser optional.

   463 	at := a trim.

   464 	b := $b asParser.

   465 	bt := b trim.

   466 	parser := at, bt.

   467 	fs :=	parser firstSetSuchThat: [ :e | (e isKindOf: PPTrimmingParser) or: [ e isTerminal  ] ].

   468 	self assert: (fs anySatisfy: [ :e | e = at ]).

   469 	self assert: (fs anySatisfy: [ :e | e = bt ]).

   470 	self assert: fs size = 2.

   471 !

   472 

   473 testFirstSetSuchThat3

   474 	| a b c fs at bt ct |

   475 	a := $a asParser optional.

   476 	at := a trim.

   477 	b := $b asParser.

   478 	bt := b trim.

   479 	c := $c asParser.

   480 	ct := c trim.

   481 

   482 	parser := (at, bt optional) wrapped, at, ct.

   483 	fs :=	parser firstSetSuchThat: [ :e | (e isKindOf: PPTrimmingParser) or: [ e isTerminal  ] ].

   484 	self assert: (fs anySatisfy: [ :e | e = at ]).

   485 	self assert: (fs anySatisfy: [ :e | e = bt ]).

   486 	self assert: (fs anySatisfy: [ :e | e = ct ]).

   487 	self assert: fs size = 3.

   488 ! !

   489 

   490 !PetitCompilerTest methodsFor:'tests - guard'!

   491 

   492 testChoiceGuard

   493 	parser := ('foo' asParser trimmingToken / 'bar' asParser trimmingToken / $d asParser trimmingToken plus) 

   494 		compileWithParameters: {#profile -> true}.

   495 	

   496 	self assert: parser parse: 'foo'.

   497 	self assert: result inputValue = 'foo'.	

   498 	self assert: (context invocations anySatisfy: [ :e | e beginsWith: 'token' ]).

   499 

   500 	self assert: parser parse: 'bar'.

   501 	self assert: result inputValue = 'bar'.	

   502 

   503 	self assert: parser parse: ' foo'.

   504 	self assert: result inputValue = 'foo'.	

   505 

   506 	self assert: parser parse: '  d'.

   507 	self assert: result first inputValue = 'd'.	

   508 

   509 	self assert: parser fail: ''.

   510 	self assert: (context invocations noneSatisfy: [ :e | e beginsWith: 'predicate' ]).

   511 	self assert: (context invocations noneSatisfy: [ :e | e beginsWith: 'token' ]).

   512 

   513 	self assert: parser fail: 'zorg'.		

   514 	self assert: (context invocations noneSatisfy: [ :e | e beginsWith: 'token' ]).

   515 !

   516 

   517 testEmptyChoiceGuard

   518 	parser := ('foo' asParser trimmingToken / 'bar' asParser trimmingToken / $d asParser trimmingToken star) 

   519 		compileWithParameters: {#profile -> true}.

   520 	

   521 	self assert: parser parse: 'foo'.

   522 	self assert: result inputValue = 'foo'.	

   523 

   524 	self assert: parser parse: 'bar'.

   525 	self assert: result inputValue = 'bar'.	

   526 

   527 	self assert: parser parse: ' foo'.

   528 	self assert: result inputValue = 'foo'.	

   529 

   530 	self assert: parser parse: '  d'.

   531 	self assert: result first inputValue = 'd'.	

   532 

   533 	self assert: parser parse: ''.

   534 

   535 	self assert: parser parse: 'zorg' end: 0.	

   536 !

   537 

   538 testGuard1

   539 	| charSet |

   540 	charSet := PPCCompiler new guardCharSet: $a asParser.

   541 	self assert: (charSet equals: (PPCharSetPredicate on: [ :char | char = $a ])).

   542 !

   543 

   544 testGuard2

   545 	| charSet |

   546 	charSet := PPCCompiler new guardCharSet: #letter asParser.

   547 	self assert: (charSet equals: (PPCharSetPredicate on: [ :char | char isLetter ])).

   548 !

   549 

   550 testGuard3

   551 	| charSet |

   552 	charSet := PPCCompiler new guardCharSet: #letter asParser not.

   553 	self assert: (charSet equals: (PPCharSetPredicate on: [ :char | char isLetter not ])).

   554 !

   555 

   556 testGuard4

   557 	| charSet |

   558 	charSet := PPCCompiler new guardCharSet: (#letter asParser, #word asParser star).

   559 	self assert: (charSet equals: (PPCharSetPredicate on: [ :char | char isLetter ])).

   560 !

   561 

   562 testGuard5

   563 	| charSet |

   564 	charSet := PPCCompiler new guardCharSet: 'foo' asParser.

   565 	self assert: (charSet equals: (PPCharSetPredicate on: [ :char | char = $f ])).

   566 !

   567 

   568 testGuard6

   569 	| charSet |

   570 	charSet := PPCCompiler new guardCharSet: ('foo' asParser trimmingToken asCompilerTree optimizeTree).

   571 	self assert: (charSet equals: (PPCharSetPredicate on: [ :char | (char = $f) ]))

   572 !

   573 

   574 testGuard7

   575 	| charSet |

   576 	charSet := PPCCompiler new guardCharSet: ('foo' asParser trimmingToken / 'bar' asParser trimmingToken) asCompilerTree optimizeTree.

   577 	self assert: (charSet equals: (PPCharSetPredicate on: [ :char | (char = $f) or: [ char = $b ]] )).

   578 !

   579 

   580 testSequenceGuard

   581 	parser := ((#any asParser, #any asParser) wrapped, (#any asParser, #any asParser)) compile.

   582 	

   583 	self assert: parser parse: 'fooo' to: #(#($f $o) #($o $o)).	

   584 	self assert: parser parse: 'fo oo' to: #(#($f $o) #($  $o)) end: 4.	

   585 	self assert: parser fail: 'fo'.

   586 	

   587 !

   588 

   589 testTrimmerGuard

   590 	parser := $a asParser trim, $b asParser compile: #PPGeneratedParser parameters: { #profile -> true }.

   591 	

   592 	self assert: parser parse: 'ab'.

   593 	self assert: parser parse: ' ab'.

   594 ! !

   595 

   596 !PetitCompilerTest methodsFor:'tests - verification'!

   597 

   598 testClass

   599 	| compiledParser normalParser source |

   600 	normalParser := PPSmalltalkGrammar new.

   601 	compiledParser := normalParser compile.

   602 	

   603 	Class methods do: [ :m |

   604 		source := m sourceCode.

   605 		self assert: (normalParser parse: source) 

   606 			  equals: (compiledParser parse: source withContext: self context). 

   607 	].

   608 !

   609 

   610 testObject

   611 	| compiledParser normalParser source |

   612 	normalParser := PPSmalltalkGrammar new.

   613 	compiledParser := normalParser compile.

   614 	

   615 	Object methods do: [ :m |

   616 		source := m sourceCode.

   617 		self assert: (normalParser parse: source) 

   618 			  equals: (compiledParser parse: source withContext: self context). 

   619 	].

   620 !

   621 

   622 testWhitespace

   623 	| compiledParser normalParser source |

   624 	normalParser := PPSmalltalkGrammar new.

   625 	compiledParser := normalParser compile.

   626 	

   627 	source := '  foo ^ 1'.

   628 	self assert: (normalParser parse: source) 

   629 		  equals: (compiledParser parse: source withContext: self context).

   630 ! !

   631