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 

    11 !PetitCompilerTest methodsFor:'context'!

    12 

    13 context	

    14 	^ context := PPCProfilingContext new

    15 ! !

    16 

    17 !PetitCompilerTest methodsFor:'running'!

    18 

    19 tearDown

    20     | parserClass |

    21 

    22     parserClass := (Smalltalk at: #PPGeneratedParser).

    23     parserClass notNil ifTrue:[ 

    24         parserClass removeFromSystem

    25     ].

    26 

    27     "Created: / 30-10-2014 / 22:56:19 / Jan Vrany <jan.vrany@fit.cvut.cz>"

    28 ! !

    29 

    30 !PetitCompilerTest methodsFor:'test support'!

    31 

    32 assert: p parse: whatever

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

    34 !

    35 

    36 compile: aPPParser

    37 	| compiler |

    38 	compiler := PPCCompiler new.

    39 	compiler profile: true.

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

    41 !

    42 

    43 compile: aPPParser params: params

    44 	| compiler |

    45 	compiler := PPCCompiler new.

    46 	compiler profile: true.

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

    48 !

    49 

    50 compileInlining: aPPParser

    51 	| compiler |

    52 	compiler := PPCCompiler new.

    53 	compiler inlining: true.

    54 	compiler profile: true.

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

    56 !

    57 

    58 compileTree: tree params: params

    59 	| compiler mock |

    60 	compiler := PPCCompiler new.

    61 	compiler profile: true.

    62 	mock := nil asParser.

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

    64 !

    65 

    66 parse: whatever

    67 	^ result := super parse: whatever.

    68 ! !

    69 

    70 !PetitCompilerTest methodsFor:'tests - compiling'!

    71 

    72 testCompileAnd

    73 	parser := #digit asParser and compile.

    74 	

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

    76 	self assert: parser fail: 'a'.

    77 	self assert: parser fail: ''.

    78 

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

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

    81 !

    82 

    83 testCompileAny

    84 	parser := #any asParser compile.

    85 	

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

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

    88 	self assert: parser parse: '

    89 ' to: Character cr.

    90 !

    91 

    92 testCompileAnyStar

    93 	parser := #any asParser star compile.

    94 	

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

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

    97 	

    98 !

    99 

   100 testCompileBlock

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

   102 	parser := parser compile.

   103 	

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

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

   106 	self assert: parser fail: ''.

   107 !

   108 

   109 testCompileCharacter

   110 	parser := $a asParser compile.

   111 	

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

   113 	self assert: parser fail: 'b'.

   114 

   115 	parser := $# asParser compile.

   116 	self assert: parser parse: '#'.

   117 !

   118 

   119 testCompileChoice

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

   121 	

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

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

   124 	self assert: parser fail: '_'.

   125 	

   126 !

   127 

   128 testCompileLiteral

   129 	parser := 'foo' asParser compile.

   130 	

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

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

   133 	self assert: parser fail: 'boo'.

   134 	

   135 	parser := '#[' asParser compile.

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

   137 !

   138 

   139 testCompileLiteral2

   140 	| quote |

   141 	quote := '''' asParser.

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

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

   144 !

   145 

   146 testCompileNegate

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

   148 	parser := parser compile.

   149 	

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

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

   152 	self assert: parser fail: '...'.

   153 !

   154 

   155 testCompileNil

   156 	parser := nil asParser compile.

   157 	

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

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

   160 	

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

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

   163 !

   164 

   165 testCompileNot

   166 	parser := #digit asParser not compile.

   167 	

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

   169 	self assert: parser fail: '1'.

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

   171 

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

   173 	parser := parser compile: #PPCompilerTest.	

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

   175 	

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

   177 	parser := parser compile: #PPCompilerTest.	

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

   179 !

   180 

   181 testCompileNot2

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

   183 		

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

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

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

   187 	self assert: parser fail: 'ab'.

   188 !

   189 

   190 testCompileNotLiteral

   191 	parser := 'foo' asParser not compile.

   192 	self assert: parser class methods size = 2.

   193 

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

   195 		

   196 	self assert: parser fail: 'foo'.

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

   198 

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

   200 	self assert: parser class methods size = 2.

   201 

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

   203 	self assert: parser fail: ''''.

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

   205 

   206 

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

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

   209 	

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

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

   212 	self assert: parser fail: 'foofoo'.

   213 !

   214 

   215 testCompileOptional

   216 	parser := #digit asParser optional compile.

   217 	

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

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

   220 	self assert: parser class parsers isEmpty.

   221 	

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

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

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

   225 	self assert: parser class parsers isEmpty.

   226 !

   227 

   228 testCompilePlus

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

   230 	

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

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

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

   234 

   235 	self assert: parser fail: ''.

   236 	self assert: parser fail: '123'.

   237 !

   238 

   239 testCompilePredicate

   240 	parser := #digit asParser compile.

   241 	

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

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

   244 	self assert: parser fail: 'a'.

   245 !

   246 

   247 testCompilePredicate2

   248 	parser := #space asParser compile.

   249 	

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

   251 	self assert: parser fail: 'a'.

   252 !

   253 

   254 testCompileSequence

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

   256 	

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

   258 	

   259 	

   260 !

   261 

   262 testCompileSequence2

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

   264 	

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

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

   267 	

   268 !

   269 

   270 testCompileSequence3

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

   272 	

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

   274 	self assert: parser fail: 'fo'.

   275 	

   276 !

   277 

   278 testCompileStar

   279 	parser := #letter asParser star compile.

   280 	

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

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

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

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

   285 !

   286 

   287 testCompileStarLiteral

   288 	parser := 'foo' asParser star compile.

   289 	

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

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

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

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

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

   295 !

   296 

   297 testCompileStarPredicate

   298 	parser := #letter asParser star compile.

   299 	

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

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

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

   303 !

   304 

   305 testCompileSymbolBlock

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

   307 	parser := parser compile: #PPCompilerTest.

   308 	

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

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

   311 	self assert: parser fail: ''.

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

   313 !

   314 

   315 testTrim

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

   317 	

   318 	self assert: parser fail: ''.

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

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

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

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

   323 ! !

   324 

   325 !PetitCompilerTest methodsFor:'tests - extra'!

   326 

   327 testCompileSmalltalkToken

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

   329 	

   330 	self assert: parser parse: 'foo'.

   331 	self assert: result inputValue = 'foo'.

   332 	self assert: parser parse: 'a'.

   333 	self assert: result inputValue = 'a'.

   334 	self assert: parser parse: 'f123a'.

   335 	self assert: result inputValue = 'f123a'.

   336 	

   337 	self assert: parser fail: ''.

   338 	self assert: parser fail: '12'.

   339 

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

   341 	self assert: result inputValue = 'foo'.

   342 	

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

   344 	self assert: result inputValue = 'bar'.

   345 	self assert: parser parse: '

   346 		"b"

   347 		"b"

   348 		foo

   349 		"and yet, another comment"

   350 

   351 		"one more to make sure :)"

   352 	'.

   353 	self assert: result inputValue = 'foo'.

   354 !

   355 

   356 testCycle

   357 	| p1 block |

   358 	

   359 	p1 := PPDelegateParser new.

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

   361 	p1 setParser: block.

   362 	

   363 	parser := block compile: #PPCompilerTest.

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

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

   366 	

   367 !

   368 

   369 testGuardSmalltlakToken

   370 	| charSet |

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

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

   373 	

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

   375 	self assert: parser parse: 'bar'.

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

   377 	

   378 	self assert: parser fail: '123'.

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

   380 !

   381 

   382 testSmalltalkToken

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

   384         

   385         self assert: parser class methodDictionary size = 6.

   386         self assert: parser parse: 'foo'.

   387         self assert: result inputValue = 'foo'.

   388         self assert: context invocationCount = 9.

   389         self assert: context rememberCount = 0.

   390         self assert: context lwRememberCount = 1.

   391         self assert: context lwRestoreCount = 0.

   392 

   393     "Modified: / 30-10-2014 / 23:20:57 / Jan Vrany <jan.vrany@fit.cvut.cz>"

   394 !

   395 

   396 testSmalltalkToken2

   397 	|id|

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

   399 		name: 'identifier';

   400 		yourself.

   401 		

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

   403 		name: 'kw';

   404 		yourself.

   405 	

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

   407 	

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

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

   410 !

   411 

   412 testToken

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

   414 	

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

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

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

   418 	self assert: parser fail: ''.

   419 !

   420 

   421 testToken2

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

   423         

   424         self assert: parser class methodDictionary size = 5.

   425         self assert: parser parse: 'foo'.

   426         self assert: result inputValue = 'foo'.

   427         self assert: context invocationCount = 7.

   428         self assert: context rememberCount = 0.

   429         self assert: context lwRememberCount = 1.

   430         self assert: context lwRestoreCount = 0.

   431 

   432     "Modified: / 30-10-2014 / 23:21:17 / Jan Vrany <jan.vrany@fit.cvut.cz>"

   433 !

   434 

   435 testTrimmingToken

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

   437 

   438         self assert: parser class methodDictionary size = 6.

   439         

   440         self assert: parser parse: 'foo'.

   441         self assert: result inputValue = 'foo'.

   442 

   443         self assert: context invocationCount = 9.

   444         self assert: context rememberCount = 0.

   445         self assert: context lwRememberCount = 1.

   446         self assert: context lwRestoreCount = 0.        

   447 

   448         self assert: parser parse: ' foo '.

   449         self assert: result inputValue = 'foo'.

   450 

   451 

   452 

   453         self assert: parser fail: '123'.

   454 

   455         self assert: context invocationCount = 3.

   456         self assert: context rememberCount = 0.

   457         self assert: context lwRememberCount = 0.

   458         self assert: context lwRestoreCount = 0.        

   459 

   460 

   461         self assert: parser fail: ''.

   462 

   463     "Modified: / 30-10-2014 / 23:21:23 / Jan Vrany <jan.vrany@fit.cvut.cz>"

   464 ! !

   465 

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

   467 

   468 testFirstSetSuchThat

   469 	| a b fs at |

   470 	a := $a asParser.

   471 	at := a trim.

   472 	b := $b asParser.

   473 	parser := b optional, at.

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

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

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

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

   478 !

   479 

   480 testFirstSetSuchThat2

   481 	| a b fs at bt |

   482 	a := $a asParser optional.

   483 	at := a trim.

   484 	b := $b asParser.

   485 	bt := b trim.

   486 	parser := at, bt.

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

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

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

   490 	self assert: fs size = 2.

   491 !

   492 

   493 testFirstSetSuchThat3

   494 	| a b c fs at bt ct |

   495 	a := $a asParser optional.

   496 	at := a trim.

   497 	b := $b asParser.

   498 	bt := b trim.

   499 	c := $c asParser.

   500 	ct := c trim.

   501 

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

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

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

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

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

   507 	self assert: fs size = 3.

   508 ! !

   509 

   510 !PetitCompilerTest methodsFor:'tests - guard'!

   511 

   512 testChoiceGuard

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

   514 		compileWithParameters: {#profile -> true}.

   515 	

   516 	self assert: parser parse: 'foo'.

   517 	self assert: result inputValue = 'foo'.	

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

   519 

   520 	self assert: parser parse: 'bar'.

   521 	self assert: result inputValue = 'bar'.	

   522 

   523 	self assert: parser parse: ' foo'.

   524 	self assert: result inputValue = 'foo'.	

   525 

   526 	self assert: parser parse: '  d'.

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

   528 

   529 	self assert: parser fail: ''.

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

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

   532 

   533 	self assert: parser fail: 'zorg'.		

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

   535 !

   536 

   537 testEmptyChoiceGuard

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

   539 		compileWithParameters: {#profile -> true}.

   540 	

   541 	self assert: parser parse: 'foo'.

   542 	self assert: result inputValue = 'foo'.	

   543 

   544 	self assert: parser parse: 'bar'.

   545 	self assert: result inputValue = 'bar'.	

   546 

   547 	self assert: parser parse: ' foo'.

   548 	self assert: result inputValue = 'foo'.	

   549 

   550 	self assert: parser parse: '  d'.

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

   552 

   553 	self assert: parser parse: ''.

   554 

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

   556 !

   557 

   558 testGuard1

   559 	| charSet |

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

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

   562 !

   563 

   564 testGuard2

   565 	| charSet |

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

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

   568 !

   569 

   570 testGuard3

   571 	| charSet |

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

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

   574 !

   575 

   576 testGuard4

   577 	| charSet |

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

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

   580 !

   581 

   582 testGuard5

   583 	| charSet |

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

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

   586 !

   587 

   588 testGuard6

   589 	| charSet |

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

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

   592 !

   593 

   594 testGuard7

   595 	| charSet |

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

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

   598 !

   599 

   600 testSequenceGuard

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

   602 	

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

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

   605 	self assert: parser fail: 'fo'.

   606 	

   607 !

   608 

   609 testTrimmerGuard

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

   611 	

   612 	self assert: parser parse: 'ab'.

   613 	self assert: parser parse: ' ab'.

   614 ! !

   615 

   616 !PetitCompilerTest methodsFor:'tests - verification'!

   617 

   618 testClass

   619 	| compiledParser normalParser source |

   620 	normalParser := PPSmalltalkGrammar new.

   621 	compiledParser := normalParser compile.

   622 	

   623 	Class methods do: [ :m |

   624 		source := m sourceCode.

   625 		self assert: (normalParser parse: source) 

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

   627 	].

   628 !

   629 

   630 testObject

   631         | compiledParser normalParser source |

   632         normalParser := PPSmalltalkGrammar new.

   633         compiledParser := normalParser compile.

   634         

   635         Object methodsDo: [ :m |

   636                 source := m sourceCode.

   637                 self assert: (normalParser parse: source) 

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

   639         ].

   640 

   641     "Modified: / 30-10-2014 / 23:22:00 / Jan Vrany <jan.vrany@fit.cvut.cz>"

   642 !

   643 

   644 testWhitespace

   645 	| compiledParser normalParser source |

   646 	normalParser := PPSmalltalkGrammar new.

   647 	compiledParser := normalParser compile.

   648 	

   649 	source := '  foo ^ 1'.

   650 	self assert: (normalParser parse: source) 

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

   652 ! !

   653 

   654 !PetitCompilerTest class methodsFor:'documentation'!

   655 

   656 version_HG

   657 

   658     ^ '$Changeset: <not expanded> $'

   659 ! !

   660