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