001/*
002 *   Copyright (C) Christian Schulte, 2012-235
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: JavaTypeNameTest.java 4681 2012-12-29 00:30:19Z schulte $
029 *
030 */
031package org.jomc.model.test;
032
033import java.io.ObjectInputStream;
034import java.text.ParseException;
035import org.jomc.model.JavaTypeName;
036import org.junit.Test;
037import static org.junit.Assert.assertEquals;
038import static org.junit.Assert.assertFalse;
039import static org.junit.Assert.assertNotNull;
040import static org.junit.Assert.assertTrue;
041import static org.junit.Assert.fail;
042
043/**
044 * Test cases for class {@code org.jomc.model.JavaTypeName}.
045 *
046 * @author <a href="mailto:cs@schulte.it">Christian Schulte</a>
047 * @version $JOMC: JavaTypeNameTest.java 4681 2012-12-29 00:30:19Z schulte $
048 * @since 1.4
049 */
050public class JavaTypeNameTest
051{
052
053    /** Constant to prefix relative resource names with. */
054    private static final String ABSOLUTE_RESOURCE_NAME_PREFIX = "/org/jomc/model/test/";
055
056    /** Creates a new {@code JavaTypeNameTest} instance. */
057    public JavaTypeNameTest()
058    {
059        super();
060    }
061
062    @Test
063    public final void ThrowsNullPointerExceptionOnNullArgument() throws Exception
064    {
065        try
066        {
067            JavaTypeName.parse( null );
068            fail( "Expected 'NullPointerException' not thrown." );
069        }
070        catch ( final NullPointerException e )
071        {
072            assertNotNull( e.getMessage() );
073            System.out.println( e.getMessage() );
074        }
075
076        try
077        {
078            JavaTypeName.valueOf( null );
079            fail( "Expected 'NullPointerException' not thrown." );
080        }
081        catch ( final NullPointerException e )
082        {
083            assertNotNull( e.getMessage() );
084            System.out.println( e.getMessage() );
085        }
086    }
087
088    @Test
089    public final void ParsesBasicTypeNames() throws Exception
090    {
091        for ( final String basicType : JavaLanguage.BASIC_TYPES )
092        {
093            assertBasicTypeName( basicType );
094        }
095    }
096
097    @Test
098    public final void ParsesReferenceTypeNames() throws Exception
099    {
100        JavaTypeName javaTypeName = JavaTypeName.parse( "ReferenceType" );
101        assertEquals( "ReferenceType", javaTypeName.getClassName() );
102        assertEquals( "", javaTypeName.getPackageName() );
103        assertEquals( "ReferenceType", javaTypeName.getQualifiedName() );
104        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
105        assertEquals( "ReferenceType", javaTypeName.toString() );
106        assertFalse( javaTypeName.isArray() );
107        assertFalse( javaTypeName.isPrimitive() );
108
109        javaTypeName = JavaTypeName.parse( "validpackagename.ReferenceType" );
110        assertEquals( "validpackagename.ReferenceType", javaTypeName.getClassName() );
111        assertEquals( "validpackagename", javaTypeName.getPackageName() );
112        assertEquals( "validpackagename.ReferenceType", javaTypeName.getQualifiedName() );
113        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
114        assertEquals( "validpackagename.ReferenceType", javaTypeName.toString() );
115        assertFalse( javaTypeName.isArray() );
116        assertFalse( javaTypeName.isPrimitive() );
117
118        javaTypeName = JavaTypeName.parse( "ReferenceType<?>" );
119        assertEquals( "ReferenceType", javaTypeName.getClassName() );
120        assertEquals( "", javaTypeName.getPackageName() );
121        assertEquals( "ReferenceType", javaTypeName.getQualifiedName() );
122        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
123        assertEquals( "ReferenceType<?>", javaTypeName.toString() );
124        assertFalse( javaTypeName.isArray() );
125        assertFalse( javaTypeName.isPrimitive() );
126
127        javaTypeName = JavaTypeName.parse( "validpackagename.ReferenceType<?>" );
128        assertEquals( "validpackagename.ReferenceType", javaTypeName.getClassName() );
129        assertEquals( "validpackagename", javaTypeName.getPackageName() );
130        assertEquals( "validpackagename.ReferenceType", javaTypeName.getQualifiedName() );
131        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
132        assertEquals( "validpackagename.ReferenceType<?>", javaTypeName.toString() );
133        assertFalse( javaTypeName.isArray() );
134        assertFalse( javaTypeName.isPrimitive() );
135
136        javaTypeName = JavaTypeName.parse( "ReferenceType<?   extends   ReferenceType>" );
137        assertEquals( "ReferenceType", javaTypeName.getClassName() );
138        assertEquals( "", javaTypeName.getPackageName() );
139        assertEquals( "ReferenceType", javaTypeName.getQualifiedName() );
140        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
141        assertEquals( "ReferenceType<? extends ReferenceType>", javaTypeName.toString() );
142        assertFalse( javaTypeName.isArray() );
143        assertFalse( javaTypeName.isPrimitive() );
144
145        javaTypeName = JavaTypeName.parse( "validpackagename.ReferenceType<?   extends   ReferenceType>" );
146        assertEquals( "validpackagename.ReferenceType", javaTypeName.getClassName() );
147        assertEquals( "validpackagename", javaTypeName.getPackageName() );
148        assertEquals( "validpackagename.ReferenceType", javaTypeName.getQualifiedName() );
149        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
150        assertEquals( "validpackagename.ReferenceType<? extends ReferenceType>", javaTypeName.toString() );
151        assertFalse( javaTypeName.isArray() );
152        assertFalse( javaTypeName.isPrimitive() );
153
154        javaTypeName = JavaTypeName.parse( "ReferenceType<?   super   ReferenceType>" );
155        assertEquals( "ReferenceType", javaTypeName.getClassName() );
156        assertEquals( "", javaTypeName.getPackageName() );
157        assertEquals( "ReferenceType", javaTypeName.getQualifiedName() );
158        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
159        assertEquals( "ReferenceType<? super ReferenceType>", javaTypeName.toString() );
160        assertFalse( javaTypeName.isArray() );
161        assertFalse( javaTypeName.isPrimitive() );
162
163        javaTypeName = JavaTypeName.parse( "validpackagename.ReferenceType<?   super   ReferenceType>" );
164        assertEquals( "validpackagename.ReferenceType", javaTypeName.getClassName() );
165        assertEquals( "validpackagename", javaTypeName.getPackageName() );
166        assertEquals( "validpackagename.ReferenceType", javaTypeName.getQualifiedName() );
167        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
168        assertEquals( "validpackagename.ReferenceType<? super ReferenceType>", javaTypeName.toString() );
169        assertFalse( javaTypeName.isArray() );
170        assertFalse( javaTypeName.isPrimitive() );
171
172        javaTypeName = JavaTypeName.parse( "ReferenceType<ReferenceType>" );
173        assertEquals( "ReferenceType", javaTypeName.getClassName() );
174        assertEquals( "", javaTypeName.getPackageName() );
175        assertEquals( "ReferenceType", javaTypeName.getQualifiedName() );
176        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
177        assertEquals( "ReferenceType<ReferenceType>", javaTypeName.toString() );
178        assertFalse( javaTypeName.isArray() );
179        assertFalse( javaTypeName.isPrimitive() );
180
181        javaTypeName = JavaTypeName.parse( "validpackagename.ReferenceType<ReferenceType>" );
182        assertEquals( "validpackagename.ReferenceType", javaTypeName.getClassName() );
183        assertEquals( "validpackagename", javaTypeName.getPackageName() );
184        assertEquals( "validpackagename.ReferenceType", javaTypeName.getQualifiedName() );
185        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
186        assertEquals( "validpackagename.ReferenceType<ReferenceType>", javaTypeName.toString() );
187        assertFalse( javaTypeName.isArray() );
188        assertFalse( javaTypeName.isPrimitive() );
189
190        javaTypeName = JavaTypeName.parse( "ReferenceType<ReferenceType,?>" );
191        assertEquals( "ReferenceType", javaTypeName.getClassName() );
192        assertEquals( "", javaTypeName.getPackageName() );
193        assertEquals( "ReferenceType", javaTypeName.getQualifiedName() );
194        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
195        assertEquals( "ReferenceType<ReferenceType, ?>", javaTypeName.toString() );
196        assertFalse( javaTypeName.isArray() );
197        assertFalse( javaTypeName.isPrimitive() );
198
199        javaTypeName = JavaTypeName.parse( "validpackagename.ReferenceType<ReferenceType,?>" );
200        assertEquals( "validpackagename.ReferenceType", javaTypeName.getClassName() );
201        assertEquals( "validpackagename", javaTypeName.getPackageName() );
202        assertEquals( "validpackagename.ReferenceType", javaTypeName.getQualifiedName() );
203        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
204        assertEquals( "validpackagename.ReferenceType<ReferenceType, ?>", javaTypeName.toString() );
205        assertFalse( javaTypeName.isArray() );
206        assertFalse( javaTypeName.isPrimitive() );
207
208        javaTypeName = JavaTypeName.parse( "ReferenceType<ReferenceType,?   extends ReferenceType>" );
209        assertEquals( "ReferenceType", javaTypeName.getClassName() );
210        assertEquals( "", javaTypeName.getPackageName() );
211        assertEquals( "ReferenceType", javaTypeName.getQualifiedName() );
212        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
213        assertEquals( "ReferenceType<ReferenceType, ? extends ReferenceType>", javaTypeName.toString() );
214        assertFalse( javaTypeName.isArray() );
215        assertFalse( javaTypeName.isPrimitive() );
216
217        javaTypeName = JavaTypeName.parse( "validpackagename.ReferenceType<ReferenceType,?   extends ReferenceType>" );
218        assertEquals( "validpackagename.ReferenceType", javaTypeName.getClassName() );
219        assertEquals( "validpackagename", javaTypeName.getPackageName() );
220        assertEquals( "validpackagename.ReferenceType", javaTypeName.getQualifiedName() );
221        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
222        assertEquals( "validpackagename.ReferenceType<ReferenceType, ? extends ReferenceType>",
223                      javaTypeName.toString() );
224
225        assertFalse( javaTypeName.isArray() );
226        assertFalse( javaTypeName.isPrimitive() );
227
228        javaTypeName = JavaTypeName.parse( "ReferenceType<ReferenceType,?   super ReferenceType>" );
229        assertEquals( "ReferenceType", javaTypeName.getClassName() );
230        assertEquals( "", javaTypeName.getPackageName() );
231        assertEquals( "ReferenceType", javaTypeName.getQualifiedName() );
232        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
233        assertEquals( "ReferenceType<ReferenceType, ? super ReferenceType>", javaTypeName.toString() );
234        assertFalse( javaTypeName.isArray() );
235        assertFalse( javaTypeName.isPrimitive() );
236
237        javaTypeName = JavaTypeName.parse( "validpackagename.ReferenceType<ReferenceType,?   super ReferenceType>" );
238        assertEquals( "validpackagename.ReferenceType", javaTypeName.getClassName() );
239        assertEquals( "validpackagename", javaTypeName.getPackageName() );
240        assertEquals( "validpackagename.ReferenceType", javaTypeName.getQualifiedName() );
241        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
242        assertEquals( "validpackagename.ReferenceType<ReferenceType, ? super ReferenceType>", javaTypeName.toString() );
243        assertFalse( javaTypeName.isArray() );
244        assertFalse( javaTypeName.isPrimitive() );
245
246        javaTypeName = JavaTypeName.parse( "ReferenceType<ReferenceType,ReferenceType>" );
247        assertEquals( "ReferenceType", javaTypeName.getClassName() );
248        assertEquals( "", javaTypeName.getPackageName() );
249        assertEquals( "ReferenceType", javaTypeName.getQualifiedName() );
250        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
251        assertEquals( "ReferenceType<ReferenceType, ReferenceType>", javaTypeName.toString() );
252        assertFalse( javaTypeName.isArray() );
253        assertFalse( javaTypeName.isPrimitive() );
254
255        javaTypeName = JavaTypeName.parse( "validpackagename.ReferenceType<ReferenceType,ReferenceType>" );
256        assertEquals( "validpackagename.ReferenceType", javaTypeName.getClassName() );
257        assertEquals( "validpackagename", javaTypeName.getPackageName() );
258        assertEquals( "validpackagename.ReferenceType", javaTypeName.getQualifiedName() );
259        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
260        assertEquals( "validpackagename.ReferenceType<ReferenceType, ReferenceType>",
261                      javaTypeName.toString() );
262
263        assertFalse( javaTypeName.isArray() );
264        assertFalse( javaTypeName.isPrimitive() );
265
266        javaTypeName = JavaTypeName.parse(
267            "validpackagename.ReferenceType<validpackagename.ReferenceType<validpackagename.ReferenceType<"
268            + "validpackagename.ReferenceType>>,?   super validpackagename.ReferenceType<"
269            + "validpackagename.ReferenceType<validpackagename.ReferenceType>>>" );
270
271        assertEquals( "validpackagename.ReferenceType", javaTypeName.getClassName() );
272        assertEquals( "validpackagename", javaTypeName.getPackageName() );
273        assertEquals( "validpackagename.ReferenceType", javaTypeName.getQualifiedName() );
274        assertEquals( "ReferenceType", javaTypeName.getSimpleName() );
275        assertEquals( "validpackagename.ReferenceType<validpackagename.ReferenceType<validpackagename.ReferenceType<"
276                      + "validpackagename.ReferenceType>>, ? super validpackagename.ReferenceType<"
277                      + "validpackagename.ReferenceType<validpackagename.ReferenceType>>>",
278                      javaTypeName.toString() );
279
280        assertFalse( javaTypeName.isArray() );
281        assertFalse( javaTypeName.isPrimitive() );
282    }
283
284    @Test
285    public final void ParsesBasicArrayTypeNames() throws Exception
286    {
287        for ( final String basicType : JavaLanguage.BASIC_TYPES )
288        {
289            assertBasicArrayTypeName( basicType + "[]" );
290            assertBasicArrayTypeName( basicType + "[][]" );
291            assertBasicArrayTypeName( basicType + "[][][]" );
292        }
293    }
294
295    @Test
296    public final void DetectsInvalidQualifiedBasicTypeNames() throws Exception
297    {
298        for ( final String basicType : JavaLanguage.BASIC_TYPES )
299        {
300            assertInvalidTypeName( "validpackagename." + basicType );
301        }
302    }
303
304    @Test
305    public final void DetectsInvalidQualifiedBasicArrayTypeNames() throws Exception
306    {
307        for ( final String basicType : JavaLanguage.BASIC_TYPES )
308        {
309            assertInvalidTypeName( "validpackagename." + basicType + "[]" );
310            assertInvalidTypeName( "validpackagename." + basicType + "[][]" );
311            assertInvalidTypeName( "validpackagename." + basicType + "[][][]" );
312        }
313    }
314
315    @Test
316    public final void DetectsInvalidBasicTypeNamesWithReferenceTypeArgument() throws Exception
317    {
318        for ( final String basicType : JavaLanguage.BASIC_TYPES )
319        {
320            assertInvalidTypeName( basicType + "<Test>" );
321        }
322    }
323
324    @Test
325    public final void DetectsInvalidBasicTypeNamesWithWildcardTypeArgument() throws Exception
326    {
327        for ( final String basicType : JavaLanguage.BASIC_TYPES )
328        {
329            assertInvalidTypeName( basicType + "<?>" );
330        }
331    }
332
333    @Test
334    public final void DetectsInvalidBasicTypeNamesWithBoundedWildcardTypeArgument() throws Exception
335    {
336        for ( final String basicType : JavaLanguage.BASIC_TYPES )
337        {
338            assertInvalidTypeName( basicType + "<? extends Test>" );
339            assertInvalidTypeName( basicType + "<? super Test>" );
340        }
341    }
342
343    @Test
344    public final void DetectsInvalidKeywordOrBooleanLiteralOrNullLiteralIdentifiers() throws Exception
345    {
346        for ( final String keyword : JavaLanguage.KEYWORDS )
347        {
348            if ( !JavaLanguage.BASIC_TYPES.contains( keyword ) )
349            {
350                assertInvalidTypeName( keyword );
351            }
352
353            assertInvalidTypeName( "validpackagename." + keyword );
354            assertInvalidTypeName( "validpackagename.Test<" + keyword + ">" );
355            assertInvalidTypeName( "validpackagename.Test<Test," + keyword + ">" );
356            assertInvalidTypeName( "validpackagename.Test<?,Test," + keyword + ">" );
357            assertInvalidTypeName( "validpackagename.Test<? extends " + keyword + ">" );
358            assertInvalidTypeName( "validpackagename.Test<? super " + keyword + ">" );
359            assertInvalidTypeName( "validpackagename.Test<Test, ? extends " + keyword + ">" );
360            assertInvalidTypeName( "validpackagename.Test<Test, ? super " + keyword + ">" );
361            assertInvalidTypeName( "validpackagename.Test<?, Test, ? extends " + keyword + ">" );
362            assertInvalidTypeName( "validpackagename.Test<?, Test, ? super " + keyword + ">" );
363        }
364
365        for ( final String literal : JavaLanguage.BOOLEAN_LITERALS )
366        {
367            assertInvalidTypeName( literal );
368            assertInvalidTypeName( "validpackagename." + literal );
369            assertInvalidTypeName( "validpackagename.Test<" + literal + ">" );
370            assertInvalidTypeName( "validpackagename.Test<Test," + literal + ">" );
371            assertInvalidTypeName( "validpackagename.Test<?,Test," + literal + ">" );
372            assertInvalidTypeName( "validpackagename.Test<? extends " + literal + ">" );
373            assertInvalidTypeName( "validpackagename.Test<? super " + literal + ">" );
374            assertInvalidTypeName( "validpackagename.Test<Test, ? extends " + literal + ">" );
375            assertInvalidTypeName( "validpackagename.Test<Test, ? super " + literal + ">" );
376            assertInvalidTypeName( "validpackagename.Test<?, Test, ? extends " + literal + ">" );
377            assertInvalidTypeName( "validpackagename.Test<?, Test, ? super " + literal + ">" );
378        }
379
380        assertInvalidTypeName( JavaLanguage.NULL_LITERAL );
381        assertInvalidTypeName( "validpackagename." + JavaLanguage.NULL_LITERAL );
382        assertInvalidTypeName( "validpackagename.Test<" + JavaLanguage.NULL_LITERAL + ">" );
383        assertInvalidTypeName( "validpackagename.Test<Test," + JavaLanguage.NULL_LITERAL + ">" );
384        assertInvalidTypeName( "validpackagename.Test<?,Test," + JavaLanguage.NULL_LITERAL + ">" );
385        assertInvalidTypeName( "validpackagename.Test<? extends " + JavaLanguage.NULL_LITERAL + ">" );
386        assertInvalidTypeName( "validpackagename.Test<? super " + JavaLanguage.NULL_LITERAL + ">" );
387        assertInvalidTypeName( "validpackagename.Test<Test, ? extends " + JavaLanguage.NULL_LITERAL + ">" );
388        assertInvalidTypeName( "validpackagename.Test<Test, ? super " + JavaLanguage.NULL_LITERAL + ">" );
389        assertInvalidTypeName( "validpackagename.Test<?, Test, ? extends " + JavaLanguage.NULL_LITERAL + ">" );
390        assertInvalidTypeName( "validpackagename.Test<?, Test, ? super " + JavaLanguage.NULL_LITERAL + ">" );
391    }
392
393    @Test
394    public final void DetectsMisplacedSeparatorTokens() throws Exception
395    {
396        assertInvalidTypeName( "[" );
397        assertInvalidTypeName( "]" );
398        assertInvalidTypeName( "<" );
399        assertInvalidTypeName( ">" );
400        assertInvalidTypeName( "," );
401        assertInvalidTypeName( "." );
402        assertInvalidTypeName( "?" );
403
404        assertInvalidTypeName( "[TEST" );
405        assertInvalidTypeName( "]TEST" );
406        assertInvalidTypeName( "<TEST" );
407        assertInvalidTypeName( ">TEST" );
408        assertInvalidTypeName( ",TEST" );
409        assertInvalidTypeName( ".TEST" );
410        assertInvalidTypeName( "?TEST" );
411
412        assertInvalidTypeName( "TEST[TEST" );
413        assertInvalidTypeName( "TEST]TEST" );
414        assertInvalidTypeName( "TEST>TEST" );
415        assertInvalidTypeName( "TEST,TEST" );
416        assertInvalidTypeName( "TEST?TEST" );
417
418        assertInvalidTypeName( "TEST]" );
419        assertInvalidTypeName( "TEST>" );
420        assertInvalidTypeName( "TEST," );
421        assertInvalidTypeName( "TEST?" );
422
423        assertInvalidTypeName( "TEST.TEST]" );
424        assertInvalidTypeName( "TEST.TEST>" );
425        assertInvalidTypeName( "TEST.TEST," );
426        assertInvalidTypeName( "TEST.TEST?" );
427
428        assertInvalidTypeName( "TEST<TEST[" );
429        assertInvalidTypeName( "TEST<TEST]" );
430        assertInvalidTypeName( "TEST<TEST," );
431        assertInvalidTypeName( "TEST<TEST." );
432        assertInvalidTypeName( "TEST<TEST?" );
433
434        assertInvalidTypeName( "TEST<TEST<[" );
435        assertInvalidTypeName( "TEST<TEST<]" );
436        assertInvalidTypeName( "TEST<TEST<," );
437        assertInvalidTypeName( "TEST<TEST<." );
438        assertInvalidTypeName( "TEST<TEST<?" );
439
440        for ( final String basicType : JavaLanguage.BASIC_TYPES )
441        {
442            assertInvalidTypeName( "[" + basicType );
443            assertInvalidTypeName( "]" + basicType );
444            assertInvalidTypeName( "<" + basicType );
445            assertInvalidTypeName( ">" + basicType );
446            assertInvalidTypeName( "," + basicType );
447            assertInvalidTypeName( "." + basicType );
448            assertInvalidTypeName( "?" + basicType );
449        }
450
451        for ( final String basicType : JavaLanguage.BASIC_TYPES )
452        {
453            assertInvalidTypeName( basicType + "]" );
454            assertInvalidTypeName( basicType + ">" );
455            assertInvalidTypeName( basicType + "," );
456            assertInvalidTypeName( basicType + "?" );
457        }
458    }
459
460    @Test
461    public final void DetectsUnexpectedEndOfInput() throws Exception
462    {
463        assertInvalidTypeName( "" );
464        assertInvalidTypeName( "boolean[" );
465        assertInvalidTypeName( "TEST[" );
466
467        assertInvalidTypeName( "TEST[" );
468        assertInvalidTypeName( "TEST<" );
469        assertInvalidTypeName( "TEST." );
470
471        assertInvalidTypeName( "TEST.TEST[" );
472        assertInvalidTypeName( "TEST.TEST<" );
473
474        assertInvalidTypeName( "TEST<TEST" );
475        assertInvalidTypeName( "TEST<TEST." );
476        assertInvalidTypeName( "TEST<?" );
477        assertInvalidTypeName( "TEST<?extends" );
478        assertInvalidTypeName( "TEST<?super" );
479
480        assertInvalidTypeName( "TEST.TEST<TEST" );
481        assertInvalidTypeName( "TEST.TEST<?" );
482        assertInvalidTypeName( "TEST.TEST<?extends" );
483        assertInvalidTypeName( "TEST.TEST<?super" );
484
485        for ( final String basicType : JavaLanguage.BASIC_TYPES )
486        {
487            assertInvalidTypeName( basicType + "[" );
488        }
489    }
490
491    @Test
492    public final void DetectsInvalidTokens() throws Exception
493    {
494        assertInvalidTypeName( "@" );
495
496        for ( final String basicType : JavaLanguage.BASIC_TYPES )
497        {
498            assertInvalidTypeName( basicType + "@" );
499        }
500
501        assertInvalidTypeName( "ReferenceType@" );
502        assertInvalidTypeName( "validpackagename.ReferenceType@" );
503        assertInvalidTypeName( "validpackagename@ReferenceType" );
504        assertInvalidTypeName( "validpackagename.ReferenceType<@>" );
505        assertInvalidTypeName( "validpackagename.ReferenceType<? extends @>" );
506        assertInvalidTypeName( "validpackagename.ReferenceType<? super @>" );
507        assertInvalidTypeName( "ReferenceType<ReferenceType<@>>" );
508        assertInvalidTypeName( "ReferenceType<ReferenceType<? extends @>>" );
509        assertInvalidTypeName( "ReferenceType<ReferenceType<? super @>>" );
510        assertInvalidTypeName( "validpackagename.ReferenceType<validpackagename.ReferenceType<@>>" );
511        assertInvalidTypeName( "validpackagename.ReferenceType<validpackagename.ReferenceType<? extends @>>" );
512        assertInvalidTypeName( "validpackagename.ReferenceType<validpackagename.ReferenceType<? super @>>" );
513    }
514
515    @Test
516    public final void DetectsDuplicateTokens() throws Exception
517    {
518        for ( final String basicType : JavaLanguage.BASIC_TYPES )
519        {
520            assertInvalidTypeName( basicType + " " + basicType );
521        }
522
523        assertInvalidTypeName( "ReferenceType ReferenceType" );
524        assertInvalidTypeName( "ReferenceType.." );
525        assertInvalidTypeName( "ReferenceType<<" );
526        assertInvalidTypeName( "ReferenceType[[" );
527        assertInvalidTypeName( "ReferenceType<ReferenceType,," );
528    }
529
530    @Test
531    public final void ClassNameEncodings() throws Exception
532    {
533        assertEquals( "boolean", JavaTypeName.parse( "boolean" ).getClassName() );
534        assertEquals( "byte", JavaTypeName.parse( "byte" ).getClassName() );
535        assertEquals( "char", JavaTypeName.parse( "char" ).getClassName() );
536        assertEquals( "double", JavaTypeName.parse( "double" ).getClassName() );
537        assertEquals( "float", JavaTypeName.parse( "float" ).getClassName() );
538        assertEquals( "int", JavaTypeName.parse( "int" ).getClassName() );
539        assertEquals( "long", JavaTypeName.parse( "long" ).getClassName() );
540        assertEquals( "short", JavaTypeName.parse( "short" ).getClassName() );
541
542        assertEquals( "[Z", JavaTypeName.parse( "boolean[]" ).getClassName() );
543        assertEquals( "[B", JavaTypeName.parse( "byte[]" ).getClassName() );
544        assertEquals( "[C", JavaTypeName.parse( "char[]" ).getClassName() );
545        assertEquals( "[D", JavaTypeName.parse( "double[]" ).getClassName() );
546        assertEquals( "[F", JavaTypeName.parse( "float[]" ).getClassName() );
547        assertEquals( "[I", JavaTypeName.parse( "int[]" ).getClassName() );
548        assertEquals( "[J", JavaTypeName.parse( "long[]" ).getClassName() );
549        assertEquals( "[S", JavaTypeName.parse( "short[]" ).getClassName() );
550
551        assertEquals( "[[Z", JavaTypeName.parse( "boolean[][]" ).getClassName() );
552        assertEquals( "[[B", JavaTypeName.parse( "byte[][]" ).getClassName() );
553        assertEquals( "[[C", JavaTypeName.parse( "char[][]" ).getClassName() );
554        assertEquals( "[[D", JavaTypeName.parse( "double[][]" ).getClassName() );
555        assertEquals( "[[F", JavaTypeName.parse( "float[][]" ).getClassName() );
556        assertEquals( "[[I", JavaTypeName.parse( "int[][]" ).getClassName() );
557        assertEquals( "[[J", JavaTypeName.parse( "long[][]" ).getClassName() );
558        assertEquals( "[[S", JavaTypeName.parse( "short[][]" ).getClassName() );
559
560        assertEquals( "[[[Z", JavaTypeName.parse( "boolean[][][]" ).getClassName() );
561        assertEquals( "[[[B", JavaTypeName.parse( "byte[][][]" ).getClassName() );
562        assertEquals( "[[[C", JavaTypeName.parse( "char[][][]" ).getClassName() );
563        assertEquals( "[[[D", JavaTypeName.parse( "double[][][]" ).getClassName() );
564        assertEquals( "[[[F", JavaTypeName.parse( "float[][][]" ).getClassName() );
565        assertEquals( "[[[I", JavaTypeName.parse( "int[][][]" ).getClassName() );
566        assertEquals( "[[[J", JavaTypeName.parse( "long[][][]" ).getClassName() );
567        assertEquals( "[[[S", JavaTypeName.parse( "short[][][]" ).getClassName() );
568
569        assertEquals( "ReferenceType", JavaTypeName.parse( "ReferenceType" ).getClassName() );
570        assertEquals( "validpackagename.ReferenceType",
571                      JavaTypeName.parse( "validpackagename.ReferenceType" ).getClassName() );
572
573        assertEquals( "[LReferenceType;", JavaTypeName.parse( "ReferenceType[]" ).getClassName() );
574        assertEquals( "[Lvalidpackagename.ReferenceType;",
575                      JavaTypeName.parse( "validpackagename.ReferenceType[]" ).getClassName() );
576
577        assertEquals( "[[LReferenceType;", JavaTypeName.parse( "ReferenceType[][]" ).getClassName() );
578        assertEquals( "[[Lvalidpackagename.ReferenceType;",
579                      JavaTypeName.parse( "validpackagename.ReferenceType[][]" ).getClassName() );
580
581        assertEquals( "[[[LReferenceType;", JavaTypeName.parse( "ReferenceType[][][]" ).getClassName() );
582        assertEquals( "[[[Lvalidpackagename.ReferenceType;",
583                      JavaTypeName.parse( "validpackagename.ReferenceType[][][]" ).getClassName() );
584
585    }
586
587    @Test
588    public final void Deserializable() throws Exception
589    {
590        ObjectInputStream in = null;
591
592        try
593        {
594            in = new ObjectInputStream( this.getClass().getResourceAsStream(
595                ABSOLUTE_RESOURCE_NAME_PREFIX + "JavaTypeName.ser" ) );
596
597            final JavaTypeName javaTypeName = (JavaTypeName) in.readObject();
598            assertEquals( "Java<Java>", javaTypeName.getName( true ) );
599            assertEquals( 1, javaTypeName.getArguments().size() );
600            assertEquals( "Java", javaTypeName.getArguments().get( 0 ).getTypeName().getName( true ) );
601            System.out.println( javaTypeName );
602        }
603        finally
604        {
605            in.close();
606        }
607
608        try
609        {
610            in = new ObjectInputStream( this.getClass().getResourceAsStream(
611                ABSOLUTE_RESOURCE_NAME_PREFIX + "JavaTypeNameArgument.ser" ) );
612
613            final JavaTypeName.Argument javaTypeNameArgument = (JavaTypeName.Argument) in.readObject();
614            assertEquals( "Java", javaTypeNameArgument.getTypeName().getName( true ) );
615            System.out.println( javaTypeNameArgument );
616        }
617        finally
618        {
619            in.close();
620        }
621    }
622
623    private static void assertBasicTypeName( final String typeName )
624    {
625        final JavaTypeName t = JavaTypeName.valueOf( typeName );
626        assertEquals( "", t.getPackageName() );
627        assertEquals( typeName, t.getClassName() );
628        assertEquals( typeName, t.getQualifiedName() );
629        assertEquals( typeName, t.getSimpleName() );
630        assertFalse( t.isArray() );
631        assertTrue( t.isPrimitive() );
632    }
633
634    private static void assertBasicArrayTypeName( final String typeName )
635    {
636        final JavaTypeName t = JavaTypeName.valueOf( typeName );
637        assertEquals( "", t.getPackageName() );
638        assertEquals( typeName, t.getQualifiedName() );
639        assertEquals( typeName, t.getSimpleName() );
640        assertTrue( t.isArray() );
641        assertTrue( t.isPrimitive() );
642    }
643
644    private static void assertInvalidTypeName( final String typeName )
645    {
646        try
647        {
648            JavaTypeName.parse( typeName );
649            fail( "Expected 'ParseException' not thrown parsing Java type name '" + typeName + "'." );
650        }
651        catch ( final ParseException e )
652        {
653            assertNotNull( e.getMessage() );
654            System.out.println( e.getMessage() );
655        }
656    }
657
658}