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