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