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