binding2/mdsal-binding2-generator-util/src/test/java/org/opendaylight/mdsal/binding/javav2/generator/util/JavaIdentifierNormalizerTest.java

   1 /*
   2  * Copyright (c) 2017 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.mdsal.binding.javav2.generator.util;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertTrue;
  13 import org.junit.Test;
  14 import org.opendaylight.mdsal.binding.javav2.util.BindingMapping;
  15
  16 public class JavaIdentifierNormalizerTest {
  17
  18     @Test
  19     public void specialPathsTest() {
  20         // QName - reserved & non reserved
  21         String normalizeIdentifier =
  22                 JavaIdentifierNormalizer.normalizeClassIdentifier("org.opendaylight.yangtools.yang.common", "QName");
  23         assertEquals("QName", normalizeIdentifier);
  24         // again reserved
  25         normalizeIdentifier =
  26                 JavaIdentifierNormalizer.normalizeClassIdentifier("org.opendaylight.yangtools.yang.common", "QName");
  27         assertEquals("QName", normalizeIdentifier);
  28         // non reserved
  29         normalizeIdentifier = JavaIdentifierNormalizer.normalizeClassIdentifier("qname.non.reserved", "QName");
  30         assertEquals("Qname", normalizeIdentifier);
  31         // again non reserved
  32         normalizeIdentifier = JavaIdentifierNormalizer.normalizeClassIdentifier("qname.non.reserved", "QName");
  33         assertEquals("Qname1", normalizeIdentifier);
  34
  35         // Augmentable - reserved & non reserved
  36         normalizeIdentifier = JavaIdentifierNormalizer
  37                 .normalizeClassIdentifier("org.opendaylight.mdsal.binding.javav2.spec.structural", "Augmentable");
  38         assertEquals("Augmentable", normalizeIdentifier);
  39         // again reserved
  40         normalizeIdentifier = JavaIdentifierNormalizer
  41                 .normalizeClassIdentifier("org.opendaylight.mdsal.binding.javav2.spec.structural", "Augmentable");
  42         assertEquals("Augmentable", normalizeIdentifier);
  43         // non reserved
  44         normalizeIdentifier = JavaIdentifierNormalizer
  45                 .normalizeClassIdentifier("augmentable.non.reserved", "Augmentable");
  46         assertEquals("Augmentable", normalizeIdentifier);
  47         // again non reserved
  48         normalizeIdentifier =
  49                 JavaIdentifierNormalizer.normalizeClassIdentifier("augmentable.non.reserved", "Augmentable");
  50         assertEquals("Augmentable1", normalizeIdentifier);
  51
  52         // List - reserved & non reserved
  53         normalizeIdentifier = JavaIdentifierNormalizer.normalizeClassIdentifier("java.util", "List");
  54         assertEquals("List", normalizeIdentifier);
  55         // again reserved
  56         normalizeIdentifier = JavaIdentifierNormalizer.normalizeClassIdentifier("java.util", "List");
  57         assertEquals("List", normalizeIdentifier);
  58         // non reserved
  59         normalizeIdentifier = JavaIdentifierNormalizer.normalizeClassIdentifier("list.non.reserved", "List");
  60         assertEquals("List", normalizeIdentifier);
  61         // again non reserved
  62         normalizeIdentifier = JavaIdentifierNormalizer.normalizeClassIdentifier("list.non.reserved", "List");
  63         assertEquals("List1", normalizeIdentifier);
  64
  65         // String - reserved & non reserved
  66         normalizeIdentifier = JavaIdentifierNormalizer.normalizeClassIdentifier("java.lang", "String");
  67         assertEquals("String", normalizeIdentifier);
  68         // again reserved
  69         normalizeIdentifier = JavaIdentifierNormalizer.normalizeClassIdentifier("java.lang", "String");
  70         assertEquals("String", normalizeIdentifier);
  71         // non reserved
  72         normalizeIdentifier = JavaIdentifierNormalizer.normalizeClassIdentifier("string.non.reserved", "String");
  73         assertEquals("String", normalizeIdentifier);
  74         // again non reserved
  75         normalizeIdentifier = JavaIdentifierNormalizer.normalizeClassIdentifier("string.non.reserved", "String");
  76         assertEquals("String1", normalizeIdentifier);
  77     }
  78
  79     /**
  80      * This test tests normalizing of enum and interface identifiers too.
  81      */
  82     @Test
  83     public void sameClassNamesSamePackageTest() {
  84         String normalizeIdentifier1 = JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.same.package", "Foo");
  85         String normalizeIdentifier2 = JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.same.package", "fOo");
  86         final String normalizeIdentifier3 =
  87                 JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.same.package", "foo");
  88         assertEquals(normalizeIdentifier1, "Foo");
  89         assertEquals(normalizeIdentifier2, "Foo1");
  90         assertEquals(normalizeIdentifier3, "Foo2");
  91
  92         normalizeIdentifier1 = JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.same.package", "*");
  93         normalizeIdentifier2 = JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.same.package", "asterisk");
  94         assertEquals(normalizeIdentifier1, "Asterisk");
  95         assertEquals(normalizeIdentifier2, "Asterisk1");
  96     }
  97
  98     /**
  99      * This test tests normalizing of enum and interface identifiers too.
 100      */
 101     @Test
 102     public void sameClassNamesOtherPackageTest() {
 103         String normalizeIdentifier1 =
 104                 JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.other.package", "Foo");
 105         String normalizeIdentifier2 =
 106                 JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.other.package.next", "fOo");
 107         final String normalizeIdentifier3 =
 108                 JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.other.package.next.next", "foo");
 109         assertEquals(normalizeIdentifier1, "Foo");
 110         assertEquals(normalizeIdentifier2, "Foo");
 111         assertEquals(normalizeIdentifier3, "Foo");
 112
 113         normalizeIdentifier1 = JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.other.package", "*");
 114         normalizeIdentifier2 =
 115                 JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.other.package.next", "asterisk");
 116         assertEquals(normalizeIdentifier1, "Asterisk");
 117         assertEquals(normalizeIdentifier2, "Asterisk");
 118     }
 119
 120     /**
 121      * This test tests normalizing of enum and interface identifiers too.
 122      */
 123     @Test
 124     public void sameClassNamesSamePackageReservedWordsTest() {
 125         final String normalizeIdentifier1 =
 126                 JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.keywords.same.package", "int");
 127         final String normalizeIdentifier2 =
 128                 JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.keywords.same.package", "InT");
 129         final String normalizeIdentifier3 =
 130                 JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.keywords.same.package", "inT");
 131         assertEquals(normalizeIdentifier1, "IntReservedKeyword");
 132         assertEquals(normalizeIdentifier2, "IntReservedKeyword1");
 133         assertEquals(normalizeIdentifier3, "IntReservedKeyword2");
 134     }
 135
 136     /**
 137      * This test tests normalizing of enum and interface identifiers too.
 138      */
 139     @Test
 140     public void sameClassNamesOtherPackageReservedWordsTest() {
 141         final String normalizeIdentifier1 =
 142                 JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.keywords.other.package", "int");
 143         final String normalizeIdentifier2 =
 144                 JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.keywords.other.package.next", "InT");
 145         final String normalizeIdentifier3 =
 146                 JavaIdentifierNormalizer.normalizeClassIdentifier("org.example.keywords.other.package.next.next", "inT");
 147         assertEquals(normalizeIdentifier1, "IntReservedKeyword");
 148         assertEquals(normalizeIdentifier2, "IntReservedKeyword");
 149         assertEquals(normalizeIdentifier3, "IntReservedKeyword");
 150     }
 151
 152     /**
 153      * This test tests converting of reserved keywords like class and interface identifiers too.
 154      */
 155     @Test
 156     public void identifierReservedKeyWordsEnumConverterTest() throws Exception {
 157         for (final String reservedKeyword : BindingMapping.JAVA_RESERVED_WORDS) {
 158             testIdentifierReservedKeywordEnum(reservedKeyword);
 159         }
 160         for (final String reservedKeyword : BindingMapping.WINDOWS_RESERVED_WORDS) {
 161             testIdentifierReservedKeywordEnum(reservedKeyword);
 162         }
 163         testIdentifierReservedKeywordEnum("iNt");
 164         testIdentifierReservedKeywordEnum("cOn");
 165     }
 166
 167     private void testIdentifierReservedKeywordEnum(final String reservedKeyword) {
 168         final StringBuilder expected =
 169                 new StringBuilder(reservedKeyword.substring(0, 1).toUpperCase())
 170                         .append(reservedKeyword.substring(1).toLowerCase())
 171                         .append("ReservedKeyword");
 172         assertTest(reservedKeyword, expected.toString(), JavaIdentifier.ENUM);
 173     }
 174
 175     /**
 176      * This test tests converting of reserved keywords like constant identifier too.
 177      */
 178     @Test
 179     public void identifierReservedKeyWordsEnumValueConverterTest() throws Exception {
 180         for (final String reservedKeyword : BindingMapping.JAVA_RESERVED_WORDS) {
 181             testIdentifierReservedKeywordEnumValue(reservedKeyword);
 182         }
 183         for (final String reservedKeyword : BindingMapping.WINDOWS_RESERVED_WORDS) {
 184             testIdentifierReservedKeywordEnumValue(reservedKeyword);
 185         }
 186         testIdentifierReservedKeywordEnumValue("iNt");
 187         testIdentifierReservedKeywordEnumValue("cOn");
 188     }
 189
 190     private void testIdentifierReservedKeywordEnumValue(final String reservedKeyword) {
 191         final StringBuilder expected = new StringBuilder(reservedKeyword.toUpperCase()).append("_RESERVED_KEYWORD");
 192         assertTest(reservedKeyword, expected.toString(), JavaIdentifier.ENUM_VALUE);
 193     }
 194
 195     /**
 196      * This test tests converting of reserved keywords like variable identifier too.
 197      */
 198     @Test
 199     public void identifierReservedKeyWordsMethodConverterTest() throws Exception {
 200         for (final String reservedKeyword : BindingMapping.JAVA_RESERVED_WORDS) {
 201             testIdentifierReservedKeywordMethod(reservedKeyword);
 202         }
 203         for (final String reservedKeyword : BindingMapping.WINDOWS_RESERVED_WORDS) {
 204             testIdentifierReservedKeywordMethod(reservedKeyword);
 205         }
 206         testIdentifierReservedKeywordMethod("iNt");
 207         testIdentifierReservedKeywordMethod("cOn");
 208     }
 209
 210     private void testIdentifierReservedKeywordMethod(final String reservedKeyword) {
 211         final StringBuilder expected = new StringBuilder(reservedKeyword.toLowerCase()).append("ReservedKeyword");
 212         assertTest(reservedKeyword, expected.toString(), JavaIdentifier.METHOD);
 213     }
 214
 215     @Test
 216     public void acceptableCharsEnumTest() throws Exception {
 217         assertTest("Acceptable", "Acceptable", JavaIdentifier.ENUM);
 218     }
 219
 220     /**
 221      * This test tests converting of class and interface identifiers too.
 222      */
 223     @Test
 224     public void nonAcceptableCharsEnumTest() throws Exception {
 225         assertTest("acceptable", "Acceptable", JavaIdentifier.ENUM);
 226         assertTest("acc*", "AccAsterisk", JavaIdentifier.ENUM);
 227         assertTest("Acc*", "AccAsterisk", JavaIdentifier.ENUM);
 228         assertTest("Acc*acc", "AccAsteriskAcc", JavaIdentifier.ENUM);
 229         assertTest("*acc", "AsteriskAcc", JavaIdentifier.ENUM);
 230         assertTest("*Acc", "AsteriskAcc", JavaIdentifier.ENUM);
 231         assertTest("*", "Asterisk", JavaIdentifier.ENUM);
 232         assertTest("\\acc", "ReverseSolidusAcc", JavaIdentifier.ENUM);
 233         assertTest("\\Acc", "ReverseSolidusAcc", JavaIdentifier.ENUM);
 234         assertTest("\\", "ReverseSolidus", JavaIdentifier.ENUM);
 235         assertTest("/acc", "SolidusAcc", JavaIdentifier.ENUM);
 236         assertTest("/Acc", "SolidusAcc", JavaIdentifier.ENUM);
 237         assertTest("/", "Solidus", JavaIdentifier.ENUM);
 238         assertTest("1acc", "DigitOneAcc", JavaIdentifier.ENUM);
 239         assertTest("1Acc", "DigitOneAcc", JavaIdentifier.ENUM);
 240         assertTest("acc1", "Acc1", JavaIdentifier.ENUM);
 241         assertTest("Acc1", "Acc1", JavaIdentifier.ENUM);
 242         assertTest("1", "DigitOne", JavaIdentifier.ENUM);
 243         assertTest("%", "PercentSign", JavaIdentifier.ENUM);
 244         assertTest("foo-bar", "FooBar", JavaIdentifier.ENUM);
 245         assertTest("foo--bar", "FooHyphenMinusHyphenMinusBar", JavaIdentifier.ENUM);
 246         assertTest("-foo", "HyphenMinusFoo", JavaIdentifier.ENUM);
 247         assertTest("--foo", "HyphenMinusHyphenMinusFoo", JavaIdentifier.ENUM);
 248         assertTest("foo-", "FooHyphenMinus", JavaIdentifier.ENUM);
 249         assertTest("foo--", "FooHyphenMinusHyphenMinus", JavaIdentifier.ENUM);
 250         assertTest("-foo-", "HyphenMinusFooHyphenMinus", JavaIdentifier.ENUM);
 251         assertTest("-foo-bar-", "HyphenMinusFooBarHyphenMinus", JavaIdentifier.ENUM);
 252         assertTest("-foo--bar-", "HyphenMinusFooHyphenMinusHyphenMinusBarHyphenMinus", JavaIdentifier.ENUM);
 253         assertTest("foo.", "FooFullStop", JavaIdentifier.ENUM);
 254         assertTest(".foo", "FullStopFoo", JavaIdentifier.ENUM);
 255         assertTest("bar.foo", "BarFullStopFoo", JavaIdentifier.ENUM);
 256     }
 257
 258     @Test
 259     public void acceptableCharsEnumValueTest() throws Exception {
 260         assertTest("ACCEPTABLE", "ACCEPTABLE", JavaIdentifier.ENUM_VALUE);
 261     }
 262
 263     /**
 264      * This test tests converting of constant identifier too.
 265      */
 266     @Test
 267     public void nonAcceptableCharsEnumValueTest() throws Exception {
 268         assertTest("acceptable", "ACCEPTABLE", JavaIdentifier.ENUM_VALUE);
 269         assertTest("Acceptable", "ACCEPTABLE", JavaIdentifier.ENUM_VALUE);
 270         assertTest("Acce_ptable", "ACCE_PTABLE", JavaIdentifier.ENUM_VALUE);
 271         assertTest("acc*", "ACC_ASTERISK", JavaIdentifier.ENUM_VALUE);
 272         assertTest("Acc*", "ACC_ASTERISK", JavaIdentifier.ENUM_VALUE);
 273         assertTest("*acc", "ASTERISK_ACC", JavaIdentifier.ENUM_VALUE);
 274         assertTest("*Acc", "ASTERISK_ACC", JavaIdentifier.ENUM_VALUE);
 275         assertTest("*", "ASTERISK", JavaIdentifier.ENUM_VALUE);
 276         assertTest("\\acc", "REVERSE_SOLIDUS_ACC", JavaIdentifier.ENUM_VALUE);
 277         assertTest("\\Acc", "REVERSE_SOLIDUS_ACC", JavaIdentifier.ENUM_VALUE);
 278         assertTest("\\", "REVERSE_SOLIDUS", JavaIdentifier.ENUM_VALUE);
 279         assertTest("/acc", "SOLIDUS_ACC", JavaIdentifier.ENUM_VALUE);
 280         assertTest("/Acc", "SOLIDUS_ACC", JavaIdentifier.ENUM_VALUE);
 281         assertTest("/", "SOLIDUS", JavaIdentifier.ENUM_VALUE);
 282         assertTest("1acc", "DIGIT_ONE_ACC", JavaIdentifier.ENUM_VALUE);
 283         assertTest("1Acc", "DIGIT_ONE_ACC", JavaIdentifier.ENUM_VALUE);
 284         assertTest("acc1", "ACC1", JavaIdentifier.ENUM_VALUE);
 285         assertTest("Acc1", "ACC1", JavaIdentifier.ENUM_VALUE);
 286         assertTest("1", "DIGIT_ONE", JavaIdentifier.ENUM_VALUE);
 287         assertTest("%", "PERCENT_SIGN", JavaIdentifier.ENUM_VALUE);
 288         assertTest("foo-bar", "FOO_BAR", JavaIdentifier.ENUM_VALUE);
 289         assertTest("foo--bar", "FOO_HYPHEN_MINUS_HYPHEN_MINUS_BAR", JavaIdentifier.ENUM_VALUE);
 290         assertTest("-foo", "HYPHEN_MINUS_FOO", JavaIdentifier.ENUM_VALUE);
 291         assertTest("--foo", "HYPHEN_MINUS_HYPHEN_MINUS_FOO", JavaIdentifier.ENUM_VALUE);
 292         assertTest("foo-", "FOO_HYPHEN_MINUS", JavaIdentifier.ENUM_VALUE);
 293         assertTest("foo--", "FOO_HYPHEN_MINUS_HYPHEN_MINUS", JavaIdentifier.ENUM_VALUE);
 294         assertTest("-foo-", "HYPHEN_MINUS_FOO_HYPHEN_MINUS", JavaIdentifier.ENUM_VALUE);
 295         assertTest("-foo-bar-", "HYPHEN_MINUS_FOO_BAR_HYPHEN_MINUS", JavaIdentifier.ENUM_VALUE);
 296         assertTest("-foo--bar-", "HYPHEN_MINUS_FOO_HYPHEN_MINUS_HYPHEN_MINUS_BAR_HYPHEN_MINUS",
 297                 JavaIdentifier.ENUM_VALUE);
 298         assertTest("foo.", "FOO_FULL_STOP", JavaIdentifier.ENUM_VALUE);
 299         assertTest(".foo", "FULL_STOP_FOO", JavaIdentifier.ENUM_VALUE);
 300         assertTest("bar.foo", "BAR_FULL_STOP_FOO", JavaIdentifier.ENUM_VALUE);
 301     }
 302
 303     @Test
 304     public void acceptableCharsMethodTest() throws Exception {
 305         assertTest("acceptable", "acceptable", JavaIdentifier.METHOD);
 306     }
 307
 308     /**
 309      * This test tests converting of variable identifier too.
 310      */
 311     @Test
 312     public void nonAcceptableCharsMethodTest() throws Exception {
 313         assertTest("acc*", "accAsterisk", JavaIdentifier.METHOD);
 314         assertTest("Acc*", "accAsterisk", JavaIdentifier.METHOD);
 315         assertTest("*acc", "asteriskAcc", JavaIdentifier.METHOD);
 316         assertTest("*Acc", "asteriskAcc", JavaIdentifier.METHOD);
 317         assertTest("*", "asterisk", JavaIdentifier.METHOD);
 318         assertTest("\\acc", "reverseSolidusAcc", JavaIdentifier.METHOD);
 319         assertTest("\\Acc", "reverseSolidusAcc", JavaIdentifier.METHOD);
 320         assertTest("\\", "reverseSolidus", JavaIdentifier.METHOD);
 321         assertTest("/acc", "solidusAcc", JavaIdentifier.METHOD);
 322         assertTest("/Acc", "solidusAcc", JavaIdentifier.METHOD);
 323         assertTest("/", "solidus", JavaIdentifier.METHOD);
 324         assertTest("1acc", "digitOneAcc", JavaIdentifier.METHOD);
 325         assertTest("1Acc", "digitOneAcc", JavaIdentifier.METHOD);
 326         assertTest("acc1", "acc1", JavaIdentifier.METHOD);
 327         assertTest("Acc1", "acc1", JavaIdentifier.METHOD);
 328         assertTest("1", "digitOne", JavaIdentifier.METHOD);
 329         assertTest("%", "percentSign", JavaIdentifier.METHOD);
 330         assertTest("foo-bar", "fooBar", JavaIdentifier.METHOD);
 331         assertTest("foo--bar", "fooHyphenMinusHyphenMinusBar", JavaIdentifier.METHOD);
 332         assertTest("-foo", "hyphenMinusFoo", JavaIdentifier.METHOD);
 333         assertTest("--foo", "hyphenMinusHyphenMinusFoo", JavaIdentifier.METHOD);
 334         assertTest("foo-", "fooHyphenMinus", JavaIdentifier.METHOD);
 335         assertTest("foo--", "fooHyphenMinusHyphenMinus", JavaIdentifier.METHOD);
 336         assertTest("-foo-", "hyphenMinusFooHyphenMinus", JavaIdentifier.METHOD);
 337         assertTest("-foo-bar-", "hyphenMinusFooBarHyphenMinus", JavaIdentifier.METHOD);
 338         assertTest("-foo--bar-", "hyphenMinusFooHyphenMinusHyphenMinusBarHyphenMinus", JavaIdentifier.METHOD);
 339         assertTest("foo.", "fooFullStop", JavaIdentifier.METHOD);
 340         assertTest(".foo", "fullStopFoo", JavaIdentifier.METHOD);
 341         assertTest("foo.bar", "fooFullStopBar", JavaIdentifier.METHOD);
 342     }
 343
 344
 345     @Test
 346     public void packageReservedKeyWordsTest() {
 347         for (final String reservedKeyword : BindingMapping.JAVA_RESERVED_WORDS) {
 348             testPackageReservedKeyword(reservedKeyword);
 349         }
 350         for (final String reservedKeyword : BindingMapping.WINDOWS_RESERVED_WORDS) {
 351             testPackageReservedKeyword(reservedKeyword);
 352         }
 353     }
 354
 355     private void testPackageReservedKeyword(final String reservedKeyword) {
 356         final String packageNameNormalizer = JavaIdentifierNormalizer.normalizePartialPackageName(reservedKeyword);
 357         final StringBuilder expected = new StringBuilder(reservedKeyword).append('_');
 358         assertEquals(expected.toString().toLowerCase(), packageNameNormalizer);
 359     }
 360
 361     @Test
 362     public void digitAtStartTest() {
 363         for (int i = 0; i < 10; i++) {
 364             final String str_i = String.valueOf(i);
 365             final String packageNameNormalizer = JavaIdentifierNormalizer.normalizePartialPackageName(str_i);
 366             final String expected = Character.getName(str_i.charAt(0)).replaceAll(" ", "").toLowerCase();
 367             assertEquals(expected.toString(), packageNameNormalizer);
 368         }
 369     }
 370
 371     @Test
 372     public void normalizePackageNameDashTest() {
 373         dashTest("foo-bar", "foo_bar");
 374         dashTest("foo--bar", "foo__bar");
 375         dashTest("-foo", "_foo");
 376         dashTest("--foo", "__foo");
 377         dashTest("foo-", "foo_");
 378         dashTest("foo--", "foo__");
 379         dashTest("-foo-bar", "_foo_bar");
 380         dashTest("foo-bar-", "foo_bar_");
 381         dashTest("-foo-bar-", "_foo_bar_");
 382         dashTest("-foo--bar-", "_foo__bar_");
 383     }
 384
 385     private void dashTest(final String tested, final String expected) {
 386         final String actual = JavaIdentifierNormalizer.normalizePartialPackageName(tested);
 387         assertEquals(expected, actual);
 388     }
 389
 390     @Test
 391     public void normalizePackageNameTest() {
 392         normalizePackageNameTest("*foo", "asteriskfoo");
 393         normalizePackageNameTest("/foo", "solidusfoo");
 394         normalizePackageNameTest("\\foo", "reversesolidusfoo");
 395         normalizePackageNameTest(":foo", "colonfoo");
 396
 397         normalizePackageNameTest("f*oo", "fasteriskoo");
 398         normalizePackageNameTest("f/oo", "fsolidusoo");
 399         normalizePackageNameTest("f\\oo", "freversesolidusoo");
 400         normalizePackageNameTest("f:oo", "fcolonoo");
 401
 402         normalizePackageNameTest("foo*", "fooasterisk");
 403         normalizePackageNameTest("foo/", "foosolidus");
 404         normalizePackageNameTest("foo\\", "fooreversesolidus");
 405         normalizePackageNameTest("foo:", "foocolon");
 406
 407         normalizePackageNameTest("_foo_", "_foo_");
 408         normalizePackageNameTest("f_oo", "f_oo");
 409     }
 410
 411     private void normalizePackageNameTest(final String tested, final Object expected) {
 412         final String packageNameNormalizer = JavaIdentifierNormalizer.normalizePartialPackageName(tested);
 413         assertEquals(expected, packageNameNormalizer);
 414     }
 415
 416     private void assertTest(final String testedIdentifier, final String acceptable,
 417             final JavaIdentifier javaTypeOfIdentifier) {
 418         final String convertedIdentifier =
 419                 JavaIdentifierNormalizer.normalizeSpecificIdentifier(testedIdentifier, javaTypeOfIdentifier);
 420         assertNotNull(convertedIdentifier);
 421         assertTrue(!convertedIdentifier.isEmpty());
 422         assertEquals(acceptable, convertedIdentifier);
 423     }
 424
 425     @Test
 426     public void realPackageNameExampleTest() {
 427         String tested = "org.opendaylight.example.test.rev000000.data.foo";
 428         String expected = "org.opendaylight.example.test.rev000000.data.foo";
 429         testRealPackageNameExample(tested, expected);
 430
 431         tested = "org.opendaylight.example.test.rev000000.data.foo*";
 432         expected = "org.opendaylight.example.test.rev000000.data.fooasterisk";
 433         testRealPackageNameExample(tested, expected);
 434
 435         tested = "org.opendaylight.example.test.rev000000.data.foo*bar";
 436         expected = "org.opendaylight.example.test.rev000000.data.fooasteriskbar";
 437         testRealPackageNameExample(tested, expected);
 438
 439         tested = "org.opendaylight.example.test.rev000000.data.foo.bar";
 440         expected = "org.opendaylight.example.test.rev000000.data.foo.bar";
 441         testRealPackageNameExample(tested, expected);
 442
 443         tested = "org.opendaylight.example.test.rev000000.data.foo-bar";
 444         expected = "org.opendaylight.example.test.rev000000.data.foo_bar";
 445         testRealPackageNameExample(tested, expected);
 446
 447         tested = "org.opendaylight.example.test.rev000000.data.foo_";
 448         expected = "org.opendaylight.example.test.rev000000.data.foo_";
 449         testRealPackageNameExample(tested, expected);
 450
 451         tested = "org.opendaylight.example.test.rev000000.data._foo";
 452         expected = "org.opendaylight.example.test.rev000000.data._foo";
 453         testRealPackageNameExample(tested, expected);
 454
 455         tested = "org.opendaylight.example.test.rev000000.data.foo*.*";
 456         expected = "org.opendaylight.example.test.rev000000.data.fooasterisk.asterisk";
 457         testRealPackageNameExample(tested, expected);
 458
 459         tested = "org.opendaylight.example.test.rev000000.data.int";
 460         expected = "org.opendaylight.example.test.rev000000.data.int_";
 461         testRealPackageNameExample(tested, expected);
 462
 463         tested = "org.opendaylight.example.test.rev000000.data.iNt";
 464         expected = "org.opendaylight.example.test.rev000000.data.int_";
 465         testRealPackageNameExample(tested, expected);
 466
 467         tested = "org.opendaylight.example.test.rev000000.data.con";
 468         expected = "org.opendaylight.example.test.rev000000.data.con_";
 469         testRealPackageNameExample(tested, expected);
 470
 471         tested = "org.opendaylight.example.test.rev000000.data.CON";
 472         expected = "org.opendaylight.example.test.rev000000.data.con_";
 473         testRealPackageNameExample(tested, expected);
 474     }
 475
 476     private void testRealPackageNameExample(final String tested, final String expected) {
 477         final String actual = JavaIdentifierNormalizer.normalizeFullPackageName(tested);
 478         assertEquals(expected, actual);
 479     }
 480 }