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

     2 

     3 "{ NameSpace: Smalltalk }"

     4 

     5 PPJavaLexiconTest subclass:#PPCompiledJavaSyntaxTest

     6 	instanceVariableNames:''

     7 	classVariableNames:''

     8 	poolDictionaries:''

     9 	category:'PetitCompiler-Tests-Java'

    10 !

    11 

    12 !PPCompiledJavaSyntaxTest class methodsFor:'as yet unclassified'!

    13 

    14 resources

    15 	^ (OrderedCollection with: PPCompiledJavaResource)

    16 		addAll: super resources;

    17 		yourself

    18 ! !

    19 

    20 !PPCompiledJavaSyntaxTest methodsFor:'accessing'!

    21 

    22 context

    23 	^ PPCContext new

    24 !

    25 

    26 parserClass

    27 	^ Smalltalk at: #PPCompiledJavaSyntax

    28 !

    29 

    30 parserInstanceFor: aSymbol

    31 	^ (Smalltalk at: #PPCompiledJavaSyntax) new startSymbol: aSymbol

    32 ! !

    33 

    34 !PPCompiledJavaSyntaxTest methodsFor:'testing'!

    35 

    36 testAdditiveExpression1

    37 

    38 	self parse: 'true'

    39 		rule: #additiveExpression

    40 !

    41 

    42 testAdditiveExpression2

    43 

    44 	self parse: '3 + 5'

    45 		rule: #additiveExpression

    46 !

    47 

    48 testAdditiveExpression3

    49 

    50 	self parse: '4 + 8 - 2 + 9'

    51 		rule: #additiveExpression

    52 !

    53 

    54 testAndExpression1

    55 

    56 	self parse: 'true'

    57 		rule: #andExpression

    58 !

    59 

    60 testBlock1

    61 

    62 	self parse: '{	}'

    63 		rule: #block

    64 !

    65 

    66 testBlock2

    67 

    68 	self

    69 		parse:

    70 		'{

    71 			System.out.println("Hello World!!");

    72  	       	System.out.println("Hello World!!");

    73 		}'

    74 		rule: #block

    75 !

    76 

    77 testCompilationUnit1

    78 

    79 	self parse: 'package foo;

    80 				public class CU1 {}'

    81 	rule: #compilationUnit

    82 !

    83 

    84 testCompilationUnit2

    85 

    86 	self parse: 'package foo;

    87 				import foo.Bar;

    88 				public class CU2 {

    89 				}'

    90 	rule: #compilationUnit

    91 !

    92 

    93 testCompilationUnit3

    94 

    95 	self parse: 'class myfirstjavaprog

    96 {  

    97 	public static void main(String args[])

    98 	{

    99 	   System.out.println("Hello World!!");

   100 	}

   101 }'

   102 	rule: #compilationUnit

   103 !

   104 

   105 testCompilationUnit4

   106 

   107 	self parse: '

   108 					public class OddEven {

   109  						private int input;

   110  					  public static void main(String[] args) {

   111      					OddEven number = new OddEven();

   112 					        number.showDialog(); }

   113 					public void showDialog() {

   114        

   115 	try {

   116           

   117 	    input = Integer.parseInt(JOptionPane.showInputDialog("Please Enter A Number"));

   118 	    calculate();

   119 	} catch (NumberFormatException e) {

   120             

   121 	    System.err.println("ERROR: Invalid input. Please type in a numerical value.");

   122 	}

   123     }

   124 

   125 private void calculate() {

   126 	if (input % 2 == 0) {

   127 	    System.out.println("Even");

   128 	} else {

   129 	    System.out.println("Odd");

   130 	}

   131     }

   132 					}'

   133 	rule: #compilationUnit

   134 !

   135 

   136 testCompilationUnit5

   137 

   138 	self parse: 'class myfirstjavaprog

   139 {  

   140 

   141 		public myfirstjavaprog() {

   142 			

   143 		}

   144 	

   145 	public static void main(String args[])

   146 	{

   147 	   System.out.println("Hello World!!");

   148 	}

   149 }'

   150 	rule: #compilationUnit

   151 !

   152 

   153 testConditionalAndExpression1

   154 

   155 	self parse: 'true'

   156 		rule: #conditionalAndExpression

   157 !

   158 

   159 testConditionalOrExpression1

   160 

   161 	self parse: 'true'

   162 		rule: #conditionalOrExpression

   163 !

   164 

   165 testEqualityExpression1

   166 

   167 	self 

   168 		parse: 'true'

   169 		rule: #equalityExpression

   170 !

   171 

   172 testExclusiveOrExpression1

   173 

   174 	self parse: 'true'

   175 		rule: #exclusiveOrExpression

   176 !

   177 

   178 testExpression1

   179 

   180 	self parse: '1 + 2'

   181 		rule: #expression

   182 !

   183 

   184 testExpression2

   185 

   186 	self parse: 'true'

   187 		rule: #expression

   188 !

   189 

   190 testExpression3

   191 

   192 	self parse: 'a.method()'

   193 		rule: #expression

   194 !

   195 

   196 testExpression4

   197 

   198 	self parse: 'a'

   199 		rule: #expression

   200 !

   201 

   202 testExpression5

   203 

   204 	self parse: 'a += 5'

   205 		rule: #expression

   206 !

   207 

   208 testFormalParameters1

   209 

   210 	self 

   211 		parse: '

   212     (String s, Object parameterType)'

   213 	rule: #formalParameters

   214 !

   215 

   216 testFormalParameters2

   217 

   218 	self 

   219 		parse: '

   220     (Object ... parameterType)'

   221 	rule: #formalParameters

   222 !

   223 

   224 testFormalParameters3

   225 

   226 	self 

   227 		parse: '(String name, Class<?>... parameterTypes)'

   228 	rule: #formalParameters

   229 !

   230 

   231 testFormalParameters4

   232 

   233 	self 

   234 		parse: '(int one, int two, int three, int four)'

   235 		rule: #formalParameters

   236 !

   237 

   238 testFormalParameters5

   239 

   240 	self 

   241 		parse: '()'

   242 		rule: #formalParameters

   243 !

   244 

   245 testIdentifier

   246 

   247 	self parse: 'method'

   248 		rule: #identifier

   249 !

   250 

   251 testIfStatement1

   252 

   253 	self parse: 'if (true) {}'

   254 		rule: #ifStatement

   255 !

   256 

   257 testIfStatement2

   258 

   259 	self parse: 'if (true) {} else {}'

   260 		rule: #ifStatement

   261 !

   262 

   263 testIfStatement3

   264 

   265 	self parse: '

   266 	if (true) 

   267 		{int a = 0; a = 1;}

   268 	else

   269 		{return false;}'

   270 		rule: #ifStatement

   271 !

   272 

   273 testIfStatement4

   274 

   275 	self parse: 'if (true) a = 0;'

   276 		rule: #ifStatement

   277 !

   278 

   279 testIfStatement5

   280 

   281 	self parse: 'if (a < 4) {}'

   282 		rule: #ifStatement

   283 !

   284 

   285 testImportDeclaration1

   286 

   287 	self parse: 'import foo.Top;'

   288 		rule: #importDeclaration

   289 !

   290 

   291 testImportDeclaration2

   292 

   293 	self parse: 'import foo.Top2.*;'

   294 		rule: #importDeclaration

   295 !

   296 

   297 testInclusiveOrExpression1

   298 

   299 	self parse: 'true'

   300 		rule: #inclusiveOrExpression

   301 !

   302 

   303 testInstanceofExpression1

   304 

   305 	self 

   306 		parse: 'true'

   307 		rule: #instanceofExpression

   308 !

   309 

   310 testJavaToken

   311 

   312 	self parse: 'false' rule: #literal.

   313 	self assert: (result isKindOf: PPJavaToken).

   314 	self assert: (result inputValue = 'false').

   315 !

   316 

   317 testLocalVariableDeclaration1

   318 

   319 	self parse: 'Type name'

   320 		rule: #localVariableDeclaration

   321 !

   322 

   323 testLocalVariableDeclaration2

   324 

   325 	self parse: 'Type name = value, name2'

   326 		rule: #localVariableDeclaration

   327 !

   328 

   329 testLocalVariableDeclarationStatement1

   330 

   331 	self parse: 'int i = 5;'

   332 		rule: #localVariableDeclarationStatement

   333 !

   334 

   335 testLocalVariableDeclarationStatement2

   336 

   337 	self parse: 'int i, j = 6;'

   338 		rule: #localVariableDeclarationStatement

   339 !

   340 

   341 testLocalVariableDeclarationStatement3

   342 

   343 	self parse: 'Srting str, in, g;'

   344 		rule: #localVariableDeclarationStatement

   345 !

   346 

   347 testMethodDeclaration3

   348 

   349 	self 

   350 		parse: '

   351     public void getMethod(String s, Object ... parameterType)

   352     {

   353     }'

   354 	rule: #methodDeclaration

   355 !

   356 

   357 testMethodDeclaration4

   358 

   359 	self 

   360 		parse: '

   361     public void getMethod(String s, int o)

   362     {

   363     }'

   364 	rule: #methodDeclaration

   365 !

   366 

   367 testMultiplicativeExpression1

   368 

   369 	self parse: 'true'

   370 		rule: #multiplicativeExpression

   371 !

   372 

   373 testMultiplicativeExpression2

   374 

   375 	self parse: '3 * 5'

   376 		rule: #multiplicativeExpression

   377 !

   378 

   379 testMultiplicativeExpression3

   380 

   381 	self parse: '4 * 8 / 2 * 9'

   382 		rule: #multiplicativeExpression

   383 !

   384 

   385 testNormalParameterDecl1

   386 

   387 	self parse: 'final int integers[]'

   388 		rule: #normalParameterDecl

   389 !

   390 

   391 testNormalParameterDecl2

   392 

   393 	self parse: 'String str'

   394 		rule: #normalParameterDecl

   395 !

   396 

   397 testPackageDeclaration

   398 	self 

   399 		parse: 'package java.util;'

   400 		rule: #packageDeclaration

   401 !

   402 

   403 testPackageDeclaration1

   404 

   405 	self parse: 'package foo;'

   406 		rule: #packageDeclaration

   407 !

   408 

   409 testPackageDeclaration2

   410 

   411 	self parse: 'package foo.Bar;'

   412 		rule: #packageDeclaration

   413 !

   414 

   415 testPackageDeclaration3

   416 

   417 	self fail: 'package ;'

   418 		rule: #packageDeclaration

   419 !

   420 

   421 testPrimary1

   422 

   423 	self 

   424 		parse: 'true'

   425 		rule: #primary

   426 !

   427 

   428 testPrimary2

   429 

   430 	self 

   431 		parse: '"Java string"'

   432 		rule: #primary

   433 !

   434 

   435 testPrimaryWithselectors1

   436 

   437 	self 

   438 		parse: 'true'

   439 		rule: #primaryWithselectors

   440 !

   441 

   442 testQualifiedName1

   443 

   444 	self parse: 'a.a'

   445 		rule: #qualifiedName

   446 !

   447 

   448 testRelationalExpression1

   449 

   450 	self parse: 'true'

   451 		rule: #relationalExpression

   452 !

   453 

   454 testRelationalExpression2

   455 

   456 	self parse: '3 > 5'

   457 		rule: #relationalExpression

   458 !

   459 

   460 testReturnStatement1

   461 

   462 	self parse: 'return true;'

   463 		rule: #returnStatement

   464 !

   465 

   466 testReturnStatement2

   467 

   468 	self parse: 'return;'

   469 		rule: #returnStatement

   470 !

   471 

   472 testShiftExpression1

   473 

   474 	self parse: 'true'

   475 		rule: #shiftExpression

   476 !

   477 

   478 testStatement1

   479 

   480 	self parse: 'System.out.println("Hello World!!");'

   481 		rule: #statement

   482 !

   483 

   484 testStatement2

   485 

   486 	self parse: 'return true;'

   487 		rule: #statement

   488 !

   489 

   490 testStatement3

   491 

   492 	self parse: '{}'

   493 		rule: #statement

   494 !

   495 

   496 testUnaryExpression1

   497 

   498 	self parse: 'a'

   499 		rule: #unaryExpression

   500 !

   501 

   502 testUnaryExpression2

   503 

   504 	self parse: 'true'

   505 		rule: #unaryExpression

   506 !

   507 

   508 testUnaryExpressionNotPlusMinus1

   509 

   510 	self 

   511 		parse: 'true'

   512 		rule: #unaryExpressionNotPlusMinus

   513 !

   514 

   515 testVariableDeclarator1

   516 

   517 	self parse: 'var'

   518 		rule: #variableDeclarator

   519 !

   520 

   521 testVariableDeclarator2

   522 

   523 	self parse: 'var[][]'

   524 		rule: #variableDeclarator

   525 !

   526 

   527 testVariableDeclarator3

   528 

   529 	self parse: 'var = a.methd()'

   530 		rule: #variableDeclarator

   531 !

   532 

   533 testWhileStatement1

   534 

   535 	self parse: 'while (true) object.executeMethod();'

   536 		rule: #whileStatement

   537 !

   538 

   539 testWhileStatement2

   540 

   541 	self parse: 'while (3>2) {block; of; statements;}'

   542 		rule: #whileStatement

   543 ! !

   544 

   545 !PPCompiledJavaSyntaxTest methodsFor:'testing-classes'!

   546 

   547 testClassDeclaration1

   548 

   549 	self parse: '//comment

   550 	class myfirstjavaprog

   551 {  

   552 	public static void main(String args[])

   553 	{

   554 	   System.out.println("Hello World!!");

   555 	}

   556 }'

   557 	rule: #classDeclaration

   558 !

   559 

   560 testMethodDeclaration1

   561 

   562 	self 

   563 		parse: 'public void aMethod() {	}'

   564 			rule: #methodDeclaration

   565 !

   566 

   567 testMethodDeclaration2

   568 

   569 	self 

   570 		parse: 'public aMethod() {	}'

   571 			rule: #methodDeclaration

   572 ! !

   573