binding/mdsal-binding-generator-impl/src/test/java/org/opendaylight/yangtools/sal/binding/generator/impl/stmt/parser/retest/UsesTest.java

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