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