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