binding/mdsal-binding-generator/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", 3, groupingCaseTest.getMethodDefinitions()
 109                 .size());
 110         containsMethods(groupingCaseTest.getMethodDefinitions(),
 111             new NameTypePattern("getLeafGroupingCaseTest1", "String"),
 112             new NameTypePattern("requireLeafGroupingCaseTest1", "String"));
 113     }
 114
 115     @Test
 116     public void usesInContainerTest() {
 117         final List<GeneratedType> genTypes = DefaultBindingGenerator.generateFor(YangParserTestUtils.parseYangResource(
 118                 "/uses-of-grouping/uses-of-grouping-container.yang"));
 119
 120         int containerTestCount = 0;
 121         int groupingContainerTestCounter = 0;
 122         GeneratedType containerTest = null;
 123         GeneratedType groupingContainerTest = null;
 124
 125         for (GeneratedType genType : genTypes) {
 126             if (!(genType instanceof GeneratedTransferObject)) {
 127                 if (genType.getName().equals("GroupingContainerTest")) {
 128                     groupingContainerTest = genType;
 129                     groupingContainerTestCounter++;
 130                 } else if (genType.getName().equals("ContainerTest")) {
 131                     containerTest = genType;
 132                     containerTestCount++;
 133                 }
 134             }
 135         }
 136
 137         assertNotNull("Generated type for grouping-container-test wasn't generated", groupingContainerTest);
 138         assertEquals("GroupingContainerTest interface - incorrect number of occurences", 1,
 139                 groupingContainerTestCounter);
 140         assertEquals("GroupingContainerTest isn't in correct package",
 141                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.container.rev130718",
 142                 groupingContainerTest.getPackageName());
 143
 144         assertNotNull("Generated type for container-test wasn't generated", containerTest);
 145         assertEquals("ContainerTest interface - incorrect number of occurences", 1, containerTestCount);
 146         assertEquals("ContainerTest isn't in correct package",
 147                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.container.rev130718", containerTest.getPackageName());
 148
 149         containsInterface("GroupingContainerTest", containerTest);
 150
 151         assertEquals("Number of method in GroupingContainerTestis incorrect", 5, groupingContainerTest
 152                 .getMethodDefinitions().size());
 153         // FIXME: split this into getter/default/static asserts
 154         assertEquals(6, containerTest.getMethodDefinitions().size());
 155
 156         containsMethods(groupingContainerTest.getMethodDefinitions(),
 157             new NameTypePattern("getLeafGroupingContainerTest1", "String"),
 158             new NameTypePattern("requireLeafGroupingContainerTest1", "String"),
 159             new NameTypePattern("getLeafGroupingContainerTest2", "Uint8"),
 160             new NameTypePattern("requireLeafGroupingContainerTest2", "Uint8"));
 161
 162         containsMethods(containerTest.getMethodDefinitions(),
 163             new NameTypePattern("getContainerLeafTest", "String"),
 164             new NameTypePattern("requireContainerLeafTest", "String"));
 165     }
 166
 167     @Test
 168     public void usesInGroupingTest() {
 169         final List<GeneratedType> genTypes = DefaultBindingGenerator.generateFor(YangParserTestUtils.parseYangResource(
 170                 "/uses-of-grouping/uses-of-grouping-grouping.yang"));
 171
 172         int groupingTestCount = 0;
 173         int groupingGroupingTestCounter = 0;
 174         GeneratedType groupingTest = null;
 175         GeneratedType groupingGroupingTest = null;
 176
 177         for (GeneratedType genType : genTypes) {
 178             if (!(genType instanceof GeneratedTransferObject)) {
 179                 if (genType.getName().equals("GroupingGroupingTest")) {
 180                     groupingGroupingTest = genType;
 181                     groupingGroupingTestCounter++;
 182                 } else if (genType.getName().equals("GroupingTest")) {
 183                     groupingTest = genType;
 184                     groupingTestCount++;
 185                 }
 186             }
 187         }
 188
 189         assertNotNull("Generated type for grouping-grouping-test wasn't generated", groupingGroupingTest);
 190         assertEquals("GroupingGroupingTest interface - incorrect number of occurences", 1, groupingGroupingTestCounter);
 191         assertEquals("GroupingGroupingTest isn't in correct package",
 192                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.grouping.rev130718",
 193                 groupingGroupingTest.getPackageName());
 194
 195         assertNotNull("Generated type for grouping-test wasn't generated", groupingTest);
 196         assertEquals("GroupingTest interface - incorrect number of occurences", 1, groupingTestCount);
 197         assertEquals("GroupingTest isn't in correct package",
 198                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.grouping.rev130718", groupingTest.getPackageName());
 199
 200         containsInterface("GroupingGroupingTest", groupingTest);
 201
 202         assertEquals("Number of method in GroupingGroupingTest is incorrect", 3, groupingGroupingTest
 203                 .getMethodDefinitions().size());
 204         assertEquals("Number of method in GroupingTest is incorrect", 3, groupingTest.getMethodDefinitions().size());
 205
 206         containsMethods(groupingGroupingTest.getMethodDefinitions(),
 207             new NameTypePattern("getLeafGroupingGrouping", "String"),
 208             new NameTypePattern("requireLeafGroupingGrouping", "String"));
 209
 210         containsMethods(groupingTest.getMethodDefinitions(),
 211             new NameTypePattern("getLeafGroupingTest", "Byte"),
 212             new NameTypePattern("requireLeafGroupingTest", "Byte"));
 213     }
 214
 215     @Test
 216     public void usesInListTest() {
 217         final List<GeneratedType> genTypes = DefaultBindingGenerator.generateFor(YangParserTestUtils.parseYangResource(
 218                 "/uses-of-grouping/uses-of-grouping-list.yang"));
 219
 220         int listTestCounter = 0;
 221         int groupingListTestCounter = 0;
 222         int containerGroupingListTestCounter = 0;
 223         int listGroupingListTestCounter = 0;
 224         GeneratedType listTest = null;
 225         GeneratedType groupingListTest = null;
 226         GeneratedType containerGroupingListTest = null;
 227         GeneratedType listGroupingListTest = null;
 228
 229         for (GeneratedType genType : genTypes) {
 230             if (!(genType instanceof GeneratedTransferObject)) {
 231                 if (genType.getName().equals("GroupingListTest")) {
 232                     groupingListTest = genType;
 233                     groupingListTestCounter++;
 234                 } else if (genType.getName().equals("ListTest")) {
 235                     listTest = genType;
 236                     listTestCounter++;
 237                 } else if (genType.getName().equals("ContainerGroupingListTest")) {
 238                     containerGroupingListTest = genType;
 239                     containerGroupingListTestCounter++;
 240                 } else if (genType.getName().equals("ListGroupingListTest")) {
 241                     listGroupingListTest = genType;
 242                     listGroupingListTestCounter++;
 243                 }
 244             }
 245         }
 246
 247         assertNotNull("Generated type for grouping-list-test wasn't generated", groupingListTest);
 248         assertEquals("GroupingListTest interface - incorrect number of occurences", 1, groupingListTestCounter);
 249         assertEquals("GroupingListTest isn't in correct package",
 250                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev130718", groupingListTest.getPackageName());
 251
 252         assertNotNull("Generated type for list-test wasn't generated", listTest);
 253         assertEquals("ListTest interface - incorrect number of occurences", 1, listTestCounter);
 254         assertEquals("ListTest isn't in correct package",
 255                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev130718", listTest.getPackageName());
 256
 257         assertNotNull("Generated type for container-grouping-list-test wasn't generated", containerGroupingListTest);
 258         assertEquals("ContainerGroupingListTest interface - incorrect number of occurences", 1,
 259                 containerGroupingListTestCounter);
 260         assertEquals("ContainerGroupingListTest isn't in correct package",
 261                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev130718.grouping.list.test",
 262                 containerGroupingListTest.getPackageName());
 263
 264         assertNotNull("Generated type for list-grouping-list-test wasn't generated", listGroupingListTest);
 265         assertEquals("ListGroupingListTest interface - incorrect number of occurences", 1, listGroupingListTestCounter);
 266         assertEquals("ListGroupingListTest isn't in correct package",
 267                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev130718.grouping.list.test",
 268                 listGroupingListTest.getPackageName());
 269
 270         containsInterface("GroupingListTest", listTest);
 271
 272         assertEquals("Number of method in GroupingListTest is incorrect", 8, groupingListTest.getMethodDefinitions()
 273                 .size());
 274         // FIXME: split this into getter/default/static asserts
 275         assertEquals(6, listTest.getMethodDefinitions().size());
 276         // FIXME: split this into getter/default/static asserts
 277         assertEquals(6, containerGroupingListTest.getMethodDefinitions().size());
 278         // FIXME: split this into getter/default/static asserts
 279         assertEquals(6, listGroupingListTest.getMethodDefinitions().size());
 280
 281         containsMethods(groupingListTest.getMethodDefinitions(),
 282             new NameTypePattern("getContainerGroupingListTest", "ContainerGroupingListTest"),
 283             new NameTypePattern("getLeafGroupingListTest", "String"),
 284             new NameTypePattern("requireLeafGroupingListTest", "String"),
 285             new NameTypePattern("getLeaffllistGroupingListTest", "List<String>"),
 286             new NameTypePattern("requireLeaffllistGroupingListTest", "List<String>"),
 287             new NameTypePattern("getListGroupingListTest", "List<ListGroupingListTest>"));
 288         containsMethods(listTest.getMethodDefinitions(), new NameTypePattern("getListLeafTest", "String"));
 289         containsMethods(containerGroupingListTest.getMethodDefinitions(), new NameTypePattern(
 290                 "getLeafContainerGroupingListTest", "Uint8"));
 291         containsMethods(listGroupingListTest.getMethodDefinitions(), new NameTypePattern("getLeafListGroupingListTest",
 292                 "Integer"));
 293     }
 294
 295     @Test
 296     public void usesInModulTest() {
 297         final List<GeneratedType> genTypes = DefaultBindingGenerator.generateFor(YangParserTestUtils.parseYangResource(
 298                 "/uses-of-grouping/uses-of-grouping-modul.yang"));
 299
 300         int groupingModulTestCounter = 0;
 301         int groupingUsesModulDataCounter = 0;
 302         GeneratedType groupingModulTest = null;
 303         GeneratedType groupingUsesModulData = null;
 304
 305         for (GeneratedType genType : genTypes) {
 306             if (!(genType instanceof GeneratedTransferObject)) {
 307                 if (genType.getName().equals("GroupingModulTest")) {
 308                     groupingModulTest = genType;
 309                     groupingModulTestCounter++;
 310                 } else if (genType.getName().equals("GroupingUsesModulData")) {
 311                     groupingUsesModulData = genType;
 312                     groupingUsesModulDataCounter++;
 313                 }
 314             }
 315         }
 316
 317         assertNotNull("Generated type for grouping-list-test wasn't generated", groupingModulTest);
 318         assertEquals("GroupingModulTest interface - incorrect number of occurences", 1, groupingModulTestCounter);
 319         assertEquals("GroupingModulTest isn't in correct package",
 320                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.modul.rev130718", groupingModulTest.getPackageName());
 321
 322         assertNotNull("Generated type for modul wasn't generated", groupingUsesModulData);
 323         assertEquals("GroupingUsesModulData interface - incorrect number of occurences", 1,
 324                 groupingUsesModulDataCounter);
 325         assertEquals("GroupingUsesModulData isn't in correct package",
 326                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.modul.rev130718",
 327                 groupingUsesModulData.getPackageName());
 328
 329         containsInterface("GroupingModulTest", groupingUsesModulData);
 330
 331         assertEquals("Number of method in GroupingUsesModulData is incorrect", 0, groupingUsesModulData
 332                 .getMethodDefinitions().size());
 333         assertEquals("Number of method in GroupingModulTest is incorrect", 5, groupingModulTest.getMethodDefinitions()
 334                 .size());
 335
 336         containsMethods(groupingModulTest.getMethodDefinitions(),
 337             new NameTypePattern("getLeafGroupingModulTest", "String"),
 338             new NameTypePattern("requireLeafGroupingModulTest", "String"),
 339             new NameTypePattern("getLeafGroupingModulTest2", "Uint8"),
 340             new NameTypePattern("requireLeafGroupingModulTest2", "Uint8"));
 341     }
 342
 343     @Test
 344     public void usesInRpcTest() {
 345         final List<GeneratedType> genTypes = DefaultBindingGenerator.generateFor(YangParserTestUtils.parseYangResource(
 346                 "/uses-of-grouping/uses-of-grouping-rpc.yang"));
 347
 348         int rpcTestInputCounter = 0;
 349         int rpcTestOutputCounter = 0;
 350         int groupingRpcInputTestCounter = 0;
 351         int groupingRpcOutputTestCounter = 0;
 352         int containerGroupingRpcInputTestCounter = 0;
 353         GeneratedType rpcTestInput = null;
 354         GeneratedType rpcTestOutput = null;
 355         GeneratedType groupingRpcInputTest = null;
 356         GeneratedType groupingRpcOutputTest = null;
 357         GeneratedType containerGroupingRpcInputTest = null;
 358
 359         for (GeneratedType genType : genTypes) {
 360             if (!(genType instanceof GeneratedTransferObject)) {
 361                 if (genType.getName().equals("RpcTestInput")) {
 362                     rpcTestInput = genType;
 363                     rpcTestInputCounter++;
 364                 } else if (genType.getName().equals("RpcTestOutput")) {
 365                     rpcTestOutput = genType;
 366                     rpcTestOutputCounter++;
 367                 } else if (genType.getName().equals("GroupingRpcInputTest")) {
 368                     groupingRpcInputTest = genType;
 369                     groupingRpcInputTestCounter++;
 370                 } else if (genType.getName().equals("GroupingRpcOutputTest")) {
 371                     groupingRpcOutputTest = genType;
 372                     groupingRpcOutputTestCounter++;
 373                 } else if (genType.getName().equals("ContainerGroupingRpcInputTest")) {
 374                     containerGroupingRpcInputTest = genType;
 375                     containerGroupingRpcInputTestCounter++;
 376                 }
 377
 378             }
 379         }
 380
 381         assertNotNull("Generated type for RPC test input was not generated", rpcTestInput);
 382         assertEquals("RpcTestInput interface - incorrect number of occurences", 1, rpcTestInputCounter);
 383         assertEquals("RpcTestInput is not in correct package",
 384             "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev130718", rpcTestInput.getPackageName());
 385
 386         assertNotNull("Generated type for RPC test output was not generated", rpcTestOutput);
 387         assertEquals("RpcTestOutput interface - incorrect number of occurences", 1, rpcTestOutputCounter);
 388         assertEquals("RpcTestOutput is not in correct package",
 389                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev130718", rpcTestOutput.getPackageName());
 390
 391         assertNotNull("Generated type for grouping-rpc-input-test was not generated", groupingRpcInputTest);
 392         assertEquals("RpcTestOutput interface - incorrect number of occurences", 1, groupingRpcInputTestCounter);
 393         assertEquals("GroupingRpcInputTest isn't in correct package",
 394                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev130718", groupingRpcInputTest.getPackageName());
 395
 396         assertNotNull("Generated type for grouping-rpc-output-test was not generated", groupingRpcOutputTest);
 397         assertEquals("RpcTestOutput interface - incorrect number of occurences", 1, groupingRpcOutputTestCounter);
 398         assertEquals("GroupingRpcOutputTest isn't in correct package",
 399                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev130718", groupingRpcOutputTest.getPackageName());
 400
 401         assertNotNull("Generated type for container-grouping-rpc-input-test wasn't generated",
 402                 containerGroupingRpcInputTest);
 403         assertEquals("ContainerGroupingRpcInputTest interface - incorrect number of occurences", 1,
 404                 containerGroupingRpcInputTestCounter);
 405         assertEquals("ContainerGroupingRpcInputTest is not in correct package",
 406                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev130718.grouping.rpc.input.test",
 407                 containerGroupingRpcInputTest.getPackageName());
 408
 409         containsInterface("GroupingRpcInputTest", rpcTestInput);
 410         containsInterface("GroupingRpcOutputTest", rpcTestOutput);
 411
 412         // FIXME: split this into getter/default/static asserts
 413         assertEquals(4, rpcTestInput.getMethodDefinitions().size());
 414         // FIXME: split this into getter/default/static asserts
 415         assertEquals(4, rpcTestOutput.getMethodDefinitions().size());
 416         assertEquals("Number of method in GroupingRpcInputTest is incorrect", 4, groupingRpcInputTest
 417                 .getMethodDefinitions().size());
 418         assertEquals("Number of method in GroupingRpcOutputTest is incorrect", 3, groupingRpcOutputTest
 419                 .getMethodDefinitions().size());
 420         // FIXME: split this into getter/default/static asserts
 421         assertEquals(6, containerGroupingRpcInputTest.getMethodDefinitions().size());
 422
 423         containsMethods(groupingRpcInputTest.getMethodDefinitions(),
 424             new NameTypePattern("getContainerGroupingRpcInputTest", "ContainerGroupingRpcInputTest"),
 425             new NameTypePattern("getLeaflistGroupingRpcInputTest", "List<Uint8>"),
 426             new NameTypePattern("requireLeaflistGroupingRpcInputTest", "List<Uint8>"));
 427         containsMethods(groupingRpcOutputTest.getMethodDefinitions(),
 428             new NameTypePattern("getLeafGroupingRpcOutputTest", "Byte"));
 429         containsMethods(containerGroupingRpcInputTest.getMethodDefinitions(),
 430             new NameTypePattern("getLeafContainerGroupingRpcInputTest", "String"));
 431     }
 432
 433     @Test
 434     public void usesInAugmentTest() {
 435         final List<GeneratedType> genTypes = DefaultBindingGenerator.generateFor(
 436             YangParserTestUtils.parseYangResource("/uses-of-grouping/uses-of-grouping-augment.yang"));
 437
 438         GeneratedType containerAugment1 = null;
 439         GeneratedType groupingAugmentTest = null;
 440         int containerAugment1Counter = 0;
 441         int groupingAugmentTestCounter = 0;
 442
 443         for (GeneratedType genType : genTypes) {
 444             if (!(genType instanceof GeneratedTransferObject)) {
 445                 if (genType.getName().equals("ContainerAugment1")) {
 446                     containerAugment1 = genType;
 447                     containerAugment1Counter++;
 448                 } else if (genType.getName().equals("GroupingAugmentTest")) {
 449                     groupingAugmentTest = genType;
 450                     groupingAugmentTestCounter++;
 451                 }
 452             }
 453         }
 454
 455         assertNotNull("Generated type for augment /container-augment wasn't generated.", containerAugment1);
 456         assertEquals("ContainerAugment1 interface generated more than one time.", 1, containerAugment1Counter);
 457         assertEquals("ContainerAugment1 is in wrong package.",
 458                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.augment.rev130718", containerAugment1.getPackageName());
 459
 460         assertNotNull("Generated type for grouping-augment-test wasn't generated.", groupingAugmentTest);
 461         assertEquals("GroupingAugmentTest interface generated more than one time.", 1, groupingAugmentTestCounter);
 462         assertEquals("groupingAugmentTest is in wrong package.",
 463                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.augment.rev130718",
 464                 groupingAugmentTest.getPackageName());
 465
 466         containsInterface("GroupingAugmentTest", containerAugment1);
 467
 468         // FIXME: split this into getter/default/static asserts
 469         assertEquals(4, containerAugment1.getMethodDefinitions().size());
 470         // FIXME: split this into getter/default/static asserts
 471         assertEquals(4, containerAugment1.getMethodDefinitions().size());
 472         assertEquals("Number of method in GroupingCaseTest is incorrect", 3, groupingAugmentTest.getMethodDefinitions()
 473                 .size());
 474
 475         containsMethods(groupingAugmentTest.getMethodDefinitions(),
 476             new NameTypePattern("getLeafGroupingAugmentTest", "String"),
 477             new NameTypePattern("requireLeafGroupingAugmentTest", "String"));
 478     }
 479
 480     @Test
 481     public void usesInNotification() {
 482         final List<GeneratedType> genTypes = DefaultBindingGenerator.generateFor(
 483             YangParserTestUtils.parseYangResource("/uses-of-grouping/uses-of-grouping-notification.yang"));
 484
 485         GeneratedType notificationTest = null;
 486         GeneratedType groupingNotificationTest = null;
 487         GeneratedType containerGroupingNotificationTest = null;
 488         int notificationTestCounter = 0;
 489         int groupingNotificationTestCounter = 0;
 490         int containerGroupingNotificationTestCounter = 0;
 491
 492         for (GeneratedType type : genTypes) {
 493             if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
 494                 GeneratedType genType = type;
 495                 if (genType.getName().equals("NotificationTest")) {
 496                     notificationTest = genType;
 497                     notificationTestCounter++;
 498                 } else if (genType.getName().equals("GroupingNotificationTest")) {
 499                     groupingNotificationTest = genType;
 500                     groupingNotificationTestCounter++;
 501                 } else if (genType.getName().equals("ContainerGroupingNotificationTest")) {
 502                     containerGroupingNotificationTest = genType;
 503                     containerGroupingNotificationTestCounter++;
 504                 }
 505             }
 506         }
 507
 508         assertNotNull("Generated type for notification-test wasn't generated.", notificationTest);
 509         assertEquals("NotificationTest interface generated more than one time.", 1, notificationTestCounter);
 510         assertEquals("NotificationTest is in wrong package.",
 511                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.notification.rev130718",
 512                 notificationTest.getPackageName());
 513
 514         assertNotNull("Generated type for grouping-notification-test wasn't generated.", groupingNotificationTest);
 515         assertEquals("GroupingNotificationTest interface generated more than one time.", 1,
 516                 groupingNotificationTestCounter);
 517         assertEquals("groupingNotificationTest is in wrong package.",
 518                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.notification.rev130718",
 519                 groupingNotificationTest.getPackageName());
 520
 521         assertNotNull("Generated type for container-grouping-notification-test wasn't generated.",
 522                 containerGroupingNotificationTest);
 523         assertEquals("ContainerGroupingNotificationTest interface generated more than one time.", 1,
 524                 containerGroupingNotificationTestCounter);
 525         assertEquals("ContainerGroupingNotificationTest is in wrong package.",
 526                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.notification.rev130718.grouping.notification.test",
 527                 containerGroupingNotificationTest.getPackageName());
 528
 529         containsInterface("GroupingNotificationTest", notificationTest);
 530
 531         // FIXME: split this into getter/default/static asserts
 532         assertEquals(6, notificationTest.getMethodDefinitions().size());
 533         assertEquals("Number of method in GroupingNotificationTest is incorrect", 4, groupingNotificationTest
 534                 .getMethodDefinitions().size());
 535         // FIXME: split this into getter/default/static asserts
 536         assertEquals(6, containerGroupingNotificationTest.getMethodDefinitions().size());
 537
 538         containsMethods(notificationTest.getMethodDefinitions(),
 539             new NameTypePattern("getLeafNotificationTest",  "String"));
 540         containsMethods(groupingNotificationTest.getMethodDefinitions(),
 541             new NameTypePattern("getContainerGroupingNotificationTest", "ContainerGroupingNotificationTest"),
 542             new NameTypePattern("getLeaffllistGroupingNotificationTest", "List<String>"),
 543             new NameTypePattern("requireLeaffllistGroupingNotificationTest", "List<String>"));
 544         containsMethods(containerGroupingNotificationTest.getMethodDefinitions(),
 545             new NameTypePattern("getLeafContainerGroupingNotificationTest", "Uint32"),
 546             new NameTypePattern("requireLeafContainerGroupingNotificationTest", "Uint32"));
 547     }
 548
 549 }