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