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