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