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         containsMethods(groupingCaseTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingCaseTest1",
 139                 "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         containsMethods(groupingContainerTest.getMethodDefinitions(), new NameTypePattern(
 190                 "getLeafGroupingContainerTest1", "String"), new NameTypePattern("getLeafGroupingContainerTest2",
 191                 "Short"));
 192
 193         containsMethods(containerTest.getMethodDefinitions(), new NameTypePattern("getContainerLeafTest", "String"));
 194     }
 195
 196     @Test
 197     public void usesInGroupingTest() {
 198         List<File> testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-grouping.yang");
 199         final YangModelParser parser = new YangParserImpl();
 200         final Set<Module> modules = parser.parseYangModels(testModels);
 201         final SchemaContext context = parser.resolveSchemaContext(modules);
 202
 203         assertNotNull(context);
 204         final BindingGenerator bindingGen = new BindingGeneratorImpl();
 205         final List<Type> genTypes = bindingGen.generateTypes(context);
 206
 207         int groupingTestCount = 0;
 208         int groupingGroupingTestCounter = 0;
 209         GeneratedType groupingTest = null;
 210         GeneratedType groupingGroupingTest = null;
 211
 212         for (Type type : genTypes) {
 213             if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
 214                 GeneratedType genType = (GeneratedType) type;
 215                 if (genType.getName().equals("GroupingGroupingTest")) {
 216                     groupingGroupingTest = genType;
 217                     groupingGroupingTestCounter++;
 218                 } else if (genType.getName().equals("GroupingTest")) {
 219                     groupingTest = genType;
 220                     groupingTestCount++;
 221                 }
 222             }
 223         }
 224
 225         assertNotNull("Generated type for grouping-grouping-test wasn't generated", groupingGroupingTest);
 226         assertEquals("GroupingGroupingTest interface - incorrect number of occurences", 1, groupingGroupingTestCounter);
 227         assertEquals("GroupingGroupingTest isn't in correct package",
 228                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.grouping.rev2013718",
 229                 groupingGroupingTest.getPackageName());
 230
 231         assertNotNull("Generated type for grouping-test wasn't generated", groupingTest);
 232         assertEquals("GroupingTest interface - incorrect number of occurences", 1, groupingTestCount);
 233         assertEquals("GroupingTest isn't in correct package",
 234                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.grouping.rev2013718", groupingTest.getPackageName());
 235
 236         containsInterface("GroupingGroupingTest", groupingTest);
 237
 238         assertEquals("Number of method in GroupingGroupingTest is incorrect", 1, groupingGroupingTest
 239                 .getMethodDefinitions().size());
 240         assertEquals("Number of method in GroupingTest is incorrect", 1, groupingTest.getMethodDefinitions().size());
 241
 242         containsMethods(groupingGroupingTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingGrouping",
 243                 "String"));
 244
 245         containsMethods(groupingTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingTest", "Byte"));
 246     }
 247
 248     @Test
 249     public void usesInListTest() {
 250         List<File> testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-list.yang");
 251         final YangModelParser parser = new YangParserImpl();
 252         final Set<Module> modules = parser.parseYangModels(testModels);
 253         final SchemaContext context = parser.resolveSchemaContext(modules);
 254
 255         assertNotNull(context);
 256         final BindingGenerator bindingGen = new BindingGeneratorImpl();
 257         final List<Type> genTypes = bindingGen.generateTypes(context);
 258
 259         int listTestCounter = 0;
 260         int groupingListTestCounter = 0;
 261         int containerGroupingListTestCounter = 0;
 262         int listGroupingListTestCounter = 0;
 263         GeneratedType listTest = null;
 264         GeneratedType groupingListTest = null;
 265         GeneratedType containerGroupingListTest = null;
 266         GeneratedType listGroupingListTest = null;
 267
 268         for (Type type : genTypes) {
 269             if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
 270                 GeneratedType genType = (GeneratedType) type;
 271                 if (genType.getName().equals("GroupingListTest")) {
 272                     groupingListTest = genType;
 273                     groupingListTestCounter++;
 274                 } else if (genType.getName().equals("ListTest")) {
 275                     listTest = genType;
 276                     listTestCounter++;
 277                 } else if (genType.getName().equals("ContainerGroupingListTest")) {
 278                     containerGroupingListTest = genType;
 279                     containerGroupingListTestCounter++;
 280                 } else if (genType.getName().equals("ListGroupingListTest")) {
 281                     listGroupingListTest = genType;
 282                     listGroupingListTestCounter++;
 283                 }
 284             }
 285         }
 286
 287         assertNotNull("Generated type for grouping-list-test wasn't generated", groupingListTest);
 288         assertEquals("GroupingListTest interface - incorrect number of occurences", 1, groupingListTestCounter);
 289         assertEquals("GroupingListTest isn't in correct package",
 290                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev2013718", groupingListTest.getPackageName());
 291
 292         assertNotNull("Generated type for list-test wasn't generated", listTest);
 293         assertEquals("ListTest interface - incorrect number of occurences", 1, listTestCounter);
 294         assertEquals("ListTest isn't in correct package",
 295                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev2013718", listTest.getPackageName());
 296
 297         assertNotNull("Generated type for container-grouping-list-test wasn't generated", containerGroupingListTest);
 298         assertEquals("ContainerGroupingListTest interface - incorrect number of occurences", 1,
 299                 containerGroupingListTestCounter);
 300         assertEquals("ContainerGroupingListTest isn't in correct package",
 301                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev2013718.grouping.list.test",
 302                 containerGroupingListTest.getPackageName());
 303
 304         assertNotNull("Generated type for list-grouping-list-test wasn't generated", listGroupingListTest);
 305         assertEquals("ListGroupingListTest interface - incorrect number of occurences", 1, listGroupingListTestCounter);
 306         assertEquals("ListGroupingListTest isn't in correct package",
 307                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev2013718.grouping.list.test",
 308                 listGroupingListTest.getPackageName());
 309
 310         containsInterface("GroupingListTest", listTest);
 311
 312         assertEquals("Number of method in GroupingListTest is incorrect", 4, groupingListTest.getMethodDefinitions()
 313                 .size());
 314         assertEquals("Number of method in ListTest is incorrect", 1, listTest.getMethodDefinitions().size());
 315         assertEquals("Number of method in ContainerGroupingListTest is incorrect", 1, containerGroupingListTest
 316                 .getMethodDefinitions().size());
 317         assertEquals("Number of method in ListGroupingListTest is incorrect", 1, listGroupingListTest
 318                 .getMethodDefinitions().size());
 319
 320         containsMethods(groupingListTest.getMethodDefinitions(), new NameTypePattern("getContainerGroupingListTest",
 321                 "ContainerGroupingListTest"), new NameTypePattern("getLeafGroupingListTest", "String"),
 322                 new NameTypePattern("getLeaffllistGroupingListTest", "List<String>"), new NameTypePattern(
 323                         "getListGroupingListTest", "List<ListGroupingListTest>"));
 324         containsMethods(listTest.getMethodDefinitions(), new NameTypePattern("getListLeafTest", "String"));
 325         containsMethods(containerGroupingListTest.getMethodDefinitions(), new NameTypePattern(
 326                 "getLeafContainerGroupingListTest", "Short"));
 327         containsMethods(listGroupingListTest.getMethodDefinitions(), new NameTypePattern("getLeafListGroupingListTest",
 328                 "Integer"));
 329     }
 330
 331     @Test
 332     public void usesInModulTest() {
 333         List<File> testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-modul.yang");
 334         final YangModelParser parser = new YangParserImpl();
 335         final Set<Module> modules = parser.parseYangModels(testModels);
 336         final SchemaContext context = parser.resolveSchemaContext(modules);
 337
 338         assertNotNull(context);
 339         final BindingGenerator bindingGen = new BindingGeneratorImpl();
 340         final List<Type> genTypes = bindingGen.generateTypes(context);
 341
 342         int groupingModulTestCounter = 0;
 343         int groupingUsesModulDataCounter = 0;
 344         GeneratedType groupingModulTest = null;
 345         GeneratedType groupingUsesModulData = null;
 346
 347         for (Type type : genTypes) {
 348             if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
 349                 GeneratedType genType = (GeneratedType) type;
 350                 if (genType.getName().equals("GroupingModulTest")) {
 351                     groupingModulTest = genType;
 352                     groupingModulTestCounter++;
 353                 } else if (genType.getName().equals("GroupingUsesModulData")) {
 354                     groupingUsesModulData = genType;
 355                     groupingUsesModulDataCounter++;
 356                 }
 357             }
 358         }
 359
 360         assertNotNull("Generated type for grouping-list-test wasn't generated", groupingModulTest);
 361         assertEquals("GroupingModulTest interface - incorrect number of occurences", 1, groupingModulTestCounter);
 362         assertEquals("GroupingModulTest isn't in correct package",
 363                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.modul.rev2013718", groupingModulTest.getPackageName());
 364
 365         assertNotNull("Generated type for modul wasn't generated", groupingUsesModulData);
 366         assertEquals("GroupingUsesModulData interface - incorrect number of occurences", 1,
 367                 groupingUsesModulDataCounter);
 368         assertEquals("GroupingUsesModulData isn't in correct package",
 369                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.modul.rev2013718",
 370                 groupingUsesModulData.getPackageName());
 371
 372         containsInterface("GroupingModulTest", groupingUsesModulData);
 373
 374         assertEquals("Number of method in GroupingUsesModulData is incorrect", 0, groupingUsesModulData
 375                 .getMethodDefinitions().size());
 376         assertEquals("Number of method in GroupingModulTest is incorrect", 2, groupingModulTest.getMethodDefinitions()
 377                 .size());
 378
 379         containsMethods(groupingModulTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingModulTest",
 380                 "String"), new NameTypePattern("getLeafGroupingModulTest2", "Short"));
 381     }
 382
 383     @Test
 384     public void usesInRpcTest() {
 385         List<File> testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-rpc.yang");
 386         final YangModelParser parser = new YangParserImpl();
 387         final Set<Module> modules = parser.parseYangModels(testModels);
 388         final SchemaContext context = parser.resolveSchemaContext(modules);
 389
 390         assertNotNull(context);
 391         final BindingGenerator bindingGen = new BindingGeneratorImpl();
 392         final List<Type> genTypes = bindingGen.generateTypes(context);
 393
 394         int rpcTestInputCounter = 0;
 395         int rpcTestOutputCounter = 0;
 396         int groupingRpcInputTestCounter = 0;
 397         int groupingRpcOutputTestCounter = 0;
 398         int containerGroupingRpcInputTestCounter = 0;
 399         GeneratedType rpcTestInput = null;
 400         GeneratedType rpcTestOutput = null;
 401         GeneratedType groupingRpcInputTest = null;
 402         GeneratedType groupingRpcOutputTest = null;
 403         GeneratedType containerGroupingRpcInputTest = null;
 404
 405         for (Type type : genTypes) {
 406             if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
 407                 GeneratedType genType = (GeneratedType) type;
 408                 if (genType.getName().equals("RpcTestInput")) {
 409                     rpcTestInput = genType;
 410                     rpcTestInputCounter++;
 411                 } else if (genType.getName().equals("RpcTestOutput")) {
 412                     rpcTestOutput = genType;
 413                     rpcTestOutputCounter++;
 414                 } else if (genType.getName().equals("GroupingRpcInputTest")) {
 415                     groupingRpcInputTest = genType;
 416                     groupingRpcInputTestCounter++;
 417                 } else if (genType.getName().equals("GroupingRpcOutputTest")) {
 418                     groupingRpcOutputTest = genType;
 419                     groupingRpcOutputTestCounter++;
 420                 } else if (genType.getName().equals("ContainerGroupingRpcInputTest")) {
 421                     containerGroupingRpcInputTest = genType;
 422                     containerGroupingRpcInputTestCounter++;
 423                 }
 424
 425             }
 426         }
 427
 428         assertNotNull("Generated type for RPC test input wasn't generated", rpcTestInput);
 429         assertEquals("RpcTestInput interface - incorrect number of occurences", 1, rpcTestInputCounter);
 430         assertEquals("RpcTestInput isn't in correct package",
 431                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev2013718", rpcTestInput.getPackageName());
 432
 433         assertNotNull("Generated type for RPC test output wasn't generated", rpcTestOutput);
 434         assertEquals("RpcTestOutput interface - incorrect number of occurences", 1, rpcTestOutputCounter);
 435         assertEquals("RpcTestOutput isn't in correct package",
 436                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev2013718", rpcTestOutput.getPackageName());
 437
 438         assertNotNull("Generated type for grouping-rpc-input-test wasn't generated", groupingRpcInputTest);
 439         assertEquals("RpcTestOutput interface - incorrect number of occurences", 1, groupingRpcInputTestCounter);
 440         assertEquals("GroupingRpcInputTest isn't in correct package",
 441                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev2013718", groupingRpcInputTest.getPackageName());
 442
 443         assertNotNull("Generated type for grouping-rpc-output-test wasn't generated", groupingRpcOutputTest);
 444         assertEquals("RpcTestOutput interface - incorrect number of occurences", 1, groupingRpcOutputTestCounter);
 445         assertEquals("GroupingRpcOutputTest isn't in correct package",
 446                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev2013718", groupingRpcOutputTest.getPackageName());
 447
 448         assertNotNull("Generated type for container-grouping-rpc-input-test wasn't generated",
 449                 containerGroupingRpcInputTest);
 450         assertEquals("ContainerGroupingRpcInputTest interface - incorrect number of occurences", 1,
 451                 containerGroupingRpcInputTestCounter);
 452         assertEquals("ContainerGroupingRpcInputTest isn't in correct package",
 453                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev2013718.grouping.rpc.input.test",
 454                 containerGroupingRpcInputTest.getPackageName());
 455
 456         containsInterface("GroupingRpcInputTest", rpcTestInput);
 457         containsInterface("GroupingRpcOutputTest", rpcTestOutput);
 458
 459         assertEquals("Number of method in RpcTestInput is incorrect", 0, rpcTestInput.getMethodDefinitions().size());
 460         assertEquals("Number of method in RpcTestOutput is incorrect", 0, rpcTestOutput.getMethodDefinitions().size());
 461         assertEquals("Number of method in GroupingRpcInputTest is incorrect", 2, groupingRpcInputTest
 462                 .getMethodDefinitions().size());
 463         assertEquals("Number of method in GroupingRpcOutputTest is incorrect", 1, groupingRpcOutputTest
 464                 .getMethodDefinitions().size());
 465         assertEquals("Number of method in ContainerGroupingRpcInputTest is incorrect", 1, containerGroupingRpcInputTest
 466                 .getMethodDefinitions().size());
 467
 468         containsMethods(groupingRpcInputTest.getMethodDefinitions(), new NameTypePattern(
 469                 "getContainerGroupingRpcInputTest", "ContainerGroupingRpcInputTest"), new NameTypePattern(
 470                 "getLeaflistGroupingRpcInputTest", "List<Short>"));
 471         containsMethods(groupingRpcOutputTest.getMethodDefinitions(), new NameTypePattern(
 472                 "getLeafGroupingRpcOutputTest", "Byte"));
 473         containsMethods(containerGroupingRpcInputTest.getMethodDefinitions(), new NameTypePattern(
 474                 "getLeafContainerGroupingRpcInputTest", "String"));
 475     }
 476
 477     @Test
 478     public void usesInAugmentTest() {
 479         List<File> testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-augment.yang");
 480         final YangModelParser parser = new YangParserImpl();
 481         final Set<Module> modules = parser.parseYangModels(testModels);
 482         final SchemaContext context = parser.resolveSchemaContext(modules);
 483
 484         assertNotNull(context);
 485         final BindingGenerator bindingGen = new BindingGeneratorImpl();
 486         final List<Type> genTypes = bindingGen.generateTypes(context);
 487
 488         GeneratedType containerAugment1 = null;
 489         GeneratedType groupingAugmentTest = null;
 490         int containerAugment1Counter = 0;
 491         int groupingAugmentTestCounter = 0;
 492
 493         for (Type type : genTypes) {
 494             if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
 495                 GeneratedType genType = (GeneratedType) type;
 496                 if (genType.getName().equals("ContainerAugment1")) {
 497                     containerAugment1 = genType;
 498                     containerAugment1Counter++;
 499                 } else if (genType.getName().equals("GroupingAugmentTest")) {
 500                     groupingAugmentTest = genType;
 501                     groupingAugmentTestCounter++;
 502                 }
 503             }
 504         }
 505
 506         assertNotNull("Generated type for augment /container-augment wasn't generated.", containerAugment1);
 507         assertEquals("ContainerAugment1 interface generated more than one time.", 1, containerAugment1Counter);
 508         assertEquals("ContainerAugment1 is in wrong package.",
 509                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.augment.rev2013718", containerAugment1.getPackageName());
 510
 511         assertNotNull("Generated type for grouping-augment-test wasn't generated.", groupingAugmentTest);
 512         assertEquals("GroupingAugmentTest interface generated more than one time.", 1, groupingAugmentTestCounter);
 513         assertEquals("groupingAugmentTest is in wrong package.",
 514                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.augment.rev2013718",
 515                 groupingAugmentTest.getPackageName());
 516
 517         containsInterface("GroupingAugmentTest", containerAugment1);
 518
 519         assertEquals("Number of method in GroupingCaseTest is incorrect", 0, containerAugment1.getMethodDefinitions()
 520                 .size());
 521
 522         assertEquals("Number of method in ContainerAugment1 is incorrect", 0, containerAugment1.getMethodDefinitions()
 523                 .size());
 524         assertEquals("Number of method in GroupingCaseTest is incorrect", 1, groupingAugmentTest.getMethodDefinitions()
 525                 .size());
 526
 527         containsMethods(groupingAugmentTest.getMethodDefinitions(), new NameTypePattern("getLeafGroupingAugmentTest",
 528                 "String"));
 529     }
 530
 531     @Test
 532     public void usesInNotification() {
 533         List<File> testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-notification.yang");
 534         final YangModelParser parser = new YangParserImpl();
 535         final Set<Module> modules = parser.parseYangModels(testModels);
 536         final SchemaContext context = parser.resolveSchemaContext(modules);
 537
 538         assertNotNull(context);
 539         final BindingGenerator bindingGen = new BindingGeneratorImpl();
 540         final List<Type> genTypes = bindingGen.generateTypes(context);
 541
 542         GeneratedType notificationTest = null;
 543         GeneratedType groupingNotificationTest = null;
 544         GeneratedType containerGroupingNotificationTest = null;
 545         int notificationTestCounter = 0;
 546         int groupingNotificationTestCounter = 0;
 547         int containerGroupingNotificationTestCounter = 0;
 548
 549         for (Type type : genTypes) {
 550             if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
 551                 GeneratedType genType = (GeneratedType) type;
 552                 if (genType.getName().equals("NotificationTest")) {
 553                     notificationTest = genType;
 554                     notificationTestCounter++;
 555                 } else if (genType.getName().equals("GroupingNotificationTest")) {
 556                     groupingNotificationTest = genType;
 557                     groupingNotificationTestCounter++;
 558                 } else if (genType.getName().equals("ContainerGroupingNotificationTest")) {
 559                     containerGroupingNotificationTest = genType;
 560                     containerGroupingNotificationTestCounter++;
 561                 }
 562             }
 563         }
 564
 565         assertNotNull("Generated type for notification-test wasn't generated.", notificationTest);
 566         assertEquals("NotificationTest interface generated more than one time.", 1, notificationTestCounter);
 567         assertEquals("NotificationTest is in wrong package.",
 568                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.notification.rev2013718",
 569                 notificationTest.getPackageName());
 570
 571         assertNotNull("Generated type for grouping-notification-test wasn't generated.", groupingNotificationTest);
 572         assertEquals("GroupingNotificationTest interface generated more than one time.", 1,
 573                 groupingNotificationTestCounter);
 574         assertEquals("groupingNotificationTest is in wrong package.",
 575                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.notification.rev2013718",
 576                 groupingNotificationTest.getPackageName());
 577
 578         assertNotNull("Generated type for container-grouping-notification-test wasn't generated.",
 579                 containerGroupingNotificationTest);
 580         assertEquals("ContainerGroupingNotificationTest interface generated more than one time.", 1,
 581                 containerGroupingNotificationTestCounter);
 582         assertEquals("ContainerGroupingNotificationTest is in wrong package.",
 583                 "org.opendaylight.yang.gen.v1.urn.grouping.uses.notification.rev2013718.grouping.notification.test",
 584                 containerGroupingNotificationTest.getPackageName());
 585
 586         containsInterface("GroupingNotificationTest", notificationTest);
 587
 588         assertEquals("Number of method in NotificationTest is incorrect", 1, notificationTest.getMethodDefinitions()
 589                 .size());
 590         assertEquals("Number of method in GroupingNotificationTest is incorrect", 2, groupingNotificationTest
 591                 .getMethodDefinitions().size());
 592         assertEquals("Number of method in ContainerGroupingNotificationTest is incorrect", 1,
 593                 containerGroupingNotificationTest.getMethodDefinitions().size());
 594
 595         containsMethods(notificationTest.getMethodDefinitions(), new NameTypePattern("getLeafNotificationTest",
 596                 "String"));
 597         containsMethods(groupingNotificationTest.getMethodDefinitions(), new NameTypePattern(
 598                 "getContainerGroupingNotificationTest", "ContainerGroupingNotificationTest"), new NameTypePattern(
 599                 "getLeaffllistGroupingNotificationTest", "List<String>"));
 600         containsMethods(containerGroupingNotificationTest.getMethodDefinitions(), new NameTypePattern(
 601                 "getLeafContainerGroupingNotificationTest", "Long"));
 602     }
 603
 604 }