1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31 package org.jomc.model.test;
32
33 import java.io.ObjectInputStream;
34 import java.text.ParseException;
35 import org.jomc.model.JavaIdentifier;
36 import org.junit.Test;
37 import static org.jomc.model.JavaIdentifier.NormalizationMode.CAMEL_CASE;
38 import static org.jomc.model.JavaIdentifier.NormalizationMode.CONSTANT_NAME_CONVENTION;
39 import static org.jomc.model.JavaIdentifier.NormalizationMode.LOWER_CASE;
40 import static org.jomc.model.JavaIdentifier.NormalizationMode.METHOD_NAME_CONVENTION;
41 import static org.jomc.model.JavaIdentifier.NormalizationMode.UPPER_CASE;
42 import static org.jomc.model.JavaIdentifier.NormalizationMode.VARIABLE_NAME_CONVENTION;
43 import static org.junit.Assert.assertEquals;
44 import static org.junit.Assert.assertNotNull;
45 import static org.junit.Assert.fail;
46
47
48
49
50
51
52
53
54 public class JavaIdentifierTest
55 {
56
57
58 private static final String ABSOLUTE_RESOURCE_NAME_PREFIX = "/org/jomc/model/test/";
59
60
61 public JavaIdentifierTest()
62 {
63 super();
64 }
65
66 @Test
67 public final void NormalizeThrowsNullPointerExceptionOnNullArgument() throws Exception
68 {
69 try
70 {
71 JavaIdentifier.normalize( null, CAMEL_CASE );
72 fail( "Expected 'NullPointerException' not thrown." );
73 }
74 catch ( final NullPointerException e )
75 {
76 assertNotNull( e.getMessage() );
77 System.out.println( e.toString() );
78 }
79 try
80 {
81 JavaIdentifier.normalize( "", null );
82 fail( "Expected 'NullPointerException' not thrown." );
83 }
84 catch ( final NullPointerException e )
85 {
86 assertNotNull( e.getMessage() );
87 System.out.println( e.toString() );
88 }
89 }
90
91 @Test
92 public final void ParseAndValueOfCorrectlyDetectInvalidIdentifiers() throws Exception
93 {
94 assertInvalidJavaIdentifier( "" );
95 assertInvalidJavaIdentifier( "@" );
96 assertInvalidJavaIdentifier( " " );
97
98 for ( final String keyword : JavaLanguage.KEYWORDS )
99 {
100 assertInvalidJavaIdentifier( keyword );
101 }
102 for ( final String literal : JavaLanguage.BOOLEAN_LITERALS )
103 {
104 assertInvalidJavaIdentifier( literal );
105 }
106
107 assertInvalidJavaIdentifier( JavaLanguage.NULL_LITERAL );
108 }
109
110 @Test
111 public final void ParseThrowsNullPointerExceptionOnNullArgument() throws Exception
112 {
113 try
114 {
115 JavaIdentifier.parse( null );
116 fail( "Expected 'NullPointerException' not thrown." );
117 }
118 catch ( final NullPointerException e )
119 {
120 assertNotNull( e.getMessage() );
121 System.out.println( e.toString() );
122 }
123 }
124
125 @Test
126 public final void ValueOfThrowsNullPointerExceptionOnNullArgument() throws Exception
127 {
128 try
129 {
130 JavaIdentifier.valueOf( null );
131 fail( "Expected 'NullPointerException' not thrown." );
132 }
133 catch ( final NullPointerException e )
134 {
135 assertNotNull( e.getMessage() );
136 System.out.println( e.toString() );
137 }
138 }
139
140 @Test
141 public final void CamelCaseNormalization() throws Exception
142 {
143 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ),
144 JavaIdentifier.normalize( "test test test ", CAMEL_CASE ) );
145
146 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ),
147 JavaIdentifier.normalize( "test_test_test", CAMEL_CASE ) );
148
149 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ),
150 JavaIdentifier.normalize( " test_test_test ", CAMEL_CASE ) );
151
152 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ),
153 JavaIdentifier.normalize( " test test test ", CAMEL_CASE ) );
154
155 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ),
156 JavaIdentifier.normalize( " test test test ", CAMEL_CASE ) );
157
158 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ),
159 JavaIdentifier.normalize( " Test test test ", CAMEL_CASE ) );
160
161 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ),
162 JavaIdentifier.normalize( " Test test test ", CAMEL_CASE ) );
163
164 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ),
165 JavaIdentifier.normalize( "Test test test ", CAMEL_CASE ) );
166
167 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ),
168 JavaIdentifier.normalize( "tEST tEST tEST ", CAMEL_CASE ) );
169
170 assertEquals( JavaIdentifier.valueOf( "Test" ),
171 JavaIdentifier.normalize( "TEST", CAMEL_CASE ) );
172
173 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ),
174 JavaIdentifier.normalize( "TestTestTest", CAMEL_CASE ) );
175
176 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ),
177 JavaIdentifier.normalize( "testTestTest", CAMEL_CASE ) );
178
179 assertEquals( JavaIdentifier.valueOf( "TestTestTest" ),
180 JavaIdentifier.normalize( "test TeSt Test", CAMEL_CASE ) );
181
182 assertEquals( JavaIdentifier.valueOf( "TesTtEsTtEst" ),
183 JavaIdentifier.normalize( "tEsTtEsTtEsT", CAMEL_CASE ) );
184
185 assertEquals( JavaIdentifier.valueOf( "TesttesttestTesttesttest" ),
186 JavaIdentifier.normalize( "tEsTtEsTtEsT tEsTtEsTtEsT", CAMEL_CASE ) );
187
188 for ( final String keyword : JavaLanguage.KEYWORDS )
189 {
190 assertEquals( JavaIdentifier.valueOf( toUpperCase( keyword, 0, 1 ) ),
191 JavaIdentifier.normalize( " " + keyword + " ", CAMEL_CASE ) );
192
193 }
194
195 for ( final String literal : JavaLanguage.BOOLEAN_LITERALS )
196 {
197 assertEquals( JavaIdentifier.valueOf( toUpperCase( literal, 0, 1 ) ),
198 JavaIdentifier.normalize( " " + literal + " ", CAMEL_CASE ) );
199
200 }
201
202 assertEquals( JavaIdentifier.valueOf( toUpperCase( JavaLanguage.NULL_LITERAL, 0, 1 ) ),
203 JavaIdentifier.normalize( " " + JavaLanguage.NULL_LITERAL + " ", CAMEL_CASE ) );
204
205 assertInvalidJavaIdentifier( "", CAMEL_CASE );
206 assertInvalidJavaIdentifier( "@", CAMEL_CASE );
207 assertInvalidJavaIdentifier( " ", CAMEL_CASE );
208 }
209
210 @Test
211 public final void UpperCaseNormalization() throws Exception
212 {
213 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
214 JavaIdentifier.normalize( "test test test ", UPPER_CASE ) );
215
216 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
217 JavaIdentifier.normalize( " test test test ", UPPER_CASE ) );
218
219 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
220 JavaIdentifier.normalize( " test test test ", UPPER_CASE ) );
221
222 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
223 JavaIdentifier.normalize( " Test test test ", UPPER_CASE ) );
224
225 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
226 JavaIdentifier.normalize( " Test test test ", UPPER_CASE ) );
227
228 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
229 JavaIdentifier.normalize( "test_test_test ", UPPER_CASE ) );
230
231 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
232 JavaIdentifier.normalize( " test_test_test ", UPPER_CASE ) );
233
234 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
235 JavaIdentifier.normalize( "_test _test _test_", UPPER_CASE ) );
236
237 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
238 JavaIdentifier.normalize( " _test _test _test_ ", UPPER_CASE ) );
239
240 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
241 JavaIdentifier.normalize( "TEST_TEST_TEST", UPPER_CASE ) );
242
243 for ( final String keyword : JavaLanguage.KEYWORDS )
244 {
245 assertEquals( JavaIdentifier.valueOf( toUpperCase( keyword ) ),
246 JavaIdentifier.normalize( " " + keyword + " ", UPPER_CASE ) );
247
248 }
249
250 for ( final String literal : JavaLanguage.BOOLEAN_LITERALS )
251 {
252 assertEquals( JavaIdentifier.valueOf( toUpperCase( literal ) ),
253 JavaIdentifier.normalize( " " + literal + " ", UPPER_CASE ) );
254
255 }
256
257 assertEquals( JavaIdentifier.valueOf( toUpperCase( JavaLanguage.NULL_LITERAL ) ),
258 JavaIdentifier.normalize( " " + JavaLanguage.NULL_LITERAL + " ", UPPER_CASE ) );
259
260 assertInvalidJavaIdentifier( "", UPPER_CASE );
261 assertInvalidJavaIdentifier( "@", UPPER_CASE );
262 assertInvalidJavaIdentifier( " ", UPPER_CASE );
263 }
264
265 @Test
266 public final void LowerCaseNormalization() throws Exception
267 {
268 assertEquals( JavaIdentifier.valueOf( "test_test_test" ),
269 JavaIdentifier.normalize( "test test test ", LOWER_CASE ) );
270
271 assertEquals( JavaIdentifier.valueOf( "test_test_test" ),
272 JavaIdentifier.normalize( " test test test ", LOWER_CASE ) );
273
274 assertEquals( JavaIdentifier.valueOf( "test_test_test" ),
275 JavaIdentifier.normalize( " test test test ", LOWER_CASE ) );
276
277 assertEquals( JavaIdentifier.valueOf( "test_test_test" ),
278 JavaIdentifier.normalize( " Test test test ", LOWER_CASE ) );
279
280 assertEquals( JavaIdentifier.valueOf( "test_test_test" ),
281 JavaIdentifier.normalize( " Test test test ", LOWER_CASE ) );
282
283 assertEquals( JavaIdentifier.valueOf( "test_test_test" ),
284 JavaIdentifier.normalize( "TEST_TEST_TEST ", LOWER_CASE ) );
285
286 assertEquals( JavaIdentifier.valueOf( "test_test_test" ),
287 JavaIdentifier.normalize( " TEST_TEST_TEST ", LOWER_CASE ) );
288
289 assertEquals( JavaIdentifier.valueOf( "test_test_test" ),
290 JavaIdentifier.normalize( "_TEST _TEST _TEST_", LOWER_CASE ) );
291
292 assertEquals( JavaIdentifier.valueOf( "test_test_test" ),
293 JavaIdentifier.normalize( " _TEST _TEST _TEST_ ", LOWER_CASE ) );
294
295 assertEquals( JavaIdentifier.valueOf( "test_test_test" ),
296 JavaIdentifier.normalize( "test_test_test", LOWER_CASE ) );
297
298 for ( final String keyword : JavaLanguage.KEYWORDS )
299 {
300 assertEquals( JavaIdentifier.valueOf( "_" + toLowerCase( keyword ) ),
301 JavaIdentifier.normalize( " " + keyword + " ", LOWER_CASE ) );
302 }
303
304 for ( final String literal : JavaLanguage.BOOLEAN_LITERALS )
305 {
306 assertEquals( JavaIdentifier.valueOf( "_" + toLowerCase( literal ) ),
307 JavaIdentifier.normalize( " " + literal + " ", LOWER_CASE ) );
308
309 }
310
311 assertEquals( JavaIdentifier.valueOf( "_" + toLowerCase( JavaLanguage.NULL_LITERAL ) ),
312 JavaIdentifier.normalize( " " + JavaLanguage.NULL_LITERAL + " ", LOWER_CASE ) );
313
314 assertInvalidJavaIdentifier( "", LOWER_CASE );
315 assertInvalidJavaIdentifier( "@", LOWER_CASE );
316 assertInvalidJavaIdentifier( " ", LOWER_CASE );
317 }
318
319 @Test
320 public final void ConstantNameNormalization() throws Exception
321 {
322 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
323 JavaIdentifier.normalize( "test test test ", CONSTANT_NAME_CONVENTION ) );
324
325 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
326 JavaIdentifier.normalize( " test test test ", CONSTANT_NAME_CONVENTION ) );
327
328 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
329 JavaIdentifier.normalize( " test test test ", CONSTANT_NAME_CONVENTION ) );
330
331 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
332 JavaIdentifier.normalize( " Test test test ", CONSTANT_NAME_CONVENTION ) );
333
334 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
335 JavaIdentifier.normalize( " Test test test ", CONSTANT_NAME_CONVENTION ) );
336
337 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
338 JavaIdentifier.normalize( "test_test_test ", CONSTANT_NAME_CONVENTION ) );
339
340 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
341 JavaIdentifier.normalize( " test_test_test ", CONSTANT_NAME_CONVENTION ) );
342
343 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
344 JavaIdentifier.normalize( "_test _test _test_", CONSTANT_NAME_CONVENTION ) );
345
346 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
347 JavaIdentifier.normalize( " _test _test _test_ ", CONSTANT_NAME_CONVENTION ) );
348
349 assertEquals( JavaIdentifier.valueOf( "TEST_TEST_TEST" ),
350 JavaIdentifier.normalize( "TEST_TEST_TEST", CONSTANT_NAME_CONVENTION ) );
351
352 for ( final String keyword : JavaLanguage.KEYWORDS )
353 {
354 assertEquals( JavaIdentifier.valueOf( toUpperCase( keyword ) ),
355 JavaIdentifier.normalize( " " + keyword + " ", CONSTANT_NAME_CONVENTION ) );
356
357 }
358
359 for ( final String literal : JavaLanguage.BOOLEAN_LITERALS )
360 {
361 assertEquals( JavaIdentifier.valueOf( toUpperCase( literal ) ),
362 JavaIdentifier.normalize( " " + literal + " ", CONSTANT_NAME_CONVENTION ) );
363
364 }
365
366 assertEquals( JavaIdentifier.valueOf( toUpperCase( JavaLanguage.NULL_LITERAL ) ),
367 JavaIdentifier.normalize( " " + JavaLanguage.NULL_LITERAL + " ", CONSTANT_NAME_CONVENTION ) );
368
369 assertInvalidJavaIdentifier( "", CONSTANT_NAME_CONVENTION );
370 assertInvalidJavaIdentifier( "@", CONSTANT_NAME_CONVENTION );
371 assertInvalidJavaIdentifier( " ", CONSTANT_NAME_CONVENTION );
372 }
373
374 @Test
375 public final void MethodNameNormalization() throws Exception
376 {
377 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
378 JavaIdentifier.normalize( "test test test ", METHOD_NAME_CONVENTION ) );
379
380 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
381 JavaIdentifier.normalize( "test_test_test", METHOD_NAME_CONVENTION ) );
382
383 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
384 JavaIdentifier.normalize( " test_test_test ", METHOD_NAME_CONVENTION ) );
385
386 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
387 JavaIdentifier.normalize( " test test test ", METHOD_NAME_CONVENTION ) );
388
389 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
390 JavaIdentifier.normalize( " test test test ", METHOD_NAME_CONVENTION ) );
391
392 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
393 JavaIdentifier.normalize( " Test test test ", METHOD_NAME_CONVENTION ) );
394
395 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
396 JavaIdentifier.normalize( " Test test test ", METHOD_NAME_CONVENTION ) );
397
398 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
399 JavaIdentifier.normalize( "Test test test ", METHOD_NAME_CONVENTION ) );
400
401 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
402 JavaIdentifier.normalize( "tEST tEST tEST ", METHOD_NAME_CONVENTION ) );
403
404 assertEquals( JavaIdentifier.valueOf( "test" ),
405 JavaIdentifier.normalize( "TEST", METHOD_NAME_CONVENTION ) );
406
407 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
408 JavaIdentifier.normalize( "TestTestTest", METHOD_NAME_CONVENTION ) );
409
410 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
411 JavaIdentifier.normalize( "testTestTest", METHOD_NAME_CONVENTION ) );
412
413 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
414 JavaIdentifier.normalize( "Test TeSt Test", METHOD_NAME_CONVENTION ) );
415
416 assertEquals( JavaIdentifier.valueOf( "teStTeStTeStx" ),
417 JavaIdentifier.normalize( "TeStTeStTeStX", METHOD_NAME_CONVENTION ) );
418
419 assertEquals( JavaIdentifier.valueOf( "testtesttestTesttesttest" ),
420 JavaIdentifier.normalize( "TeStTeStTeSt TeStTeStTeSt", METHOD_NAME_CONVENTION ) );
421
422 for ( final String keyword : JavaLanguage.KEYWORDS )
423 {
424 assertEquals( JavaIdentifier.valueOf( "_" + keyword ),
425 JavaIdentifier.normalize( " " + keyword + " ", METHOD_NAME_CONVENTION ) );
426
427 }
428
429 for ( final String literal : JavaLanguage.BOOLEAN_LITERALS )
430 {
431 assertEquals( JavaIdentifier.valueOf( "_" + literal ),
432 JavaIdentifier.normalize( " " + literal + " ", METHOD_NAME_CONVENTION ) );
433
434 }
435
436 assertEquals( JavaIdentifier.valueOf( "_" + JavaLanguage.NULL_LITERAL ),
437 JavaIdentifier.normalize( " " + JavaLanguage.NULL_LITERAL + " ", METHOD_NAME_CONVENTION ) );
438
439 assertInvalidJavaIdentifier( "", METHOD_NAME_CONVENTION );
440 assertInvalidJavaIdentifier( "@", METHOD_NAME_CONVENTION );
441 assertInvalidJavaIdentifier( " ", METHOD_NAME_CONVENTION );
442 }
443
444 @Test
445 public final void VariableNameNormalization() throws Exception
446 {
447 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
448 JavaIdentifier.normalize( "test test test ", VARIABLE_NAME_CONVENTION ) );
449
450 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
451 JavaIdentifier.normalize( "test_test_test", VARIABLE_NAME_CONVENTION ) );
452
453 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
454 JavaIdentifier.normalize( " test_test_test ", VARIABLE_NAME_CONVENTION ) );
455
456 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
457 JavaIdentifier.normalize( " test test test ", VARIABLE_NAME_CONVENTION ) );
458
459 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
460 JavaIdentifier.normalize( " test test test ", VARIABLE_NAME_CONVENTION ) );
461
462 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
463 JavaIdentifier.normalize( " Test test test ", VARIABLE_NAME_CONVENTION ) );
464
465 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
466 JavaIdentifier.normalize( " Test test test ", VARIABLE_NAME_CONVENTION ) );
467
468 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
469 JavaIdentifier.normalize( "Test test test ", VARIABLE_NAME_CONVENTION ) );
470
471 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
472 JavaIdentifier.normalize( "tEST tEST tEST ", VARIABLE_NAME_CONVENTION ) );
473
474 assertEquals( JavaIdentifier.valueOf( "test" ),
475 JavaIdentifier.normalize( "TEST", VARIABLE_NAME_CONVENTION ) );
476
477 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
478 JavaIdentifier.normalize( "TestTestTest", VARIABLE_NAME_CONVENTION ) );
479
480 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
481 JavaIdentifier.normalize( "testTestTest", VARIABLE_NAME_CONVENTION ) );
482
483 assertEquals( JavaIdentifier.valueOf( "testTestTest" ),
484 JavaIdentifier.normalize( "test TeSt Test", VARIABLE_NAME_CONVENTION ) );
485
486 assertEquals( JavaIdentifier.valueOf( "teStTeStTeStx" ),
487 JavaIdentifier.normalize( "TeStTeStTeStX", VARIABLE_NAME_CONVENTION ) );
488
489 assertEquals( JavaIdentifier.valueOf( "testtesttestTesttesttest" ),
490 JavaIdentifier.normalize( "TeStTeStTeSt TeStTeStTeSt", VARIABLE_NAME_CONVENTION ) );
491
492 for ( final String keyword : JavaLanguage.KEYWORDS )
493 {
494 assertEquals( JavaIdentifier.valueOf( "_" + keyword ),
495 JavaIdentifier.normalize( " " + keyword + " ", VARIABLE_NAME_CONVENTION ) );
496
497 }
498
499 for ( final String literal : JavaLanguage.BOOLEAN_LITERALS )
500 {
501 assertEquals( JavaIdentifier.valueOf( "_" + literal ),
502 JavaIdentifier.normalize( " " + literal + " ", VARIABLE_NAME_CONVENTION ) );
503
504 }
505
506 assertEquals( JavaIdentifier.valueOf( "_" + JavaLanguage.NULL_LITERAL ),
507 JavaIdentifier.normalize( " " + JavaLanguage.NULL_LITERAL + " ", VARIABLE_NAME_CONVENTION ) );
508
509 assertInvalidJavaIdentifier( "", VARIABLE_NAME_CONVENTION );
510 assertInvalidJavaIdentifier( "@", VARIABLE_NAME_CONVENTION );
511 assertInvalidJavaIdentifier( " ", VARIABLE_NAME_CONVENTION );
512 }
513
514 @Test
515 public final void Deserializable() throws Exception
516 {
517 ObjectInputStream in = null;
518
519 try
520 {
521 in = new ObjectInputStream( this.getClass().getResourceAsStream(
522 ABSOLUTE_RESOURCE_NAME_PREFIX + "JavaIdentifier.ser" ) );
523
524 final JavaIdentifier javaIdentifier = (JavaIdentifier) in.readObject();
525 assertEquals( "Java", javaIdentifier.toString() );
526 System.out.println( javaIdentifier );
527 }
528 finally
529 {
530 in.close();
531 }
532 }
533
534 private static void assertInvalidJavaIdentifier( final String identifier )
535 {
536 try
537 {
538 JavaIdentifier.parse( identifier );
539 fail( "Expected 'ParseException' not thrown parsing Java identifier '" + identifier + "'." );
540 }
541 catch ( final ParseException e )
542 {
543 assertNotNull( e.getMessage() );
544 System.out.println( e.getMessage() );
545 }
546
547 try
548 {
549 JavaIdentifier.valueOf( identifier );
550 fail( "Expected 'IllegalArgumentException' not thrown parsing Java identifier '" + identifier + "'." );
551 }
552 catch ( final IllegalArgumentException e )
553 {
554 assertNotNull( e.getMessage() );
555 System.out.println( e.getMessage() );
556 }
557 }
558
559 private static void assertInvalidJavaIdentifier( final String identifier,
560 final JavaIdentifier.NormalizationMode mode )
561 {
562 try
563 {
564 JavaIdentifier.normalize( identifier, mode );
565 fail( "Expected 'ParseException' not thrown normalizing Java identifier '" + identifier + "'." );
566 }
567 catch ( final ParseException e )
568 {
569 assertNotNull( e.getMessage() );
570 System.out.println( e.getMessage() );
571 }
572 }
573
574 private static String toUpperCase( final String string )
575 {
576 final char[] c = string.toCharArray();
577
578 for ( int i = c.length - 1; i >= 0; i-- )
579 {
580 c[i] = Character.toUpperCase( c[i] );
581 }
582
583 return String.valueOf( c );
584 }
585
586 private static String toUpperCase( final String string, final int offset, final int count )
587 {
588 final int limit = offset + count;
589
590 if ( string == null )
591 {
592 throw new NullPointerException( "string" );
593 }
594 if ( offset < 0 || offset >= string.length() )
595 {
596 throw new StringIndexOutOfBoundsException();
597 }
598 if ( count < 0 || limit >= string.length() )
599 {
600 throw new StringIndexOutOfBoundsException();
601 }
602
603 final char[] c = string.toCharArray();
604
605 for ( int i = c.length - 1; i >= 0; i-- )
606 {
607 if ( i >= offset && i < limit )
608 {
609 c[i] = Character.toUpperCase( c[i] );
610 }
611 }
612
613 return String.valueOf( c );
614 }
615
616 private static String toLowerCase( final String string )
617 {
618 final char[] c = string.toCharArray();
619
620 for ( int i = c.length - 1; i >= 0; i-- )
621 {
622 c[i] = Character.toLowerCase( c[i] );
623 }
624
625 return String.valueOf( c );
626 }
627
628 }