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