opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/test/java/org/opendaylight/controller/sal/binding/generator/impl/UsesTest.java

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