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