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

     2 

     3 TestCase subclass:#PPCNodeFirstFollowNextTests

     4 	instanceVariableNames:'tree first node followSet'

     5 	classVariableNames:''

     6 	poolDictionaries:''

     7 	category:'PetitCompiler-Tests-Nodes'

     8 !

     9 

    10 !PPCNodeFirstFollowNextTests methodsFor:'as yet unclassified'!

    11 

    12 assert: set anyMatchesType: whatever

    13 	self assert: (set anySatisfy: [:e | e isKindOf: whatever ])

    14 !

    15 

    16 assert: set anySatisfy: whateverBlock

    17 	self assert: (set anySatisfy: [:e |  [whateverBlock value: e]  on: Error do: [ false ] ])

    18 !

    19 

    20 assert: set noneMatchesType: whatever

    21 	self assert: (set noneSatisfy: [:e | e isKindOf: whatever ])

    22 !

    23 

    24 assert: set noneSatisfy: whateverBlock

    25 	self assert: (set noneSatisfy: [:e |  [whateverBlock value: e]  on: Error do: [ false ] ])

    26 !

    27 

    28 assert: set size: anInteger

    29 	self assert: (set size = anInteger )

    30 !

    31 

    32 first: aNode 

    33 	^ aNode firstSet

    34 !

    35 

    36 first: aNode suchThat: aBlock

    37 	^ (aNode firstSetsSuchThat: aBlock) at: aNode

    38 !

    39 

    40 followOf: name in: rootNode

    41 	node := (rootNode allNodes select: [ :n | n name = name ] )anyOne.

    42 	^ rootNode followSets at: node

    43 !

    44 

    45 followOf: name in: rootNode suchThat: aBlock

    46 	node := (rootNode allNodes select: [ :n | n name = name ] )anyOne.

    47 	^ (rootNode followSetsSuchThat: aBlock) at: node

    48 !

    49 

    50 followOfNodeIn: rootNode

    51 	^ self followOf: 'node' in: rootNode

    52 !

    53 

    54 testFirst1

    55 	tree := self treeFrom: nil asParser / 'a' asParser.

    56 	

    57 	self assert: (self first: tree) anyMatchesType: PPCNilNode.

    58 	self assert: (self first: tree) anyMatchesType: PPCAbstractLiteralNode.

    59 !

    60 

    61 testFirst2

    62 	tree := self treeFrom: 'a' asParser optional, 'b' asParser.

    63 	

    64 	self assert: (self first: tree) anySatisfy: [ :e | e literal = 'a' ].

    65 	self assert: (self first: tree) anySatisfy: [ :e | e literal = 'b' ].

    66 !

    67 

    68 testFirst3

    69 	tree := ('a' asParser optional, 'b' asParser asParser optional), 'c' asParser.

    70 	

    71 	self assert: (self first: tree) anySatisfy: [ :e | e literal = 'a' ].

    72 	self assert: (self first: tree) anySatisfy: [ :e | e literal = 'b' ].

    73 	self assert: (self first: tree) anySatisfy: [ :e | e literal = 'c' ].

    74 !

    75 

    76 testFirstChoice1

    77 	tree := self treeFrom: nil asParser / '' asParser.

    78 	

    79 	self assert: (self first: tree) anySatisfy: [:e | e literal = ''].

    80 	self assert: (self first: tree) anyMatchesType: PPCNilNode.

    81 !

    82 

    83 testFirstChoice2

    84 	tree := self treeFrom: 'a' asParser / nil asParser / 'b' asParser.

    85 	

    86 	first := (self first: tree).

    87 	

    88 	self assert: first anySatisfy: [:e | e literal =  'a'].

    89 	self assert: first anySatisfy: [:e | e literal = 'b'].

    90 	self assert: first anyMatchesType: PPCNilNode.

    91 !

    92 

    93 testFirstComplex1

    94 	tree := self treeFrom: ('a' asParser / nil asParser), 'c' asParser.

    95 	

    96 	first := (self first: tree).

    97 	

    98 	self assert: first size: 2.

    99 	self assert: first anySatisfy: [:e | e literal = 'a'].

   100 	self assert: first anySatisfy: [:e | e literal = 'c'].

   101 	self assert: first noneMatchesType: PPCNilNode.

   102 !

   103 

   104 testFirstComplex2

   105 	tree := self treeFrom: ('a' asParser / nil asParser / 'b' asParser), 'c' asParser.

   106 	

   107 	

   108 	first := (self first: tree).

   109 	

   110 	self assert: first size: 3.

   111 	self assert: first anySatisfy: [:e | e literal = 'a'].

   112 	self assert: first anySatisfy: [:e | e literal = 'b'].

   113 	self assert: first anySatisfy: [:e | e literal = 'c'].

   114 !

   115 

   116 testFirstComplex3

   117 	tree := self treeFrom: ('a' asParser / nil asParser / 'b' asParser), 'c' asParser not.

   118 	

   119 	first := (self first: tree).

   120 	

   121 	self assert: first anySatisfy: [:e | e literal = 'a'].

   122 	self assert: first anySatisfy: [:e | e literal = 'b'].

   123 	self assert: first anySatisfy: [:e | (e isKindOf: PPCNotLiteralNode) and: [e literal = 'c']].

   124 !

   125 

   126 testFirstComplex4

   127 	tree := (('a' asParser / nil asParser / 'b' asParser), 'c' asParser not) wrapped asCompilerTree.

   128 	

   129 	first := (self first: tree).

   130 	

   131 	self assert: first anySatisfy: [:e | e literal = 'a'].

   132 	self assert: first anySatisfy: [:e | e literal = 'b'].

   133 	self assert: first anySatisfy: [:e | (e isKindOf: PPCNotNode) and: [ e child literal = 'c' ]].

   134 	self assert: first noneMatchesType: PPCNilNode.

   135 !

   136 

   137 testFirstNegate1

   138 	tree := ('a' asParser negate, 'b' asParser) asCompilerTree.

   139 	

   140 	first := self first: tree.

   141 

   142 	self assert: first size: 1.

   143 	self assert: first anyMatchesType: PPCNotNode

   144 !

   145 

   146 testFirstNot

   147 	tree := ('a' asParser not star, 'b' asParser) asCompilerTree.

   148 	

   149 	first := self first: tree.

   150 		

   151 	self assert: first size: 2.

   152 	self assert: first anyMatchesType: PPCNotNode.

   153 !

   154 

   155 testFirstNot2

   156 	tree := ('a' asParser not star, 'b' asParser) asCompilerTree optimizeTree.

   157 	

   158 	first := self first: tree.

   159 		

   160 	self assert: first size: 2.

   161 	self assert: first anyMatchesType: PPCNotLiteralNode.

   162 	self assert: first anyMatchesType: PPCLiteralNode.

   163 !

   164 

   165 testFirstNot3

   166 	tree := (#letter asParser not star, #letter asParser) asCompilerTree optimizeTree.

   167 	

   168 	first := self first: tree.

   169 		

   170 	self assert: first size: 2.

   171 	self assert: first anyMatchesType: PPCNotMessagePredicateNode.

   172 	self assert: first anyMatchesType: PPCMessagePredicateNode.

   173 !

   174 

   175 testFirstNot4

   176 	tree := (#letter asParser negate plus, #letter asParser) asCompilerTree optimizeTree.

   177 	

   178 	first := self first: tree.

   179 		

   180 	self assert: first size: 1.

   181 	self assert: (first anyOne predicate value: $a) not.

   182 	self assert: (first anyOne predicate value: $1).

   183 !

   184 

   185 testFirstNot5

   186 	tree := (#letter asParser negate star, #letter asParser) asCompilerTree optimizeTree.

   187 	

   188 	first := self first: tree.

   189 		

   190 	self assert: first size: 2.

   191 	self assert: first anySatisfy: [ :e |	(e predicate value: $a) not ].

   192 	self assert: first anySatisfy: [ :e |	(e predicate value: $1) ].

   193 

   194 

   195 	self assert: first anySatisfy: [ :e |	(e predicate value: $a) ].

   196 	self assert: first anySatisfy: [ :e |	(e predicate value: $1) not ].

   197 !

   198 

   199 testFirstOptional

   200 	tree := 'a' asParser optional asCompilerTree.

   201 	

   202 	first := (self first: tree).

   203 	

   204 	self assert: first anyMatchesType: PPCNilNode.

   205 	self assert: first anyMatchesType: PPCLiteralNode.

   206 !

   207 

   208 testFirstOptional2

   209 	tree := ('a' asParser optional, 'b' asParser) asCompilerTree.

   210 	

   211 	first := (self first: tree).

   212 	

   213 	self assert: first size: 2.

   214 	self assert: first anySatisfy: [ :e | e literal = 'a' ].

   215 	self assert: first anySatisfy: [ :e | e literal = 'b' ].

   216 !

   217 

   218 testFirstRepeat1

   219 	tree := ('a' asParser / nil asParser) plus asCompilerTree.

   220 	

   221 	first := self first: tree.

   222 

   223 	self assert: first anySatisfy: [:e | e literal = 'a' ].

   224 	self assert: first anyMatchesType: PPCNilNode.	

   225 !

   226 

   227 testFirstRepeat2

   228 	tree := ('a' asParser star, 'b' asParser) asCompilerTree.

   229 	

   230 	first := self first: tree.

   231 

   232 	self assert: first anySatisfy: [:e | e literal = 'a' ].

   233 	self assert: first anySatisfy: [:e | e literal = 'b' ].

   234 !

   235 

   236 testFirstRepeat3

   237 	tree := ('a' asParser negate plus, 'b' asParser) asCompilerTree.

   238 	

   239 	first := self first: tree.

   240 

   241 	self assert: first size: 1.

   242 	self assert: first anyMatchesType: PPCNotNode.

   243 !

   244 

   245 testFirstRepeat4

   246 	tree := ('a' asParser negate star, 'b' asParser) asCompilerTree.

   247 	

   248 	first := self first: tree.

   249 

   250 	self assert: first size: 2.

   251 	self assert: first anySatisfy: [:e | (e isKindOf: PPCNotNode) and: [e child literal = 'a']].

   252 	self assert: first anySatisfy: [ :e | e literal = 'b' ]

   253 !

   254 

   255 testFirstSequence1

   256 	tree := self treeFrom: 'a' asParser, 'b' asParser .

   257 	

   258 	first := self first: tree.

   259 	

   260 	self assert: first size: 1.

   261 	self assert: first anySatisfy: [ :e | e literal = 'a' ].

   262 !

   263 

   264 testFirstSequence2

   265 	tree := nil asParser, 'a' asParser, 'b' asParser .

   266 	

   267 	first := self first: tree.

   268 	

   269 	self assert: first size: 1.

   270 	self assert: first anySatisfy: [ :e | e literal = 'a' ].

   271 !

   272 

   273 testFirstSequence3

   274 	tree := self treeFrom: nil asParser, nil asParser.

   275 	

   276 	first := self first: tree.

   277 	

   278 	self assert: first size: 1.

   279 	self assert: first anyMatchesType: PPCNilNode.

   280 !

   281 

   282 testFirstSequence4

   283 	tree := self treeFrom: ((nil asParser / 'a' asParser) plus), 'b' asParser.

   284 	

   285 	first := self first: tree.

   286 	

   287 	self assert: first size: 2.

   288 	self assert: first anySatisfy: [ :e | e literal = 'a' ].

   289 	self assert: first anySatisfy: [ :e | e literal = 'b' ].

   290 	self assert: first noneMatchesType: PPCNilNode.

   291 !

   292 

   293 testFirstSequence5

   294 	tree := ((nil asParser / 'a' asParser) star), 'b' asParser.

   295 	

   296 	first := self first: tree.

   297 	

   298 	self assert: first size: 2.

   299 	self assert: first anySatisfy: [ :e | e literal = 'a' ].

   300 	self assert: first anySatisfy: [ :e | e literal = 'b' ].

   301 	self assert: first noneMatchesType: PPCNilNode.

   302 !

   303 

   304 testFirstTerminal

   305 	tree := self treeFrom: 'a' asParser not.

   306 

   307 	first := self first: tree.

   308 	

   309 	self assert: first size: 1.

   310 	self assert: (self first: tree) anyMatchesType: PPCNotLiteralNode.

   311 !

   312 

   313 testFirstTerminal2

   314 	tree := self treeFrom: 'a' asParser and.

   315 	

   316 	first := self first: tree.

   317 	

   318 	self assert: first size: 1.

   319 	self assert: first anySatisfy: [: e | e literal = 'a' ]

   320 !

   321 

   322 testFirstTrimmingToken

   323 	tree := self treeFrom: 'a' asParser trimmingToken.

   324 	

   325 	first := self first: tree 

   326 					  suchThat: [:e | (e isKindOf: PPCTrimmingTokenNode) or: [e isFirstSetTerminal]].

   327 	

   328 	self assert: first size: 1.

   329 	self assert: first anyMatchesType: PPCTrimmingTokenNode

   330 !

   331 

   332 testFollowSet1

   333 	node := 'a' asParser name: 'node'; yourself.

   334 	tree := self treeFrom: (node star, 'b' asParser).

   335 	

   336 	followSet := self followOfNodeIn: tree.

   337 	

   338 	self assert: followSet size: 2.

   339 	self assert: followSet anySatisfy: [:e | e literal = 'a'].

   340 	self assert: followSet anySatisfy: [:e | e literal = 'b'].

   341 !

   342 

   343 testFollowSet10

   344 	| a b c |

   345 	

   346 	a := 'a' asParser name: 'a'; yourself.

   347 	b := 'b' asParser optional name: 'b'; yourself.

   348 	c := 'c' asParser name: 'c'; yourself.

   349 	

   350 	

   351 		

   352 	tree := self treeFrom: a plus, b, c.

   353 

   354 	followSet := self followOf: 'a' in: tree.

   355 

   356 	self assert: followSet size: 3.

   357 	self assert: followSet anySatisfy: [:e | e literal = 'a' ].	

   358 	self assert: followSet anySatisfy: [:e | e literal =  'b' ].

   359 	self assert: followSet anySatisfy: [:e | e literal = 'c' ].

   360 !

   361 

   362 testFollowSet2

   363 	| follow |

   364 	node := 'a' asParser name: 'node'; yourself.

   365 	follow := 'b' asParser, 'c' asParser.

   366 	

   367 	tree := self treeFrom: (node, follow).

   368 

   369 	followSet := self followOfNodeIn: tree.

   370 

   371 	self assert: followSet size: 1.

   372 	self assert: followSet anySatisfy: [:e | e literal = 'b'].

   373 	self assert: followSet noneSatisfy: [:e | e literal = 'c'].	

   374 !

   375 

   376 testFollowSet3

   377 	| follow |

   378 

   379 	node := 'a' asParser name: 'node'; yourself.

   380 	follow := ('b' asParser, 'c' asParser) / ('d' asParser).

   381 	

   382 	

   383 	tree := self treeFrom: (node, follow).

   384 

   385 	followSet := self followOfNodeIn: tree.

   386 

   387 	self assert: followSet size: 2.

   388 	self assert: followSet anySatisfy: [:e | e literal = 'b' ].

   389 	self assert: followSet anySatisfy: [:e | e literal = 'd' ].

   390 !

   391 

   392 testFollowSet4

   393 	| follow |

   394 

   395 	node := 'a' asParser name: 'node'; yourself.

   396 	follow := ('b' asParser, 'c' asParser).

   397 	

   398 	

   399 	tree := self treeFrom: (node star, follow).

   400 

   401 	followSet := self followOfNodeIn: tree.

   402 

   403 	self assert: followSet anySatisfy: [:e | e literal = 'b' ].

   404 	self assert: followSet anySatisfy: [:e | e literal = 'a' ].

   405 !

   406 

   407 testFollowSet5

   408 	| follow1 follow2 |

   409 

   410 	node := 'a' asParser name: 'node'; yourself.

   411 	follow1 := ('b' asParser, 'c' asParser) / nil asParser.

   412 	follow2 := 'd' asParser.

   413 	

   414 	

   415 	tree := self treeFrom: (node, follow1, follow2).

   416 

   417 	followSet := self followOfNodeIn: tree.

   418 

   419 	self assert: followSet anySatisfy: [:e | e literal = 'b' ].

   420 	self assert: followSet anySatisfy: [:e | e literal = 'd' ].

   421 !

   422 

   423 testFollowSet6

   424 	| follow follow1 follow2 |

   425 

   426 	node := 'a' asParser name: 'node'; yourself.

   427 	follow1 := ('b' asParser, 'c' asParser) / nil asParser.

   428 	follow2 := 'd' asParser.

   429 	

   430 	follow := (follow1, follow2).

   431 	

   432 	tree  := self treeFrom: (node, follow).

   433 

   434 	followSet := self followOfNodeIn: tree.

   435 

   436 	self assert: followSet anySatisfy: [:e | e literal = 'b' ].

   437 	self assert: followSet anySatisfy: [:e | e literal = 'd' ].

   438 !

   439 

   440 testFollowSet7

   441 	|  r1 r2 follow1 follow2 |

   442 

   443 	node := 'a' asParser name: 'node'; yourself.

   444 	follow1 := ('b' asParser, 'c' asParser) / nil asParser.

   445 	follow2 := 'd' asParser / nil asParser .

   446 	

   447 	r1 := (node, follow1).

   448 	r2 := (r1, follow2).

   449 	

   450 	tree  := self treeFrom: r2.

   451 

   452 	followSet := self followOfNodeIn: tree.

   453 

   454 	self assert: followSet anySatisfy: [:e | e literal = 'b' ].

   455 	self assert: followSet anySatisfy: [:e | e literal = 'd' ].

   456 !

   457 

   458 testFollowSet8

   459 	node := 'a' asParser name: 'node'; yourself.

   460 	tree := self treeFrom: node.

   461 	

   462 	followSet := self followOfNodeIn: tree.

   463 

   464 	self assert: followSet anyMatchesType: PPCNilNode.

   465 !

   466 

   467 testFollowSet9

   468 	| a b c |

   469 	

   470 	a := 'a' asParser name: 'a'; yourself.

   471 	b := 'b' asParser optional name: 'b'; yourself.

   472 	c := 'c' asParser name: 'c'; yourself.

   473 	

   474 	

   475 	tree := self treeFrom: a, b, c.

   476 	followSet := self followOf: 'c' in: tree.

   477 	self assert: followSet anyMatchesType: PPCNilNode.

   478 	

   479 	followSet := self followOf: 'b' in: tree.

   480 	self assert: followSet anySatisfy: [:e | e literal = 'c' ].

   481 

   482 	followSet := self followOf: 'a' in: tree.

   483 	self assert: followSet anySatisfy: [:e | e literal = 'b' ].

   484 	self assert: followSet anySatisfy: [:e | e literal = 'c' ].

   485 !

   486 

   487 testFollowSetChoice1

   488 	| follow |

   489 

   490 	node := 'a' asParser name: 'node'; yourself.

   491 	follow := 'b' asParser / 'c' asParser .

   492 	

   493 	tree := self treeFrom: node, follow.

   494 

   495 	followSet := self followOfNodeIn: tree.

   496 

   497 	self assert: followSet size: 2.	

   498 	self assert: followSet anySatisfy: [:e | e literal = 'b' ].

   499 	self assert: followSet anySatisfy: [:e | e literal = 'c' ].

   500 !

   501 

   502 testFollowSetOptional1

   503 	|  follow1 follow2 |

   504 

   505 	node := 'a' asParser name: 'node'; yourself.

   506 	follow1 := 'b' asParser optional.

   507 	follow2 := 'c' asParser.

   508 	

   509 	tree := self treeFrom: node, follow1, follow2.

   510 

   511 	followSet := self followOfNodeIn: tree.

   512 

   513 	self assert: followSet size: 2.

   514 	self assert: followSet anySatisfy: [:e | e literal = 'b'].

   515 	self assert: followSet anySatisfy: [:e | e literal = 'c'].

   516 !

   517 

   518 testFollowSetRepeat1

   519 

   520 	node := 'a' asParser name: 'node'; yourself.

   521 	tree := self treeFrom: node plus.

   522 	

   523 	followSet := self followOfNodeIn: tree.

   524 	

   525 	self assert: followSet anySatisfy: [:e | e literal = 'a' ].

   526 	self assert: followSet anyMatchesType: PPCNilNode

   527 !

   528 

   529 testFollowSetRepeat2

   530 

   531 	node := 'a' asParser.

   532 	tree := self treeFrom: (node plus name: 'node'; yourself).

   533 	

   534 	followSet := self followOfNodeIn: tree.

   535 	

   536 	self assert: followSet size: 1.

   537 	self assert: followSet anyMatchesType: PPCNilNode

   538 !

   539 

   540 testFollowTrimmingToken

   541 	| token1 token2 |

   542 	

   543 	token1 := #letter asParser plus trimmingToken name: 'token1'; yourself.

   544 	token2 := #letter asParser plus trimmingToken name: 'token2'; yourself.

   545 	

   546 	

   547 	tree := self treeFrom: token1, token2.

   548 	followSet := self 	followOf: 'token1' 

   549 							in: tree 

   550 							suchThat: [:e | e isFirstSetTerminal or: [e isKindOf: PPCTrimmingTokenNode ]].

   551 

   552 	self assert: followSet size: 1.

   553 	self assert: followSet anyMatchesType: PPCTrimmingTokenNode. 

   554 !

   555 

   556 treeFrom: parser

   557 	^ parser asCompilerTree optimizeTree

   558 ! !

   559