binding/mdsal-binding-generator-impl/src/test/java/org/opendaylight/mdsal/binding/generator/impl/UsesTest.java

   1 /*
   2  * Copyright (c) 2016 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.generator.impl;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.opendaylight.mdsal.binding.generator.impl.SupportTestUtil.containsInterface;
  13 import static org.opendaylight.mdsal.binding.generator.impl.SupportTestUtil.containsMethods;
  14
  15 import java.util.List;
  16 import org.junit.Test;
  17 import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
  18 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
  19 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  20
  21 public class UsesTest {
  22     @Test
  23     public void usesInGroupingDependenciesTest() {
  24         final List<GeneratedType> genTypes = DefaultBindingGenerator.generateFor(YangParserTestUtils.parseYangResource(
  25                 "/uses-of-grouping/uses-of-grouping-dependencies.yang"));
  26         GeneratedType groupingU = null;
  27         GeneratedType groupingX = null;
  28         GeneratedType groupingV = null;
  29
  30         int groupingUCounter = 0;
  31         int groupingXCounter = 0;
  32         int groupingVCounter = 0;
  33
  34         for (GeneratedType genType : genTypes) {
  35             if (!(genType instanceof GeneratedTransferObject)) {
  36                 if (genType.getName().equals("GroupingU")) {
  37                     groupingU = genType;
  38                     groupingUCounter++;
  39                 } else if (genType.getName().equals("GroupingV")) {
  40                     groupingV = genType;
  41                     groupingVCounter++;
  42                 } else if (genType.getName().equals("GroupingX")) {
  43                     groupingX = genType;
  44                     groupingXCounter++;
  45                 }
  46             }
  47         }
  48
  49         assertNotNull("Generated type for grouping-U wasn't generated.", groupingU);
  50         assertEquals("GroupingU interface generated more than one time.", 1, groupingUCounter);
  51         assertEquals("GroupingU is in wrong package.",
  52                 "org.opendaylight.yang.gen.v1.urn.grouping.dependencies.rev130718", groupingU.getPackageName());
  53
  54         assertNotNull("Generated type for grouping-V wasn't generated.", groupingV);
  55         assertEquals("GroupingV interface generated more than one time.", 1, groupingVCounter);
  56         assertEquals("GroupingV is in wrong package.",
  57                 "org.opendaylight.yang.gen.v1.urn.grouping.dependencies.rev130718", groupingV.getPackageName());
  58
  59         assertNotNull("Generated type for grouping-X wasn't generated.", groupingX);
  60         assertEquals("GroupingX interface generated more than one time.", 1, groupingXCounter);
  61         assertEquals("GroupingX is in wrong package.",
  62                 "org.opendaylight.yang.gen.v1.urn.grouping.dependencies.rev130718", groupingX.getPackageName());
  63
  64         containsInterface("GroupingV", groupingU);
  65         containsInterface("GroupingX", groupingU);
  66         containsInterface("GroupingZ", groupingV);
  67         containsInterface("GroupingZZ", groupingV);
  68         containsInterface("GroupingY", groupingX);
  69     }
  70
  71     @Test
  72     public void usesInCaseTest() {
  73         final List<GeneratedType> genTypes = DefaultBindingGenerator.generateFor(YangParserTestUtils.parseYangResource(
  74                 "/uses-of-grouping/uses-of-grouping-case.yang"));
  75
  76         GeneratedType groupingCaseTest = null;
  77         int groupingCaseTestCounter = 0;
  78         GeneratedType caseC = null;
  79         int caseCCounter = 0;
  80         for (GeneratedType genType : genTypes) {
  81             if (!(genType instanceof GeneratedTransferObject)) {
  82                 if (genType.getName().equals("C")) {
  83                     caseC = genType;
  84                     caseCCounter++;
  85                 } else if (genType.getName().equals("GroupingCaseTest")) {
  86                     groupingCaseTest = genType;
  87                     groupingCaseTestCounter++;
  88                 }
  89             }
  90         }
  91
  92         assertNotNull("Generated type for case C wasn't generated.", caseC);
  93         assertEquals("Case C interface generated more than one time.", 1, caseCCounter);
  94         assertEquals(
  95                 "Case C is in wrong package.",
  96                 "org.opendaylight.yang.gen.v1.urn.grouping.uses._case.rev130718.container.with.choicetest.choice.test",
  97                 caseC.getPackageName());
  98
  99         assertNotNull("Generated type for grouping-case-test wasn't generated.", groupingCaseTest);
 100         assertEquals("GroupingCaseTest interface generated more than one time.", 1, groupingCaseTestCounter);
 101         assertEquals("GroupingCaseTest is in wrong package.",
 102                 "org.opendaylight.yang.gen.v1.urn.grouping.uses._case.rev130718", groupingCaseTest.getPackageName());
 103
 104         containsInterface("GroupingCaseTest", caseC);
 105         // FIXME: split this into getter/default/static asserts
 106         assertEquals(4, caseC.getMethodDefinitions().size());
 107
 108         assertEquals("Number of method in GroupingCaseTest is incorrect", 2, groupingCaseTest.getMethodDefinitions()
 109                 .size());
 110         containsMethods(groupingCaseTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingCaseTest1",
 111                 "String"));
 112     }
 113
 114     @Test
 115     public void usesInContainerTest() {
 116         final List<GeneratedType> genTypes = DefaultBindingGenerator.generateFor(YangParserTestUtils.parseYangResource(
 117                 "/uses-of-grouping/uses-of-grouping-container.yang"));
 118
 119         int containerTestCount = 0;
 120         int groupingContainerTestCounter = 0;
 121         GeneratedType containerTest = null;
 122         GeneratedType groupingContainerTest = null;
 123
 124         for (GeneratedType genType : genTypes) {
 125             if (!(genType instanceof GeneratedTransferObject)) {
 126                 if (genType.getName().equals("GroupingContainerTest")) {
 127                     groupingContainerTest = genType;
 128                     groupingContainerTestCounter++;
 129                 } else if (genType.getName().equals("ContainerTest")) {
 130                     containerTest = genType;
 131                     containerTestCount++;
 132                 }
 133             }
 134         }
 135
 136         assertNotNull("Generated type for grouping-container-test wasn't generated", groupingContainerTest);
 137         assertEquals("GroupingContainerTest interface - incorrect number of occurences", 1,
 138                 groupingContainerTestCounter);
 139         assertEquals("GroupingContainerTest isn't in correct package",
 140                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.container.rev130718",
 141                 groupingContainerTest.getPackageName());
 142
 143         assertNotNull("Generated type for container-test wasn't generated", containerTest);
 144         assertEquals("ContainerTest interface - incorrect number of occurences", 1, containerTestCount);
 145         assertEquals("ContainerTest isn't in correct package",
 146                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.container.rev130718", containerTest.getPackageName());
 147
 148         containsInterface("GroupingContainerTest", containerTest);
 149
 150         assertEquals("Number of method in GroupingContainerTestis incorrect", 3, groupingContainerTest
 151                 .getMethodDefinitions().size());
 152         // FIXME: split this into getter/default/static asserts
 153         assertEquals(5, containerTest.getMethodDefinitions().size());
 154
 155         containsMethods(groupingContainerTest.getMethodDefinitions(), new NameTypePattern(
 156                 "getLeafGroupingContainerTest1", "String"), new NameTypePattern("getLeafGroupingContainerTest2",
 157                 "Uint8"));
 158
 159         containsMethods(containerTest.getMethodDefinitions(), new NameTypePattern("getContainerLeafTest", "String"));
 160     }
 161
 162     @Test
 163     public void usesInGroupingTest() {
 164         final List<GeneratedType> genTypes = DefaultBindingGenerator.generateFor(YangParserTestUtils.parseYangResource(
 165                 "/uses-of-grouping/uses-of-grouping-grouping.yang"));
 166
 167         int groupingTestCount = 0;
 168         int groupingGroupingTestCounter = 0;
 169         GeneratedType groupingTest = null;
 170         GeneratedType groupingGroupingTest = null;
 171
 172         for (GeneratedType genType : genTypes) {
 173             if (!(genType instanceof GeneratedTransferObject)) {
 174                 if (genType.getName().equals("GroupingGroupingTest")) {
 175                     groupingGroupingTest = genType;
 176                     groupingGroupingTestCounter++;
 177                 } else if (genType.getName().equals("GroupingTest")) {
 178                     groupingTest = genType;
 179                     groupingTestCount++;
 180                 }
 181             }
 182         }
 183
 184         assertNotNull("Generated type for grouping-grouping-test wasn't generated", groupingGroupingTest);
 185         assertEquals("GroupingGroupingTest interface - incorrect number of occurences", 1, groupingGroupingTestCounter);
 186         assertEquals("GroupingGroupingTest isn't in correct package",
 187                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.grouping.rev130718",
 188                 groupingGroupingTest.getPackageName());
 189
 190         assertNotNull("Generated type for grouping-test wasn't generated", groupingTest);
 191         assertEquals("GroupingTest interface - incorrect number of occurences", 1, groupingTestCount);
 192         assertEquals("GroupingTest isn't in correct package",
 193                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.grouping.rev130718", groupingTest.getPackageName());
 194
 195         containsInterface("GroupingGroupingTest", groupingTest);
 196
 197         assertEquals("Number of method in GroupingGroupingTest is incorrect", 2, groupingGroupingTest
 198                 .getMethodDefinitions().size());
 199         assertEquals("Number of method in GroupingTest is incorrect", 2, groupingTest.getMethodDefinitions().size());
 200
 201         containsMethods(groupingGroupingTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingGrouping",
 202                 "String"));
 203
 204         containsMethods(groupingTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingTest", "Byte"));
 205     }
 206
 207     @Test
 208     public void usesInListTest() {
 209         final List<GeneratedType> genTypes = DefaultBindingGenerator.generateFor(YangParserTestUtils.parseYangResource(
 210                 "/uses-of-grouping/uses-of-grouping-list.yang"));
 211
 212         int listTestCounter = 0;
 213         int groupingListTestCounter = 0;
 214         int containerGroupingListTestCounter = 0;
 215         int listGroupingListTestCounter = 0;
 216         GeneratedType listTest = null;
 217         GeneratedType groupingListTest = null;
 218         GeneratedType containerGroupingListTest = null;
 219         GeneratedType listGroupingListTest = null;
 220
 221         for (GeneratedType genType : genTypes) {
 222             if (!(genType instanceof GeneratedTransferObject)) {
 223                 if (genType.getName().equals("GroupingListTest")) {
 224                     groupingListTest = genType;
 225                     groupingListTestCounter++;
 226                 } else if (genType.getName().equals("ListTest")) {
 227                     listTest = genType;
 228                     listTestCounter++;
 229                 } else if (genType.getName().equals("ContainerGroupingListTest")) {
 230                     containerGroupingListTest = genType;
 231                     containerGroupingListTestCounter++;
 232                 } else if (genType.getName().equals("ListGroupingListTest")) {
 233                     listGroupingListTest = genType;
 234                     listGroupingListTestCounter++;
 235                 }
 236             }
 237         }
 238
 239         assertNotNull("Generated type for grouping-list-test wasn't generated", groupingListTest);
 240         assertEquals("GroupingListTest interface - incorrect number of occurences", 1, groupingListTestCounter);
 241         assertEquals("GroupingListTest isn't in correct package",
 242                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev130718", groupingListTest.getPackageName());
 243
 244         assertNotNull("Generated type for list-test wasn't generated", listTest);
 245         assertEquals("ListTest interface - incorrect number of occurences", 1, listTestCounter);
 246         assertEquals("ListTest isn't in correct package",
 247                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev130718", listTest.getPackageName());
 248
 249         assertNotNull("Generated type for container-grouping-list-test wasn't generated", containerGroupingListTest);
 250         assertEquals("ContainerGroupingListTest interface - incorrect number of occurences", 1,
 251                 containerGroupingListTestCounter);
 252         assertEquals("ContainerGroupingListTest isn't in correct package",
 253                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev130718.grouping.list.test",
 254                 containerGroupingListTest.getPackageName());
 255
 256         assertNotNull("Generated type for list-grouping-list-test wasn't generated", listGroupingListTest);
 257         assertEquals("ListGroupingListTest interface - incorrect number of occurences", 1, listGroupingListTestCounter);
 258         assertEquals("ListGroupingListTest isn't in correct package",
 259                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev130718.grouping.list.test",
 260                 listGroupingListTest.getPackageName());
 261
 262         containsInterface("GroupingListTest", listTest);
 263
 264         assertEquals("Number of method in GroupingListTest is incorrect", 6, groupingListTest.getMethodDefinitions()
 265                 .size());
 266         // FIXME: split this into getter/default/static asserts
 267         assertEquals(5, listTest.getMethodDefinitions().size());
 268         // FIXME: split this into getter/default/static asserts
 269         assertEquals(5, containerGroupingListTest.getMethodDefinitions().size());
 270         // FIXME: split this into getter/default/static asserts
 271         assertEquals(5, listGroupingListTest.getMethodDefinitions().size());
 272
 273         containsMethods(groupingListTest.getMethodDefinitions(), new NameTypePattern("getContainerGroupingListTest",
 274                 "ContainerGroupingListTest"), new NameTypePattern("getLeafGroupingListTest", "String"),
 275                 new NameTypePattern("getLeaffllistGroupingListTest", "List<String>"), new NameTypePattern(
 276                         "getListGroupingListTest", "List<ListGroupingListTest>"));
 277         containsMethods(listTest.getMethodDefinitions(), new NameTypePattern("getListLeafTest", "String"));
 278         containsMethods(containerGroupingListTest.getMethodDefinitions(), new NameTypePattern(
 279                 "getLeafContainerGroupingListTest", "Uint8"));
 280         containsMethods(listGroupingListTest.getMethodDefinitions(), new NameTypePattern("getLeafListGroupingListTest",
 281                 "Integer"));
 282     }
 283
 284     @Test
 285     public void usesInModulTest() {
 286         final List<GeneratedType> genTypes = DefaultBindingGenerator.generateFor(YangParserTestUtils.parseYangResource(
 287                 "/uses-of-grouping/uses-of-grouping-modul.yang"));
 288
 289         int groupingModulTestCounter = 0;
 290         int groupingUsesModulDataCounter = 0;
 291         GeneratedType groupingModulTest = null;
 292         GeneratedType groupingUsesModulData = null;
 293
 294         for (GeneratedType genType : genTypes) {
 295             if (!(genType instanceof GeneratedTransferObject)) {
 296                 if (genType.getName().equals("GroupingModulTest")) {
 297                     groupingModulTest = genType;
 298                     groupingModulTestCounter++;
 299                 } else if (genType.getName().equals("GroupingUsesModulData")) {
 300                     groupingUsesModulData = genType;
 301                     groupingUsesModulDataCounter++;
 302                 }
 303             }
 304         }
 305
 306         assertNotNull("Generated type for grouping-list-test wasn't generated", groupingModulTest);
 307         assertEquals("GroupingModulTest interface - incorrect number of occurences", 1, groupingModulTestCounter);
 308         assertEquals("GroupingModulTest isn't in correct package",
 309                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.modul.rev130718", groupingModulTest.getPackageName());
 310
 311         assertNotNull("Generated type for modul wasn't generated", groupingUsesModulData);
 312         assertEquals("GroupingUsesModulData interface - incorrect number of occurences", 1,
 313                 groupingUsesModulDataCounter);
 314         assertEquals("GroupingUsesModulData isn't in correct package",
 315                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.modul.rev130718",
 316                 groupingUsesModulData.getPackageName());
 317
 318         containsInterface("GroupingModulTest", groupingUsesModulData);
 319
 320         assertEquals("Number of method in GroupingUsesModulData is incorrect", 0, groupingUsesModulData
 321                 .getMethodDefinitions().size());
 322         assertEquals("Number of method in GroupingModulTest is incorrect", 3, groupingModulTest.getMethodDefinitions()
 323                 .size());
 324
 325         containsMethods(groupingModulTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingModulTest",
 326                 "String"), new NameTypePattern("getLeafGroupingModulTest2", "Uint8"));
 327     }
 328
 329     @Test
 330     public void usesInRpcTest() {
 331         final List<GeneratedType> genTypes = DefaultBindingGenerator.generateFor(YangParserTestUtils.parseYangResource(
 332                 "/uses-of-grouping/uses-of-grouping-rpc.yang"));
 333
 334         int rpcTestInputCounter = 0;
 335         int rpcTestOutputCounter = 0;
 336         int groupingRpcInputTestCounter = 0;
 337         int groupingRpcOutputTestCounter = 0;
 338         int containerGroupingRpcInputTestCounter = 0;
 339         GeneratedType rpcTestInput = null;
 340         GeneratedType rpcTestOutput = null;
 341         GeneratedType groupingRpcInputTest = null;
 342         GeneratedType groupingRpcOutputTest = null;
 343         GeneratedType containerGroupingRpcInputTest = null;
 344
 345         for (GeneratedType genType : genTypes) {
 346             if (!(genType instanceof GeneratedTransferObject)) {
 347                 if (genType.getName().equals("RpcTestInput")) {
 348                     rpcTestInput = genType;
 349                     rpcTestInputCounter++;
 350                 } else if (genType.getName().equals("RpcTestOutput")) {
 351                     rpcTestOutput = genType;
 352                     rpcTestOutputCounter++;
 353                 } else if (genType.getName().equals("GroupingRpcInputTest")) {
 354                     groupingRpcInputTest = genType;
 355                     groupingRpcInputTestCounter++;
 356                 } else if (genType.getName().equals("GroupingRpcOutputTest")) {
 357                     groupingRpcOutputTest = genType;
 358                     groupingRpcOutputTestCounter++;
 359                 } else if (genType.getName().equals("ContainerGroupingRpcInputTest")) {
 360                     containerGroupingRpcInputTest = genType;
 361                     containerGroupingRpcInputTestCounter++;
 362                 }
 363
 364             }
 365         }
 366
 367         assertNotNull("Generated type for RPC test input was not generated", rpcTestInput);
 368         assertEquals("RpcTestInput interface - incorrect number of occurences", 1, rpcTestInputCounter);
 369         assertEquals("RpcTestInput is not in correct package",
 370             "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev130718", rpcTestInput.getPackageName());
 371
 372         assertNotNull("Generated type for RPC test output was not generated", rpcTestOutput);
 373         assertEquals("RpcTestOutput interface - incorrect number of occurences", 1, rpcTestOutputCounter);
 374         assertEquals("RpcTestOutput is not in correct package",
 375                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev130718", rpcTestOutput.getPackageName());
 376
 377         assertNotNull("Generated type for grouping-rpc-input-test was not generated", groupingRpcInputTest);
 378         assertEquals("RpcTestOutput interface - incorrect number of occurences", 1, groupingRpcInputTestCounter);
 379         assertEquals("GroupingRpcInputTest isn't in correct package",
 380                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev130718", groupingRpcInputTest.getPackageName());
 381
 382         assertNotNull("Generated type for grouping-rpc-output-test was not generated", groupingRpcOutputTest);
 383         assertEquals("RpcTestOutput interface - incorrect number of occurences", 1, groupingRpcOutputTestCounter);
 384         assertEquals("GroupingRpcOutputTest isn't in correct package",
 385                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev130718", groupingRpcOutputTest.getPackageName());
 386
 387         assertNotNull("Generated type for container-grouping-rpc-input-test wasn't generated",
 388                 containerGroupingRpcInputTest);
 389         assertEquals("ContainerGroupingRpcInputTest interface - incorrect number of occurences", 1,
 390                 containerGroupingRpcInputTestCounter);
 391         assertEquals("ContainerGroupingRpcInputTest is not in correct package",
 392                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev130718.grouping.rpc.input.test",
 393                 containerGroupingRpcInputTest.getPackageName());
 394
 395         containsInterface("GroupingRpcInputTest", rpcTestInput);
 396         containsInterface("GroupingRpcOutputTest", rpcTestOutput);
 397
 398         // FIXME: split this into getter/default/static asserts
 399         assertEquals(4, rpcTestInput.getMethodDefinitions().size());
 400         // FIXME: split this into getter/default/static asserts
 401         assertEquals(4, rpcTestOutput.getMethodDefinitions().size());
 402         assertEquals("Number of method in GroupingRpcInputTest is incorrect", 3, groupingRpcInputTest
 403                 .getMethodDefinitions().size());
 404         assertEquals("Number of method in GroupingRpcOutputTest is incorrect", 2, groupingRpcOutputTest
 405                 .getMethodDefinitions().size());
 406         // FIXME: split this into getter/default/static asserts
 407         assertEquals(5, containerGroupingRpcInputTest.getMethodDefinitions().size());
 408
 409         containsMethods(groupingRpcInputTest.getMethodDefinitions(), new NameTypePattern(
 410                 "getContainerGroupingRpcInputTest", "ContainerGroupingRpcInputTest"), new NameTypePattern(
 411                 "getLeaflistGroupingRpcInputTest", "List<Uint8>"));
 412         containsMethods(groupingRpcOutputTest.getMethodDefinitions(), new NameTypePattern(
 413                 "getLeafGroupingRpcOutputTest", "Byte"));
 414         containsMethods(containerGroupingRpcInputTest.getMethodDefinitions(), new NameTypePattern(
 415                 "getLeafContainerGroupingRpcInputTest", "String"));
 416     }
 417
 418     @Test
 419     public void usesInAugmentTest() {
 420         final List<GeneratedType> genTypes = DefaultBindingGenerator.generateFor(
 421             YangParserTestUtils.parseYangResource("/uses-of-grouping/uses-of-grouping-augment.yang"));
 422
 423         GeneratedType containerAugment1 = null;
 424         GeneratedType groupingAugmentTest = null;
 425         int containerAugment1Counter = 0;
 426         int groupingAugmentTestCounter = 0;
 427
 428         for (GeneratedType genType : genTypes) {
 429             if (!(genType instanceof GeneratedTransferObject)) {
 430                 if (genType.getName().equals("ContainerAugment1")) {
 431                     containerAugment1 = genType;
 432                     containerAugment1Counter++;
 433                 } else if (genType.getName().equals("GroupingAugmentTest")) {
 434                     groupingAugmentTest = genType;
 435                     groupingAugmentTestCounter++;
 436                 }
 437             }
 438         }
 439
 440         assertNotNull("Generated type for augment /container-augment wasn't generated.", containerAugment1);
 441         assertEquals("ContainerAugment1 interface generated more than one time.", 1, containerAugment1Counter);
 442         assertEquals("ContainerAugment1 is in wrong package.",
 443                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.augment.rev130718", containerAugment1.getPackageName());
 444
 445         assertNotNull("Generated type for grouping-augment-test wasn't generated.", groupingAugmentTest);
 446         assertEquals("GroupingAugmentTest interface generated more than one time.", 1, groupingAugmentTestCounter);
 447         assertEquals("groupingAugmentTest is in wrong package.",
 448                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.augment.rev130718",
 449                 groupingAugmentTest.getPackageName());
 450
 451         containsInterface("GroupingAugmentTest", containerAugment1);
 452
 453         // FIXME: split this into getter/default/static asserts
 454         assertEquals(4, containerAugment1.getMethodDefinitions().size());
 455         // FIXME: split this into getter/default/static asserts
 456         assertEquals(4, containerAugment1.getMethodDefinitions().size());
 457         assertEquals("Number of method in GroupingCaseTest is incorrect", 2, groupingAugmentTest.getMethodDefinitions()
 458                 .size());
 459
 460         containsMethods(groupingAugmentTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingAugmentTest",
 461                 "String"));
 462     }
 463
 464     @Test
 465     public void usesInNotification() {
 466         final List<GeneratedType> genTypes = DefaultBindingGenerator.generateFor(
 467             YangParserTestUtils.parseYangResource("/uses-of-grouping/uses-of-grouping-notification.yang"));
 468
 469         GeneratedType notificationTest = null;
 470         GeneratedType groupingNotificationTest = null;
 471         GeneratedType containerGroupingNotificationTest = null;
 472         int notificationTestCounter = 0;
 473         int groupingNotificationTestCounter = 0;
 474         int containerGroupingNotificationTestCounter = 0;
 475
 476         for (GeneratedType type : genTypes) {
 477             if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
 478                 GeneratedType genType = type;
 479                 if (genType.getName().equals("NotificationTest")) {
 480                     notificationTest = genType;
 481                     notificationTestCounter++;
 482                 } else if (genType.getName().equals("GroupingNotificationTest")) {
 483                     groupingNotificationTest = genType;
 484                     groupingNotificationTestCounter++;
 485                 } else if (genType.getName().equals("ContainerGroupingNotificationTest")) {
 486                     containerGroupingNotificationTest = genType;
 487                     containerGroupingNotificationTestCounter++;
 488                 }
 489             }
 490         }
 491
 492         assertNotNull("Generated type for notification-test wasn't generated.", notificationTest);
 493         assertEquals("NotificationTest interface generated more than one time.", 1, notificationTestCounter);
 494         assertEquals("NotificationTest is in wrong package.",
 495                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.notification.rev130718",
 496                 notificationTest.getPackageName());
 497
 498         assertNotNull("Generated type for grouping-notification-test wasn't generated.", groupingNotificationTest);
 499         assertEquals("GroupingNotificationTest interface generated more than one time.", 1,
 500                 groupingNotificationTestCounter);
 501         assertEquals("groupingNotificationTest is in wrong package.",
 502                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.notification.rev130718",
 503                 groupingNotificationTest.getPackageName());
 504
 505         assertNotNull("Generated type for container-grouping-notification-test wasn't generated.",
 506                 containerGroupingNotificationTest);
 507         assertEquals("ContainerGroupingNotificationTest interface generated more than one time.", 1,
 508                 containerGroupingNotificationTestCounter);
 509         assertEquals("ContainerGroupingNotificationTest is in wrong package.",
 510                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.notification.rev130718.grouping.notification.test",
 511                 containerGroupingNotificationTest.getPackageName());
 512
 513         containsInterface("GroupingNotificationTest", notificationTest);
 514
 515         // FIXME: split this into getter/default/static asserts
 516         assertEquals(5, notificationTest.getMethodDefinitions().size());
 517         assertEquals("Number of method in GroupingNotificationTest is incorrect", 3, groupingNotificationTest
 518                 .getMethodDefinitions().size());
 519         // FIXME: split this into getter/default/static asserts
 520         assertEquals(5, containerGroupingNotificationTest.getMethodDefinitions().size());
 521
 522         containsMethods(notificationTest.getMethodDefinitions(), new NameTypePattern("getLeafNotificationTest",
 523                 "String"));
 524         containsMethods(groupingNotificationTest.getMethodDefinitions(), new NameTypePattern(
 525                 "getContainerGroupingNotificationTest", "ContainerGroupingNotificationTest"), new NameTypePattern(
 526                 "getLeaffllistGroupingNotificationTest", "List<String>"));
 527         containsMethods(containerGroupingNotificationTest.getMethodDefinitions(), new NameTypePattern(
 528                 "getLeafContainerGroupingNotificationTest", "Uint32"));
 529     }
 530
 531 }