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

     2 

     3 "{ NameSpace: Smalltalk }"

     4 

     5 TestCase subclass:#PEGFsaScannerIntegrationTest

     6 	instanceVariableNames:'fsa fsaGenerator parser scanner result compiled'

     7 	classVariableNames:''

     8 	poolDictionaries:''

     9 	category:'PetitCompiler-Tests-Scanner'

    10 !

    11 

    12 !PEGFsaScannerIntegrationTest methodsFor:'as yet unclassified'!

    13 

    14 compile

    15     | ppcTree |

    16     compiled ifTrue: [ ^ self ].

    17     ppcTree := parser asCompilerTree.

    18     fsa := ppcTree asFsa.

    19     fsa name: #nextToken.

    20     fsa finalStates do: [ :s | s isFailure ifFalse: [s retval: #token ]].

    21 

    22     scanner := ((PPCScannerCodeGenerator new)

    23         generate: fsa).

    24 

    25     compiled := true

    26 !

    27 

    28 failScan: stream

    29     self compile.

    30 

    31     scanner initialize.

    32     scanner stream: stream asPetitStream. 

    33     result := scanner nextToken.

    34         

    35     self assert: result isEmpty

    36 !

    37 

    38 scan: stream token: token

    39     self scan: stream token: token position: stream size.

    40 !

    41 

    42 scan: stream token: token position: position

    43     self compile.

    44 

    45     scanner initialize.

    46     scanner stream: stream asPetitStream. 

    47     result := scanner nextToken.

    48         

    49     self assert: result isCollection description: 'no collection returned as a result!!'.

    50     self assert: (result isEmpty not) description: 'no token found'.

    51     self assert: (result at: token) = position.

    52 !

    53 

    54 setUp

    55     compiled := false.

    56     fsaGenerator := PEGFsaGenerator new.

    57 !

    58 

    59 testA

    60     parser := 'a' asParser.

    61     

    62     self compile.

    63 

    64     self assert: fsa isDeterministic.

    65     self assert: fsa isWithoutEpsilons.	

    66     

    67     self failScan: ''.

    68     self failScan: 'b'.

    69 

    70     self scan: 'a' token: #token position: 1.

    71     self scan: 'aaa' token: #token position: 1.

    72 !

    73 

    74 testAAA_Aplusnot

    75     parser := 'aaa' asParser not, $a asParser plus.

    76     self compile.

    77 

    78     self assert: fsa isDeterministic.

    79     self assert: fsa isWithoutEpsilons.	

    80 

    81     self scan: 'a' token: #token.

    82     self scan: 'aa' token: #token.

    83 

    84     self failScan: ''.

    85     self failScan: 'aaa'.

    86     self failScan: 'aaaa'.

    87     self failScan: 'aaaaa'.

    88 !

    89 

    90 testAAplus_A

    91     parser := 'aa' asParser plus, $a asParser.

    92     

    93     self scan: 'aaa' token: #token.

    94     self scan: 'aaaaa' token: #token.

    95 

    96     self failScan: 'a'.

    97     self failScan: 'aa'.

    98     self failScan: 'aaaa'.

    99 !

   100 

   101 testAAplus_B

   102     parser := 'aa' asParser plus, $b asParser.

   103     

   104     self scan: 'aab' token: #token.

   105     self scan: 'aaaab' token: #token.

   106 

   107     self failScan: 'ab'.

   108     self failScan: 'aaab'.

   109     self failScan: 'aac'.

   110 !

   111 

   112 testAAstar_A

   113     parser := 'aa' asParser star, $a asParser.

   114     

   115     self scan: 'a' token: #token.

   116     self scan: 'aaa' token: #token.

   117     self scan: 'aaaaa' token: #token.

   118     self scan: 'aaaaaaa' token: #token.

   119 

   120 

   121     self failScan: 'aa'.

   122     self failScan: 'aaaa'.

   123 !

   124 

   125 testAAstar_B

   126     parser := 'aa' asParser star, $b asParser.

   127     

   128     self scan: 'b' token: #token.

   129     self scan: 'aab' token: #token.

   130     self scan: 'aaaab' token: #token.

   131     self scan: 'aaaaaab' token: #token.

   132 

   133 

   134     self failScan: 'ab'.

   135     self failScan: 'aaa'.

   136 !

   137 

   138 testAB

   139     parser := 'ab' asParser.

   140     

   141     self compile.

   142 

   143     self assert: fsa isDeterministic.

   144     self assert: fsa isWithoutEpsilons.	

   145     

   146     self failScan: ''.

   147     self failScan: 'b'.

   148 

   149     self scan: 'ab' token: #token position: 2.

   150     self scan: 'aba' token: #token position: 2.

   151 !

   152 

   153 testA_BCorCD_D

   154     parser := $a asParser, ('bc' asParser / 'cd' asParser), $d asParser.

   155     

   156     self scan: 'abcd' token: #token.

   157     self scan: 'acdd' token: #token.

   158 

   159     self failScan: 'abdd'.

   160     self failScan: 'ad'.

   161     self failScan: 'aacd'.

   162 !

   163 

   164 testA_BCorCDplus_D

   165     parser := $a asParser, ('bc' asParser / 'cd' asParser) plus, $d asParser.

   166     

   167     self scan: 'abcd' token: #token.

   168     self scan: 'acdd' token: #token.

   169     self scan: 'abcbccdd' token: #token.

   170     self scan: 'acdcdbcbcd' token: #token.

   171 

   172     self failScan: 'abdd'.

   173     self failScan: 'ad'.

   174     self failScan: 'abcccd'.

   175 !

   176 

   177 testA_BCorCDstar_D

   178     parser := $a asParser, ('bc' asParser / 'cd' asParser) star, $d asParser.

   179     

   180     self scan: 'ad' token: #token.

   181     self scan: 'abcd' token: #token.

   182     self scan: 'acdd' token: #token.

   183     self scan: 'abcbccdd' token: #token.

   184     self scan: 'acdcdbcbcd' token: #token.

   185 

   186     self failScan: 'abdd'.

   187     self failScan: 'abcccd'.

   188 !

   189 

   190 testA_Bnot

   191     parser := 'a' asParser, $b asParser not.

   192     

   193     self compile.

   194 

   195     self assert: fsa isDeterministic.

   196     self assert: fsa isWithoutEpsilons.	

   197     

   198     self failScan: 'ab'.

   199     self failScan: 'bb'.

   200 

   201     self scan: 'a' token: #token position: 1.

   202     self scan: 'ac' token: #token position: 1.

   203 !

   204 

   205 testA_Boptional

   206     parser := $a asParser, $b asParser optional.

   207     

   208     self compile.

   209 

   210     self assert: fsa isDeterministic.

   211     self assert: fsa isWithoutEpsilons.	

   212     

   213     self failScan: ''.

   214     self failScan: 'b'.

   215 

   216     self scan: 'ab' token: #token position: 2.

   217     self scan: 'ac' token: #token position: 1.

   218     self scan: 'a' token: #token position: 1.

   219 !

   220 

   221 testA_BorC_D

   222     parser := $a asParser, ($b asParser / $c asParser), $d asParser.

   223     

   224     self scan: 'abd' token: #token.

   225     self scan: 'acd' token: #token.

   226 

   227     self failScan: 'a'.

   228     self failScan: 'abc'.

   229     self failScan: 'add'.

   230 !

   231 

   232 testA_BorCplus_D

   233     parser := $a asParser, ($b asParser / $c asParser) plus, $d asParser.

   234     

   235     self scan: 'abd' token: #token.

   236     self scan: 'acd' token: #token.

   237     self scan: 'abcbcd' token: #token.

   238     self scan: 'acbcbcd' token: #token.

   239 

   240     self failScan: 'a'.

   241     self failScan: 'ad'.

   242     self failScan: 'abc'.

   243     self failScan: 'aad'.

   244 !

   245 

   246 testA_BorCstar_D

   247     parser := $a asParser, ($b asParser / $c asParser) star, $d asParser.

   248     

   249     self scan: 'ad' token: #token.

   250     self scan: 'abd' token: #token.

   251     self scan: 'acd' token: #token.

   252     self scan: 'abcbcd' token: #token.

   253     self scan: 'acbcbcd' token: #token.

   254 

   255     self failScan: 'a'.

   256     self failScan: 'abc'.

   257     self failScan: 'aad'.

   258 !

   259 

   260 testAorAA

   261     parser := 'a' asParser / 'aa' asParser.

   262     self compile.

   263 

   264     self assert: fsa isDeterministic.

   265     self assert: fsa isWithoutEpsilons.	

   266     

   267     self failScan: ''.

   268     self failScan: 'b'.

   269 

   270     self scan: 'aa' token: #token position: 1.

   271     self scan: 'a' token: #token position: 1.

   272 !

   273 

   274 testAorAX_X

   275     parser := ('a' asParser / 'ax' asParser), $x asParser.

   276     

   277     self compile.

   278 

   279     self assert: fsa isDeterministic.

   280     self assert: fsa isWithoutEpsilons.	

   281     

   282     self scan: 'ax' token: #token position: 2.

   283     self scan: 'axx' token: #token position: 2.	

   284 

   285     self failScan: 'a'.

   286     self failScan: 'x'.

   287     self failScan: ''.		

   288 !

   289 

   290 testAorB

   291     parser := $a asParser / $b asParser.

   292     

   293     self compile.

   294 

   295     self assert: fsa isDeterministic.

   296     self assert: fsa isWithoutEpsilons.	

   297     

   298     self failScan: ''.

   299     self failScan: 'c'.

   300 

   301     self scan: 'aa' token: #token position: 1.

   302     self scan: 'bb' token: #token position: 1.

   303 !

   304 

   305 testAplus_B

   306     parser := $a asParser plus, $b asParser.

   307     

   308     self scan: 'ab' token: #token.

   309     self scan: 'aab' token: #token.

   310     self scan: 'aaab' token: #token.

   311 

   312     self failScan: 'b'.

   313     self failScan: 'ac'.

   314 !

   315 

   316 testAstar_A

   317     parser := $a asParser star, $a asParser.

   318     

   319     self failScan: 'a'.

   320     self failScan: 'aa'.

   321     self failScan: 'ac'.

   322 !

   323 

   324 testAstar_B

   325     parser := $a asParser star, $b asParser.

   326     

   327     self scan: 'b' token: #token.

   328     self scan: 'ab' token: #token.

   329     self scan: 'aab' token: #token.

   330 

   331     self failScan: ''.

   332     self failScan: 'ac'.

   333 !

   334 

   335 testAstar_Bnot

   336     parser := 'a' asParser star, $b asParser not.

   337     

   338     self compile.

   339 

   340     self assert: fsa isDeterministic.

   341     self assert: fsa isWithoutEpsilons.	

   342     

   343     self failScan: 'aaab'.

   344     self failScan: 'b'.

   345 

   346     self scan: '' token: #token position: 0.

   347     self scan: 'a' token: #token position: 1.

   348     self scan: 'aac' token: #token position: 2.

   349     self scan: 'aaaac' token: #token position: 4.

   350 !

   351 

   352 testFoo

   353     parser := 'foo' asParser.

   354     

   355     self scan: 'foo' token: #token.

   356     self scan: 'foobar' token: #token position: 3.

   357 

   358     self failScan: 'bar'.

   359     self failScan: 'fo'.

   360 !

   361 

   362 testNumber

   363     parser := #digit asParser plus.

   364     

   365     self compile.

   366 

   367     self assert: fsa isDeterministic.

   368     self assert: fsa isWithoutEpsilons.	

   369     

   370     self failScan: ''.

   371     self failScan: 'b'.

   372 

   373     self scan: '12' token: #token position: 2.

   374     self scan: '2312' token: #token position: 4.

   375 !

   376 

   377 testSmalltalkIdentifier

   378     parser := #letter asParser, #word asParser star, $: asParser not.

   379     self compile.

   380 

   381     self assert: fsa isDeterministic.

   382     self assert: fsa isWithoutEpsilons.	

   383 

   384     self scan: 'a' token: #token.

   385     self scan: 'hithere' token: #token.

   386     self scan: 'hi123' token: #token.

   387 

   388     self failScan: ''.

   389     self failScan: 'aaa:'.

   390     self failScan: '123'.	

   391 ! !

   392