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}