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