001/* 002 * Copyright (C) Christian Schulte, 2012-262 003 * All rights reserved. 004 * 005 * Redistribution and use in source and binary forms, with or without 006 * modification, are permitted provided that the following conditions 007 * are met: 008 * 009 * o Redistributions of source code must retain the above copyright 010 * notice, this list of conditions and the following disclaimer. 011 * 012 * o Redistributions in binary form must reproduce the above copyright 013 * notice, this list of conditions and the following disclaimer in 014 * the documentation and/or other materials provided with the 015 * distribution. 016 * 017 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 018 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 019 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 020 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT, 021 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 022 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 023 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 024 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 025 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 026 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 027 * 028 * $JOMC: JavaIdentifierTest.java 4704 2013-01-02 05:15:52Z schulte $ 029 * 030 */ 031package org.jomc.model.test; 032 033import java.io.ObjectInputStream; 034import java.text.ParseException; 035import org.jomc.model.JavaIdentifier; 036import org.junit.Test; 037import static org.jomc.model.JavaIdentifier.NormalizationMode.CAMEL_CASE; 038import static org.jomc.model.JavaIdentifier.NormalizationMode.CONSTANT_NAME_CONVENTION; 039import static org.jomc.model.JavaIdentifier.NormalizationMode.LOWER_CASE; 040import static org.jomc.model.JavaIdentifier.NormalizationMode.METHOD_NAME_CONVENTION; 041import static org.jomc.model.JavaIdentifier.NormalizationMode.UPPER_CASE; 042import static org.jomc.model.JavaIdentifier.NormalizationMode.VARIABLE_NAME_CONVENTION; 043import static org.junit.Assert.assertEquals; 044import static org.junit.Assert.assertNotNull; 045import static org.junit.Assert.fail; 046 047/** 048 * Test cases for class {@code org.jomc.model.JavaIdentifier}. 049 * 050 * @author <a href="mailto:cs@schulte.it">Christian Schulte</a> 051 * @version $JOMC: JavaIdentifierTest.java 4704 2013-01-02 05:15:52Z schulte $ 052 * @since 1.4 053 */ 054public class JavaIdentifierTest 055{ 056 057 /** Constant to prefix relative resource names with. */ 058 private static final String ABSOLUTE_RESOURCE_NAME_PREFIX = "/org/jomc/model/test/"; 059 060 /** Creates a new {@code JavaIdentifierTest} instance. */ 061 public JavaIdentifierTest() 062 { 063 super(); 064 } 065 066 @Test 067 public final void NormalizeThrowsNullPointerExceptionOnNullArgument() throws Exception 068 { 069 try 070 { 071 JavaIdentifier.normalize( null, CAMEL_CASE ); 072 fail( "Expected 'NullPointerException' not thrown." ); 073 } 074 catch ( final NullPointerException e ) 075 { 076 assertNotNull( e.getMessage() ); 077 System.out.println( e.toString() ); 078 } 079 try 080 { 081 JavaIdentifier.normalize( "", null ); 082 fail( "Expected 'NullPointerException' not thrown." ); 083 } 084 catch ( final NullPointerException e ) 085 { 086 assertNotNull( e.getMessage() ); 087 System.out.println( e.toString() ); 088 } 089 } 090 091 @Test 092 public final void ParseAndValueOfCorrectlyDetectInvalidIdentifiers() throws Exception 093 { 094 assertInvalidJavaIdentifier( "" ); 095 assertInvalidJavaIdentifier( "@" ); 096 assertInvalidJavaIdentifier( " " ); 097 098 for ( final String keyword : JavaLanguage.KEYWORDS ) 099 { 100 assertInvalidJavaIdentifier( keyword ); 101 } 102 for ( final String literal : JavaLanguage.BOOLEAN_LITERALS ) 103 { 104 assertInvalidJavaIdentifier( literal ); 105 } 106 107 assertInvalidJavaIdentifier( JavaLanguage.NULL_LITERAL ); 108 } 109 110 @Test 111 public final void ParseThrowsNullPointerExceptionOnNullArgument() throws Exception 112 { 113 try 114 { 115 JavaIdentifier.parse( null ); 116 fail( "Expected 'NullPointerException' not thrown." ); 117 } 118 catch ( final NullPointerException e ) 119 { 120 assertNotNull( e.getMessage() ); 121 System.out.println( e.toString() ); 122 } 123 } 124 125 @Test 126 public final void ValueOfThrowsNullPointerExceptionOnNullArgument() throws Exception 127 { 128 try 129 { 130 JavaIdentifier.valueOf( null ); 131 fail( "Expected 'NullPointerException' not thrown." ); 132 } 133 catch ( final NullPointerException e ) 134 { 135 assertNotNull( e.getMessage() ); 136 System.out.println( e.toString() ); 137 } 138 } 139 140 @Test 141 public final void CamelCaseNormalization() throws Exception 142 { 143 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ), 144 JavaIdentifier.normalize( "test test test ", CAMEL_CASE ) ); 145 146 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ), 147 JavaIdentifier.normalize( "test_test_test", CAMEL_CASE ) ); 148 149 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ), 150 JavaIdentifier.normalize( " test_test_test ", CAMEL_CASE ) ); 151 152 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ), 153 JavaIdentifier.normalize( " test test test ", CAMEL_CASE ) ); 154 155 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ), 156 JavaIdentifier.normalize( " test test test ", CAMEL_CASE ) ); 157 158 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ), 159 JavaIdentifier.normalize( " Test test test ", CAMEL_CASE ) ); 160 161 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ), 162 JavaIdentifier.normalize( " Test test test ", CAMEL_CASE ) ); 163 164 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ), 165 JavaIdentifier.normalize( "Test test test ", CAMEL_CASE ) ); 166 167 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ), 168 JavaIdentifier.normalize( "tEST tEST tEST ", CAMEL_CASE ) ); 169 170 assertEquals( JavaIdentifier.valueOf( "Test" ), 171 JavaIdentifier.normalize( "TEST", CAMEL_CASE ) ); 172 173 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ), 174 JavaIdentifier.normalize( "TestTestTest", CAMEL_CASE ) ); 175 176 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ), 177 JavaIdentifier.normalize( "testTestTest", CAMEL_CASE ) ); 178 179 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ), 180 JavaIdentifier.normalize( "test TeSt Test", CAMEL_CASE ) ); 181 182 assertEquals( JavaIdentifier.valueOf( "TesTtEsTtEst" ), 183 JavaIdentifier.normalize( "tEsTtEsTtEsT", CAMEL_CASE ) ); 184 185 assertEquals( JavaIdentifier.valueOf( "TesttesttestTesttesttest" ), 186 JavaIdentifier.normalize( "tEsTtEsTtEsT tEsTtEsTtEsT", CAMEL_CASE ) ); 187 188 for ( final String keyword : JavaLanguage.KEYWORDS ) 189 { 190 assertEquals( JavaIdentifier.valueOf( toUpperCase( keyword, 0, 1 ) ), 191 JavaIdentifier.normalize( " " + keyword + " ", CAMEL_CASE ) ); 192 193 } 194 195 for ( final String literal : JavaLanguage.BOOLEAN_LITERALS ) 196 { 197 assertEquals( JavaIdentifier.valueOf( toUpperCase( literal, 0, 1 ) ), 198 JavaIdentifier.normalize( " " + literal + " ", CAMEL_CASE ) ); 199 200 } 201 202 assertEquals( JavaIdentifier.valueOf( toUpperCase( JavaLanguage.NULL_LITERAL, 0, 1 ) ), 203 JavaIdentifier.normalize( " " + JavaLanguage.NULL_LITERAL + " ", CAMEL_CASE ) ); 204 205 assertInvalidJavaIdentifier( "", CAMEL_CASE ); 206 assertInvalidJavaIdentifier( "@", CAMEL_CASE ); 207 assertInvalidJavaIdentifier( " ", CAMEL_CASE ); 208 } 209 210 @Test 211 public final void UpperCaseNormalization() throws Exception 212 { 213 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 214 JavaIdentifier.normalize( "test test test ", UPPER_CASE ) ); 215 216 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 217 JavaIdentifier.normalize( " test test test ", UPPER_CASE ) ); 218 219 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 220 JavaIdentifier.normalize( " test test test ", UPPER_CASE ) ); 221 222 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 223 JavaIdentifier.normalize( " Test test test ", UPPER_CASE ) ); 224 225 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 226 JavaIdentifier.normalize( " Test test test ", UPPER_CASE ) ); 227 228 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 229 JavaIdentifier.normalize( "test_test_test ", UPPER_CASE ) ); 230 231 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 232 JavaIdentifier.normalize( " test_test_test ", UPPER_CASE ) ); 233 234 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 235 JavaIdentifier.normalize( "_test _test _test_", UPPER_CASE ) ); 236 237 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 238 JavaIdentifier.normalize( " _test _test _test_ ", UPPER_CASE ) ); 239 240 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 241 JavaIdentifier.normalize( "TEST_TEST_TEST", UPPER_CASE ) ); 242 243 for ( final String keyword : JavaLanguage.KEYWORDS ) 244 { 245 assertEquals( JavaIdentifier.valueOf( toUpperCase( keyword ) ), 246 JavaIdentifier.normalize( " " + keyword + " ", UPPER_CASE ) ); 247 248 } 249 250 for ( final String literal : JavaLanguage.BOOLEAN_LITERALS ) 251 { 252 assertEquals( JavaIdentifier.valueOf( toUpperCase( literal ) ), 253 JavaIdentifier.normalize( " " + literal + " ", UPPER_CASE ) ); 254 255 } 256 257 assertEquals( JavaIdentifier.valueOf( toUpperCase( JavaLanguage.NULL_LITERAL ) ), 258 JavaIdentifier.normalize( " " + JavaLanguage.NULL_LITERAL + " ", UPPER_CASE ) ); 259 260 assertInvalidJavaIdentifier( "", UPPER_CASE ); 261 assertInvalidJavaIdentifier( "@", UPPER_CASE ); 262 assertInvalidJavaIdentifier( " ", UPPER_CASE ); 263 } 264 265 @Test 266 public final void LowerCaseNormalization() throws Exception 267 { 268 assertEquals( JavaIdentifier.valueOf( "test_test_test" ), 269 JavaIdentifier.normalize( "test test test ", LOWER_CASE ) ); 270 271 assertEquals( JavaIdentifier.valueOf( "test_test_test" ), 272 JavaIdentifier.normalize( " test test test ", LOWER_CASE ) ); 273 274 assertEquals( JavaIdentifier.valueOf( "test_test_test" ), 275 JavaIdentifier.normalize( " test test test ", LOWER_CASE ) ); 276 277 assertEquals( JavaIdentifier.valueOf( "test_test_test" ), 278 JavaIdentifier.normalize( " Test test test ", LOWER_CASE ) ); 279 280 assertEquals( JavaIdentifier.valueOf( "test_test_test" ), 281 JavaIdentifier.normalize( " Test test test ", LOWER_CASE ) ); 282 283 assertEquals( JavaIdentifier.valueOf( "test_test_test" ), 284 JavaIdentifier.normalize( "TEST_TEST_TEST ", LOWER_CASE ) ); 285 286 assertEquals( JavaIdentifier.valueOf( "test_test_test" ), 287 JavaIdentifier.normalize( " TEST_TEST_TEST ", LOWER_CASE ) ); 288 289 assertEquals( JavaIdentifier.valueOf( "test_test_test" ), 290 JavaIdentifier.normalize( "_TEST _TEST _TEST_", LOWER_CASE ) ); 291 292 assertEquals( JavaIdentifier.valueOf( "test_test_test" ), 293 JavaIdentifier.normalize( " _TEST _TEST _TEST_ ", LOWER_CASE ) ); 294 295 assertEquals( JavaIdentifier.valueOf( "test_test_test" ), 296 JavaIdentifier.normalize( "test_test_test", LOWER_CASE ) ); 297 298 for ( final String keyword : JavaLanguage.KEYWORDS ) 299 { 300 assertEquals( JavaIdentifier.valueOf( "_" + toLowerCase( keyword ) ), 301 JavaIdentifier.normalize( " " + keyword + " ", LOWER_CASE ) ); 302 } 303 304 for ( final String literal : JavaLanguage.BOOLEAN_LITERALS ) 305 { 306 assertEquals( JavaIdentifier.valueOf( "_" + toLowerCase( literal ) ), 307 JavaIdentifier.normalize( " " + literal + " ", LOWER_CASE ) ); 308 309 } 310 311 assertEquals( JavaIdentifier.valueOf( "_" + toLowerCase( JavaLanguage.NULL_LITERAL ) ), 312 JavaIdentifier.normalize( " " + JavaLanguage.NULL_LITERAL + " ", LOWER_CASE ) ); 313 314 assertInvalidJavaIdentifier( "", LOWER_CASE ); 315 assertInvalidJavaIdentifier( "@", LOWER_CASE ); 316 assertInvalidJavaIdentifier( " ", LOWER_CASE ); 317 } 318 319 @Test 320 public final void ConstantNameNormalization() throws Exception 321 { 322 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 323 JavaIdentifier.normalize( "test test test ", CONSTANT_NAME_CONVENTION ) ); 324 325 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 326 JavaIdentifier.normalize( " test test test ", CONSTANT_NAME_CONVENTION ) ); 327 328 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 329 JavaIdentifier.normalize( " test test test ", CONSTANT_NAME_CONVENTION ) ); 330 331 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 332 JavaIdentifier.normalize( " Test test test ", CONSTANT_NAME_CONVENTION ) ); 333 334 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 335 JavaIdentifier.normalize( " Test test test ", CONSTANT_NAME_CONVENTION ) ); 336 337 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 338 JavaIdentifier.normalize( "test_test_test ", CONSTANT_NAME_CONVENTION ) ); 339 340 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 341 JavaIdentifier.normalize( " test_test_test ", CONSTANT_NAME_CONVENTION ) ); 342 343 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 344 JavaIdentifier.normalize( "_test _test _test_", CONSTANT_NAME_CONVENTION ) ); 345 346 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 347 JavaIdentifier.normalize( " _test _test _test_ ", CONSTANT_NAME_CONVENTION ) ); 348 349 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ), 350 JavaIdentifier.normalize( "TEST_TEST_TEST", CONSTANT_NAME_CONVENTION ) ); 351 352 for ( final String keyword : JavaLanguage.KEYWORDS ) 353 { 354 assertEquals( JavaIdentifier.valueOf( toUpperCase( keyword ) ), 355 JavaIdentifier.normalize( " " + keyword + " ", CONSTANT_NAME_CONVENTION ) ); 356 357 } 358 359 for ( final String literal : JavaLanguage.BOOLEAN_LITERALS ) 360 { 361 assertEquals( JavaIdentifier.valueOf( toUpperCase( literal ) ), 362 JavaIdentifier.normalize( " " + literal + " ", CONSTANT_NAME_CONVENTION ) ); 363 364 } 365 366 assertEquals( JavaIdentifier.valueOf( toUpperCase( JavaLanguage.NULL_LITERAL ) ), 367 JavaIdentifier.normalize( " " + JavaLanguage.NULL_LITERAL + " ", CONSTANT_NAME_CONVENTION ) ); 368 369 assertInvalidJavaIdentifier( "", CONSTANT_NAME_CONVENTION ); 370 assertInvalidJavaIdentifier( "@", CONSTANT_NAME_CONVENTION ); 371 assertInvalidJavaIdentifier( " ", CONSTANT_NAME_CONVENTION ); 372 } 373 374 @Test 375 public final void MethodNameNormalization() throws Exception 376 { 377 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 378 JavaIdentifier.normalize( "test test test ", METHOD_NAME_CONVENTION ) ); 379 380 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 381 JavaIdentifier.normalize( "test_test_test", METHOD_NAME_CONVENTION ) ); 382 383 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 384 JavaIdentifier.normalize( " test_test_test ", METHOD_NAME_CONVENTION ) ); 385 386 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 387 JavaIdentifier.normalize( " test test test ", METHOD_NAME_CONVENTION ) ); 388 389 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 390 JavaIdentifier.normalize( " test test test ", METHOD_NAME_CONVENTION ) ); 391 392 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 393 JavaIdentifier.normalize( " Test test test ", METHOD_NAME_CONVENTION ) ); 394 395 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 396 JavaIdentifier.normalize( " Test test test ", METHOD_NAME_CONVENTION ) ); 397 398 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 399 JavaIdentifier.normalize( "Test test test ", METHOD_NAME_CONVENTION ) ); 400 401 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 402 JavaIdentifier.normalize( "tEST tEST tEST ", METHOD_NAME_CONVENTION ) ); 403 404 assertEquals( JavaIdentifier.valueOf( "test" ), 405 JavaIdentifier.normalize( "TEST", METHOD_NAME_CONVENTION ) ); 406 407 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 408 JavaIdentifier.normalize( "TestTestTest", METHOD_NAME_CONVENTION ) ); 409 410 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 411 JavaIdentifier.normalize( "testTestTest", METHOD_NAME_CONVENTION ) ); 412 413 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 414 JavaIdentifier.normalize( "Test TeSt Test", METHOD_NAME_CONVENTION ) ); 415 416 assertEquals( JavaIdentifier.valueOf( "teStTeStTeStx" ), 417 JavaIdentifier.normalize( "TeStTeStTeStX", METHOD_NAME_CONVENTION ) ); 418 419 assertEquals( JavaIdentifier.valueOf( "testtesttestTesttesttest" ), 420 JavaIdentifier.normalize( "TeStTeStTeSt TeStTeStTeSt", METHOD_NAME_CONVENTION ) ); 421 422 for ( final String keyword : JavaLanguage.KEYWORDS ) 423 { 424 assertEquals( JavaIdentifier.valueOf( "_" + keyword ), 425 JavaIdentifier.normalize( " " + keyword + " ", METHOD_NAME_CONVENTION ) ); 426 427 } 428 429 for ( final String literal : JavaLanguage.BOOLEAN_LITERALS ) 430 { 431 assertEquals( JavaIdentifier.valueOf( "_" + literal ), 432 JavaIdentifier.normalize( " " + literal + " ", METHOD_NAME_CONVENTION ) ); 433 434 } 435 436 assertEquals( JavaIdentifier.valueOf( "_" + JavaLanguage.NULL_LITERAL ), 437 JavaIdentifier.normalize( " " + JavaLanguage.NULL_LITERAL + " ", METHOD_NAME_CONVENTION ) ); 438 439 assertInvalidJavaIdentifier( "", METHOD_NAME_CONVENTION ); 440 assertInvalidJavaIdentifier( "@", METHOD_NAME_CONVENTION ); 441 assertInvalidJavaIdentifier( " ", METHOD_NAME_CONVENTION ); 442 } 443 444 @Test 445 public final void VariableNameNormalization() throws Exception 446 { 447 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 448 JavaIdentifier.normalize( "test test test ", VARIABLE_NAME_CONVENTION ) ); 449 450 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 451 JavaIdentifier.normalize( "test_test_test", VARIABLE_NAME_CONVENTION ) ); 452 453 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 454 JavaIdentifier.normalize( " test_test_test ", VARIABLE_NAME_CONVENTION ) ); 455 456 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 457 JavaIdentifier.normalize( " test test test ", VARIABLE_NAME_CONVENTION ) ); 458 459 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 460 JavaIdentifier.normalize( " test test test ", VARIABLE_NAME_CONVENTION ) ); 461 462 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 463 JavaIdentifier.normalize( " Test test test ", VARIABLE_NAME_CONVENTION ) ); 464 465 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 466 JavaIdentifier.normalize( " Test test test ", VARIABLE_NAME_CONVENTION ) ); 467 468 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 469 JavaIdentifier.normalize( "Test test test ", VARIABLE_NAME_CONVENTION ) ); 470 471 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 472 JavaIdentifier.normalize( "tEST tEST tEST ", VARIABLE_NAME_CONVENTION ) ); 473 474 assertEquals( JavaIdentifier.valueOf( "test" ), 475 JavaIdentifier.normalize( "TEST", VARIABLE_NAME_CONVENTION ) ); 476 477 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 478 JavaIdentifier.normalize( "TestTestTest", VARIABLE_NAME_CONVENTION ) ); 479 480 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 481 JavaIdentifier.normalize( "testTestTest", VARIABLE_NAME_CONVENTION ) ); 482 483 assertEquals( JavaIdentifier.valueOf( "testTestTest" ), 484 JavaIdentifier.normalize( "test TeSt Test", VARIABLE_NAME_CONVENTION ) ); 485 486 assertEquals( JavaIdentifier.valueOf( "teStTeStTeStx" ), 487 JavaIdentifier.normalize( "TeStTeStTeStX", VARIABLE_NAME_CONVENTION ) ); 488 489 assertEquals( JavaIdentifier.valueOf( "testtesttestTesttesttest" ), 490 JavaIdentifier.normalize( "TeStTeStTeSt TeStTeStTeSt", VARIABLE_NAME_CONVENTION ) ); 491 492 for ( final String keyword : JavaLanguage.KEYWORDS ) 493 { 494 assertEquals( JavaIdentifier.valueOf( "_" + keyword ), 495 JavaIdentifier.normalize( " " + keyword + " ", VARIABLE_NAME_CONVENTION ) ); 496 497 } 498 499 for ( final String literal : JavaLanguage.BOOLEAN_LITERALS ) 500 { 501 assertEquals( JavaIdentifier.valueOf( "_" + literal ), 502 JavaIdentifier.normalize( " " + literal + " ", VARIABLE_NAME_CONVENTION ) ); 503 504 } 505 506 assertEquals( JavaIdentifier.valueOf( "_" + JavaLanguage.NULL_LITERAL ), 507 JavaIdentifier.normalize( " " + JavaLanguage.NULL_LITERAL + " ", VARIABLE_NAME_CONVENTION ) ); 508 509 assertInvalidJavaIdentifier( "", VARIABLE_NAME_CONVENTION ); 510 assertInvalidJavaIdentifier( "@", VARIABLE_NAME_CONVENTION ); 511 assertInvalidJavaIdentifier( " ", VARIABLE_NAME_CONVENTION ); 512 } 513 514 @Test 515 public final void Deserializable() throws Exception 516 { 517 ObjectInputStream in = null; 518 519 try 520 { 521 in = new ObjectInputStream( this.getClass().getResourceAsStream( 522 ABSOLUTE_RESOURCE_NAME_PREFIX + "JavaIdentifier.ser" ) ); 523 524 final JavaIdentifier javaIdentifier = (JavaIdentifier) in.readObject(); 525 assertEquals( "Java", javaIdentifier.toString() ); 526 System.out.println( javaIdentifier ); 527 } 528 finally 529 { 530 in.close(); 531 } 532 } 533 534 private static void assertInvalidJavaIdentifier( final String identifier ) 535 { 536 try 537 { 538 JavaIdentifier.parse( identifier ); 539 fail( "Expected 'ParseException' not thrown parsing Java identifier '" + identifier + "'." ); 540 } 541 catch ( final ParseException e ) 542 { 543 assertNotNull( e.getMessage() ); 544 System.out.println( e.getMessage() ); 545 } 546 547 try 548 { 549 JavaIdentifier.valueOf( identifier ); 550 fail( "Expected 'IllegalArgumentException' not thrown parsing Java identifier '" + identifier + "'." ); 551 } 552 catch ( final IllegalArgumentException e ) 553 { 554 assertNotNull( e.getMessage() ); 555 System.out.println( e.getMessage() ); 556 } 557 } 558 559 private static void assertInvalidJavaIdentifier( final String identifier, 560 final JavaIdentifier.NormalizationMode mode ) 561 { 562 try 563 { 564 JavaIdentifier.normalize( identifier, mode ); 565 fail( "Expected 'ParseException' not thrown normalizing Java identifier '" + identifier + "'." ); 566 } 567 catch ( final ParseException e ) 568 { 569 assertNotNull( e.getMessage() ); 570 System.out.println( e.getMessage() ); 571 } 572 } 573 574 private static String toUpperCase( final String string ) 575 { 576 final char[] c = string.toCharArray(); 577 578 for ( int i = c.length - 1; i >= 0; i-- ) 579 { 580 c[i] = Character.toUpperCase( c[i] ); 581 } 582 583 return String.valueOf( c ); 584 } 585 586 private static String toUpperCase( final String string, final int offset, final int count ) 587 { 588 final int limit = offset + count; 589 590 if ( string == null ) 591 { 592 throw new NullPointerException( "string" ); 593 } 594 if ( offset < 0 || offset >= string.length() ) 595 { 596 throw new StringIndexOutOfBoundsException(); 597 } 598 if ( count < 0 || limit >= string.length() ) 599 { 600 throw new StringIndexOutOfBoundsException(); 601 } 602 603 final char[] c = string.toCharArray(); 604 605 for ( int i = c.length - 1; i >= 0; i-- ) 606 { 607 if ( i >= offset && i < limit ) 608 { 609 c[i] = Character.toUpperCase( c[i] ); 610 } 611 } 612 613 return String.valueOf( c ); 614 } 615 616 private static String toLowerCase( final String string ) 617 { 618 final char[] c = string.toCharArray(); 619 620 for ( int i = c.length - 1; i >= 0; i-- ) 621 { 622 c[i] = Character.toLowerCase( c[i] ); 623 } 624 625 return String.valueOf( c ); 626 } 627 628}