View Javadoc

1   /*
2    *   Copyright (C) Christian Schulte, 2012-235
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: JavaTypeNameTest.java 4681 2012-12-29 00:30:19Z 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.JavaTypeName;
36  import org.junit.Test;
37  import static org.junit.Assert.assertEquals;
38  import static org.junit.Assert.assertFalse;
39  import static org.junit.Assert.assertNotNull;
40  import static org.junit.Assert.assertTrue;
41  import static org.junit.Assert.fail;
42  
43  /**
44   * Test cases for class {@code org.jomc.model.JavaTypeName}.
45   *
46   * @author <a href="mailto:cs@schulte.it">Christian Schulte</a>
47   * @version $JOMC: JavaTypeNameTest.java 4681 2012-12-29 00:30:19Z schulte $
48   * @since 1.4
49   */
50  public class JavaTypeNameTest
51  {
52  
53      /** Constant to prefix relative resource names with. */
54      private static final String ABSOLUTE_RESOURCE_NAME_PREFIX = "/org/jomc/model/test/";
55  
56      /** Creates a new {@code JavaTypeNameTest} instance. */
57      public JavaTypeNameTest()
58      {
59          super();
60      }
61  
62      @Test
63      public final void ThrowsNullPointerExceptionOnNullArgument() throws Exception
64      {
65          try
66          {
67              JavaTypeName.parse( null );
68              fail( "Expected 'NullPointerException' not thrown." );
69          }
70          catch ( final NullPointerException e )
71          {
72              assertNotNull( e.getMessage() );
73              System.out.println( e.getMessage() );
74          }
75  
76          try
77          {
78              JavaTypeName.valueOf( null );
79              fail( "Expected 'NullPointerException' not thrown." );
80          }
81          catch ( final NullPointerException e )
82          {
83              assertNotNull( e.getMessage() );
84              System.out.println( e.getMessage() );
85          }
86      }
87  
88      @Test
89      public final void ParsesBasicTypeNames() throws Exception
90      {
91          for ( final String basicType : JavaLanguage.BASIC_TYPES )
92          {
93              assertBasicTypeName( basicType );
94          }
95      }
96  
97      @Test
98      public final void ParsesReferenceTypeNames() throws Exception
99      {
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 }