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