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}