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