View Javadoc

1   /*
2    *   Copyright (C) Christian Schulte, 2012-262
3    *   All rights reserved.
4    *
5    *   Redistribution and use in source and binary forms, with or without
6    *   modification, are permitted provided that the following conditions
7    *   are met:
8    *
9    *     o Redistributions of source code must retain the above copyright
10   *       notice, this list of conditions and the following disclaimer.
11   *
12   *     o Redistributions in binary form must reproduce the above copyright
13   *       notice, this list of conditions and the following disclaimer in
14   *       the documentation and/or other materials provided with the
15   *       distribution.
16   *
17   *   THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
18   *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
19   *   AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
20   *   THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
21   *   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22   *   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23   *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24   *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25   *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26   *   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27   *
28   *   $JOMC: JavaIdentifierTest.java 4704 2013-01-02 05:15:52Z schulte $
29   *
30   */
31  package org.jomc.model.test;
32  
33  import java.io.ObjectInputStream;
34  import java.text.ParseException;
35  import org.jomc.model.JavaIdentifier;
36  import org.junit.Test;
37  import static org.jomc.model.JavaIdentifier.NormalizationMode.CAMEL_CASE;
38  import static org.jomc.model.JavaIdentifier.NormalizationMode.CONSTANT_NAME_CONVENTION;
39  import static org.jomc.model.JavaIdentifier.NormalizationMode.LOWER_CASE;
40  import static org.jomc.model.JavaIdentifier.NormalizationMode.METHOD_NAME_CONVENTION;
41  import static org.jomc.model.JavaIdentifier.NormalizationMode.UPPER_CASE;
42  import static org.jomc.model.JavaIdentifier.NormalizationMode.VARIABLE_NAME_CONVENTION;
43  import static org.junit.Assert.assertEquals;
44  import static org.junit.Assert.assertNotNull;
45  import static org.junit.Assert.fail;
46  
47  /**
48   * Test cases for class {@code org.jomc.model.JavaIdentifier}.
49   *
50   * @author <a href="mailto:cs@schulte.it">Christian Schulte</a>
51   * @version $JOMC: JavaIdentifierTest.java 4704 2013-01-02 05:15:52Z schulte $
52   * @since 1.4
53   */
54  public class JavaIdentifierTest
55  {
56  
57      /** Constant to prefix relative resource names with. */
58      private static final String ABSOLUTE_RESOURCE_NAME_PREFIX = "/org/jomc/model/test/";
59  
60      /** Creates a new {@code JavaIdentifierTest} instance. */
61      public JavaIdentifierTest()
62      {
63          super();
64      }
65  
66      @Test
67      public final void NormalizeThrowsNullPointerExceptionOnNullArgument() throws Exception
68      {
69          try
70          {
71              JavaIdentifier.normalize( null, CAMEL_CASE );
72              fail( "Expected 'NullPointerException' not thrown." );
73          }
74          catch ( final NullPointerException e )
75          {
76              assertNotNull( e.getMessage() );
77              System.out.println( e.toString() );
78          }
79          try
80          {
81              JavaIdentifier.normalize( "", null );
82              fail( "Expected 'NullPointerException' not thrown." );
83          }
84          catch ( final NullPointerException e )
85          {
86              assertNotNull( e.getMessage() );
87              System.out.println( e.toString() );
88          }
89      }
90  
91      @Test
92      public final void ParseAndValueOfCorrectlyDetectInvalidIdentifiers() throws Exception
93      {
94          assertInvalidJavaIdentifier( "" );
95          assertInvalidJavaIdentifier( "@" );
96          assertInvalidJavaIdentifier( "   " );
97  
98          for ( final String keyword : JavaLanguage.KEYWORDS )
99          {
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 }