/*
 * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 */
package org.opendaylight.controller.sal.binding.generator.impl;

import static org.junit.Assert.*;

import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;

import org.junit.Test;
import org.opendaylight.controller.sal.binding.generator.api.BindingGenerator;
import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.controller.sal.binding.model.api.GeneratedType;
import org.opendaylight.controller.sal.binding.model.api.MethodSignature;
import org.opendaylight.controller.sal.binding.model.api.ParameterizedType;
import org.opendaylight.controller.sal.binding.model.api.Type;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;

public class UsesTest {

    private class MethodSignaturePattern {
        final String name;
        final String type;

        public MethodSignaturePattern(String methodName, String methodType) {
            this.name = methodName;
            this.type = methodType;
        }

        public String getName() {
            return this.name;
        }

        public String getType() {
            return this.type;
        }
    }

    private static void containsSignatures(final List<MethodSignature> searchedSignsIn,
            final MethodSignaturePattern... searchedSignsWhat) {
        if (searchedSignsIn == null) {
            throw new IllegalArgumentException("List of method signatures in which should be searched can't be null");
        }
        if (searchedSignsWhat == null) {
            throw new IllegalArgumentException("Array of method signatures which should be searched can't be null");
        }

        for (MethodSignaturePattern searchedSignWhat : searchedSignsWhat) {
            boolean nameMatchFound = false;
            String typeNameFound = "";
            for (MethodSignature searchedSignIn : searchedSignsIn) {
                if (searchedSignWhat.getName().equals(searchedSignIn.getName())) {
                    nameMatchFound = true;
                    typeNameFound = resolveFullNameOfReturnType(searchedSignIn);
                    if (searchedSignWhat.getType().equals(typeNameFound)) {
                        break;
                    }
                }
            }
            assertTrue("Method " + searchedSignWhat.getName() + " wasn't found.", nameMatchFound);
            assertEquals("Return type in method " + searchedSignWhat.getName() + " doesn't match expected type ",
                    searchedSignWhat.getType(), typeNameFound);

        }
    }

    private static String resolveFullNameOfReturnType(final MethodSignature methodSignature) {
        final StringBuilder nameBuilder = new StringBuilder();
        if (methodSignature.getReturnType() instanceof ParameterizedType) {
            nameBuilder.append(methodSignature.getReturnType().getName() + "<");
            ParameterizedType parametrizedTypes = (ParameterizedType) methodSignature.getReturnType();
            for (Type parametrizedType : parametrizedTypes.getActualTypeArguments()) {
                nameBuilder.append(parametrizedType.getName() + ",");
            }
            if (nameBuilder.charAt(nameBuilder.length() - 1) == ',') {
                nameBuilder.deleteCharAt(nameBuilder.length() - 1);
            }
            nameBuilder.append(">");
        } else {
            nameBuilder.append(methodSignature.getReturnType().getName());
        }
        return nameBuilder.toString();
    }

    private static boolean containsInterface(String interfaceName, GeneratedType genType) {
        List<Type> caseCImplements = genType.getImplements();
        for (Type caseCImplement : caseCImplements) {
            if (caseCImplement.getName().equals(interfaceName)) {
                return true;
            }
        }
        return false;
    }

    private static List<File> loadTestResources(String testFile) {
        final List<File> testModels = new ArrayList<File>();
        final File listModelFile = new File(UsesTest.class.getResource(testFile).getPath());
        testModels.add(listModelFile);
        return testModels;
    }

    @Test
    public void usesInGroupingDependenciesTest() {
        List<File> testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-dependencies.yang");
        final YangModelParser parser = new YangParserImpl();
        final Set<Module> modules = parser.parseYangModels(testModels);
        final SchemaContext context = parser.resolveSchemaContext(modules);

        assertNotNull(context);
        final BindingGenerator bindingGen = new BindingGeneratorImpl();
        final List<Type> genTypes = bindingGen.generateTypes(context);
        GeneratedType groupingU = null;
        GeneratedType groupingX = null;
        GeneratedType groupingV = null;

        int groupingUCounter = 0;
        int groupingXCounter = 0;
        int groupingVCounter = 0;

        for (Type type : genTypes) {
            if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
                GeneratedType genType = (GeneratedType) type;
                if (genType.getName().equals("GroupingU")) {
                    groupingU = genType;
                    groupingUCounter++;
                } else if (genType.getName().equals("GroupingV")) {
                    groupingV = genType;
                    groupingVCounter++;
                } else if (genType.getName().equals("GroupingX")) {
                    groupingX = genType;
                    groupingXCounter++;
                }
            }
        }

        assertNotNull("Generated type for grouping-U wasn't generated.", groupingU);
        assertEquals("GroupingU interface generated more than one time.", 1, groupingUCounter);
        assertEquals("GroupingU is in wrong package.",
                "org.opendaylight.yang.gen.v1.urn.grouping.dependencies.rev2013718", groupingU.getPackageName());

        assertNotNull("Generated type for grouping-V wasn't generated.", groupingV);
        assertEquals("GroupingV interface generated more than one time.", 1, groupingVCounter);
        assertEquals("GroupingV is in wrong package.",
                "org.opendaylight.yang.gen.v1.urn.grouping.dependencies.rev2013718", groupingV.getPackageName());

        assertNotNull("Generated type for grouping-X wasn't generated.", groupingX);
        assertEquals("GroupingX interface generated more than one time.", 1, groupingXCounter);
        assertEquals("GroupingX is in wrong package.",
                "org.opendaylight.yang.gen.v1.urn.grouping.dependencies.rev2013718", groupingX.getPackageName());

        assertTrue("GroupingV doesn't extend GroupingU.", containsInterface("GroupingV", groupingU));
        assertTrue("GroupingX doesn't extend GroupingU.", containsInterface("GroupingX", groupingU));
        assertTrue("GroupingZ doesn't extend GroupingV.", containsInterface("GroupingZ", groupingV));
        assertTrue("GroupingZZ doesn't extend GroupingV.", containsInterface("GroupingZZ", groupingV));
        assertTrue("GroupingY doesn't extend GroupingX.", containsInterface("GroupingY", groupingX));
    }

    @Test
    public void usesInCaseTest() {
        List<File> testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-case.yang");
        final YangModelParser parser = new YangParserImpl();
        final Set<Module> modules = parser.parseYangModels(testModels);
        final SchemaContext context = parser.resolveSchemaContext(modules);

        assertNotNull(context);
        final BindingGenerator bindingGen = new BindingGeneratorImpl();
        final List<Type> genTypes = bindingGen.generateTypes(context);

        GeneratedType groupingCaseTest = null;
        int groupingCaseTestCounter = 0;
        GeneratedType caseC = null;
        int caseCCounter = 0;
        for (Type type : genTypes) {
            if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
                GeneratedType genType = (GeneratedType) type;
                if (genType.getName().equals("C")) {
                    caseC = genType;
                    caseCCounter++;
                } else if (genType.getName().equals("GroupingCaseTest")) {
                    groupingCaseTest = genType;
                    groupingCaseTestCounter++;
                }
            }
        }

        assertNotNull("Generated type for case C wasn't generated.", caseC);
        assertEquals("Case C interface generated more than one time.", 1, caseCCounter);
        assertEquals(
                "Case C is in wrong package.",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses._case.rev2013718.container.with.choicetest.choice.test",
                caseC.getPackageName());

        assertNotNull("Generated type for grouping-case-test wasn't generated.", groupingCaseTest);
        assertEquals("GroupingCaseTest interface generated more than one time.", 1, groupingCaseTestCounter);
        assertEquals("GroupingCaseTest is in wrong package.",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses._case.rev2013718", groupingCaseTest.getPackageName());

        assertTrue("Case C doesn't extend GroupingCaseTest.", containsInterface("GroupingCaseTest", caseC));
        assertTrue("Case C shouldn't contain any method.", caseC.getMethodDefinitions().isEmpty());

        assertEquals("Number of method in GroupingCaseTest is incorrect", 1, groupingCaseTest.getMethodDefinitions()
                .size());
        containsSignatures(groupingCaseTest.getMethodDefinitions(), new MethodSignaturePattern(
                "getLeafGroupingCaseTest1", "String"));
    }

    @Test
    public void usesInContainerTest() {
        List<File> testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-container.yang");
        final YangModelParser parser = new YangParserImpl();
        final Set<Module> modules = parser.parseYangModels(testModels);
        final SchemaContext context = parser.resolveSchemaContext(modules);

        assertNotNull(context);
        final BindingGenerator bindingGen = new BindingGeneratorImpl();
        final List<Type> genTypes = bindingGen.generateTypes(context);

        int containerTestCount = 0;
        int groupingContainerTestCounter = 0;
        GeneratedType containerTest = null;
        GeneratedType groupingContainerTest = null;

        for (Type type : genTypes) {
            if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
                GeneratedType genType = (GeneratedType) type;
                if (genType.getName().equals("GroupingContainerTest")) {
                    groupingContainerTest = genType;
                    groupingContainerTestCounter++;
                } else if (genType.getName().equals("ContainerTest")) {
                    containerTest = genType;
                    containerTestCount++;
                }
            }
        }

        assertNotNull("Generated type for grouping-container-test wasn't generated", groupingContainerTest);
        assertEquals("GroupingContainerTest interface - incorrect number of occurences", 1,
                groupingContainerTestCounter);
        assertEquals("GroupingContainerTest isn't in correct package",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.container.rev2013718",
                groupingContainerTest.getPackageName());

        assertNotNull("Generated type for container-test wasn't generated", containerTest);
        assertEquals("ContainerTest interface - incorrect number of occurences", 1, containerTestCount);
        assertEquals("ContainerTest isn't in correct package",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.container.rev2013718", containerTest.getPackageName());

        assertTrue("ContainerTest doesn't extend GroupingContainerTest.",
                containsInterface("GroupingContainerTest", containerTest));

        assertEquals("Number of method in GroupingContainerTestis incorrect", 2, groupingContainerTest
                .getMethodDefinitions().size());
        assertEquals("Number of method in ContainerTest is incorrect", 1, containerTest.getMethodDefinitions().size());

        containsSignatures(groupingContainerTest.getMethodDefinitions(), new MethodSignaturePattern(
                "getLeafGroupingContainerTest1", "String"), new MethodSignaturePattern("getLeafGroupingContainerTest2",
                "Short"));

        containsSignatures(containerTest.getMethodDefinitions(), new MethodSignaturePattern("getContainerLeafTest",
                "String"));
    }

    @Test
    public void usesInGroupingTest() {
        List<File> testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-grouping.yang");
        final YangModelParser parser = new YangParserImpl();
        final Set<Module> modules = parser.parseYangModels(testModels);
        final SchemaContext context = parser.resolveSchemaContext(modules);

        assertNotNull(context);
        final BindingGenerator bindingGen = new BindingGeneratorImpl();
        final List<Type> genTypes = bindingGen.generateTypes(context);

        int groupingTestCount = 0;
        int groupingGroupingTestCounter = 0;
        GeneratedType groupingTest = null;
        GeneratedType groupingGroupingTest = null;

        for (Type type : genTypes) {
            if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
                GeneratedType genType = (GeneratedType) type;
                if (genType.getName().equals("GroupingGroupingTest")) {
                    groupingGroupingTest = genType;
                    groupingGroupingTestCounter++;
                } else if (genType.getName().equals("GroupingTest")) {
                    groupingTest = genType;
                    groupingTestCount++;
                }
            }
        }

        assertNotNull("Generated type for grouping-grouping-test wasn't generated", groupingGroupingTest);
        assertEquals("GroupingGroupingTest interface - incorrect number of occurences", 1, groupingGroupingTestCounter);
        assertEquals("GroupingGroupingTest isn't in correct package",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.grouping.rev2013718",
                groupingGroupingTest.getPackageName());

        assertNotNull("Generated type for grouping-test wasn't generated", groupingTest);
        assertEquals("GroupingTest interface - incorrect number of occurences", 1, groupingTestCount);
        assertEquals("GroupingTest isn't in correct package",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.grouping.rev2013718", groupingTest.getPackageName());

        assertTrue("GroupingTest doesn't extend GroupingGroupingTest.",
                containsInterface("GroupingGroupingTest", groupingTest));

        assertEquals("Number of method in GroupingGroupingTest is incorrect", 1, groupingGroupingTest
                .getMethodDefinitions().size());
        assertEquals("Number of method in GroupingTest is incorrect", 1, groupingTest.getMethodDefinitions().size());

        containsSignatures(groupingGroupingTest.getMethodDefinitions(), new MethodSignaturePattern(
                "getLeafGroupingGrouping", "String"));

        containsSignatures(groupingTest.getMethodDefinitions(), new MethodSignaturePattern("getLeafGroupingTest",
                "Byte"));
    }

    @Test
    public void usesInListTest() {
        List<File> testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-list.yang");
        final YangModelParser parser = new YangParserImpl();
        final Set<Module> modules = parser.parseYangModels(testModels);
        final SchemaContext context = parser.resolveSchemaContext(modules);

        assertNotNull(context);
        final BindingGenerator bindingGen = new BindingGeneratorImpl();
        final List<Type> genTypes = bindingGen.generateTypes(context);

        int listTestCounter = 0;
        int groupingListTestCounter = 0;
        int containerGroupingListTestCounter = 0;
        int listGroupingListTestCounter = 0;
        GeneratedType listTest = null;
        GeneratedType groupingListTest = null;
        GeneratedType containerGroupingListTest = null;
        GeneratedType listGroupingListTest = null;

        for (Type type : genTypes) {
            if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
                GeneratedType genType = (GeneratedType) type;
                if (genType.getName().equals("GroupingListTest")) {
                    groupingListTest = genType;
                    groupingListTestCounter++;
                } else if (genType.getName().equals("ListTest")) {
                    listTest = genType;
                    listTestCounter++;
                } else if (genType.getName().equals("ContainerGroupingListTest")) {
                    containerGroupingListTest = genType;
                    containerGroupingListTestCounter++;
                } else if (genType.getName().equals("ListGroupingListTest")) {
                    listGroupingListTest = genType;
                    listGroupingListTestCounter++;
                }
            }
        }

        assertNotNull("Generated type for grouping-list-test wasn't generated", groupingListTest);
        assertEquals("GroupingListTest interface - incorrect number of occurences", 1, groupingListTestCounter);
        assertEquals("GroupingListTest isn't in correct package",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev2013718", groupingListTest.getPackageName());

        assertNotNull("Generated type for list-test wasn't generated", listTest);
        assertEquals("ListTest interface - incorrect number of occurences", 1, listTestCounter);
        assertEquals("ListTest isn't in correct package",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev2013718", listTest.getPackageName());

        assertNotNull("Generated type for container-grouping-list-test wasn't generated", containerGroupingListTest);
        assertEquals("ContainerGroupingListTest interface - incorrect number of occurences", 1,
                containerGroupingListTestCounter);
        assertEquals("ContainerGroupingListTest isn't in correct package",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev2013718.grouping.list.test",
                containerGroupingListTest.getPackageName());

        assertNotNull("Generated type for list-grouping-list-test wasn't generated", listGroupingListTest);
        assertEquals("ListGroupingListTest interface - incorrect number of occurences", 1, listGroupingListTestCounter);
        assertEquals("ListGroupingListTest isn't in correct package",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.list.rev2013718.grouping.list.test",
                listGroupingListTest.getPackageName());

        assertTrue("ListTest doesn't extend GroupingGroupingTest.", containsInterface("GroupingListTest", listTest));

        assertEquals("Number of method in GroupingListTest is incorrect", 4, groupingListTest.getMethodDefinitions()
                .size());
        assertEquals("Number of method in ListTest is incorrect", 1, listTest.getMethodDefinitions().size());
        assertEquals("Number of method in ContainerGroupingListTest is incorrect", 1, containerGroupingListTest
                .getMethodDefinitions().size());
        assertEquals("Number of method in ListGroupingListTest is incorrect", 1, listGroupingListTest
                .getMethodDefinitions().size());

        containsSignatures(groupingListTest.getMethodDefinitions(), new MethodSignaturePattern(
                "getContainerGroupingListTest", "ContainerGroupingListTest"), new MethodSignaturePattern(
                "getLeafGroupingListTest", "String"), new MethodSignaturePattern("getLeaffllistGroupingListTest",
                "List<String>"), new MethodSignaturePattern("getListGroupingListTest", "List<ListGroupingListTest>"));
        containsSignatures(listTest.getMethodDefinitions(), new MethodSignaturePattern("getListLeafTest", "String"));
        containsSignatures(containerGroupingListTest.getMethodDefinitions(), new MethodSignaturePattern(
                "getLeafContainerGroupingListTest", "Short"));
        containsSignatures(listGroupingListTest.getMethodDefinitions(), new MethodSignaturePattern(
                "getLeafListGroupingListTest", "Integer"));
    }

    @Test
    public void usesInModulTest() {
        List<File> testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-modul.yang");
        final YangModelParser parser = new YangParserImpl();
        final Set<Module> modules = parser.parseYangModels(testModels);
        final SchemaContext context = parser.resolveSchemaContext(modules);

        assertNotNull(context);
        final BindingGenerator bindingGen = new BindingGeneratorImpl();
        final List<Type> genTypes = bindingGen.generateTypes(context);

        int groupingModulTestCounter = 0;
        int groupingUsesModulDataCounter = 0;
        GeneratedType groupingModulTest = null;
        GeneratedType groupingUsesModulData = null;

        for (Type type : genTypes) {
            if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
                GeneratedType genType = (GeneratedType) type;
                if (genType.getName().equals("GroupingModulTest")) {
                    groupingModulTest = genType;
                    groupingModulTestCounter++;
                } else if (genType.getName().equals("GroupingUsesModulData")) {
                    groupingUsesModulData = genType;
                    groupingUsesModulDataCounter++;
                }
            }
        }

        assertNotNull("Generated type for grouping-list-test wasn't generated", groupingModulTest);
        assertEquals("GroupingModulTest interface - incorrect number of occurences", 1, groupingModulTestCounter);
        assertEquals("GroupingModulTest isn't in correct package",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.modul.rev2013718", groupingModulTest.getPackageName());

        assertNotNull("Generated type for modul wasn't generated", groupingUsesModulData);
        assertEquals("GroupingUsesModulData interface - incorrect number of occurences", 1,
                groupingUsesModulDataCounter);
        assertEquals("GroupingUsesModulData isn't in correct package",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.modul.rev2013718",
                groupingUsesModulData.getPackageName());

        assertTrue("GroupingUsesModulData doesn't extend GroupingModulTest.",
                containsInterface("GroupingModulTest", groupingUsesModulData));

        assertEquals("Number of method in GroupingUsesModulData is incorrect", 0, groupingUsesModulData
                .getMethodDefinitions().size());
        assertEquals("Number of method in GroupingModulTest is incorrect", 2, groupingModulTest.getMethodDefinitions()
                .size());

        containsSignatures(groupingModulTest.getMethodDefinitions(), new MethodSignaturePattern(
                "getLeafGroupingModulTest", "String"), new MethodSignaturePattern("getLeafGroupingModulTest2", "Short"));
    }

    @Test
    public void usesInRpcTest() {
        List<File> testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-rpc.yang");
        final YangModelParser parser = new YangParserImpl();
        final Set<Module> modules = parser.parseYangModels(testModels);
        final SchemaContext context = parser.resolveSchemaContext(modules);

        assertNotNull(context);
        final BindingGenerator bindingGen = new BindingGeneratorImpl();
        final List<Type> genTypes = bindingGen.generateTypes(context);

        int rpcTestInputCounter = 0;
        int rpcTestOutputCounter = 0;
        int groupingRpcInputTestCounter = 0;
        int groupingRpcOutputTestCounter = 0;
        int containerGroupingRpcInputTestCounter = 0;
        GeneratedType rpcTestInput = null;
        GeneratedType rpcTestOutput = null;
        GeneratedType groupingRpcInputTest = null;
        GeneratedType groupingRpcOutputTest = null;
        GeneratedType containerGroupingRpcInputTest = null;

        for (Type type : genTypes) {
            if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
                GeneratedType genType = (GeneratedType) type;
                if (genType.getName().equals("RpcTestInput")) {
                    rpcTestInput = genType;
                    rpcTestInputCounter++;
                } else if (genType.getName().equals("RpcTestOutput")) {
                    rpcTestOutput = genType;
                    rpcTestOutputCounter++;
                } else if (genType.getName().equals("GroupingRpcInputTest")) {
                    groupingRpcInputTest = genType;
                    groupingRpcInputTestCounter++;
                } else if (genType.getName().equals("GroupingRpcOutputTest")) {
                    groupingRpcOutputTest = genType;
                    groupingRpcOutputTestCounter++;
                } else if (genType.getName().equals("ContainerGroupingRpcInputTest")) {
                    containerGroupingRpcInputTest = genType;
                    containerGroupingRpcInputTestCounter++;
                }

            }
        }

        assertNotNull("Generated type for RPC test input wasn't generated", rpcTestInput);
        assertEquals("RpcTestInput interface - incorrect number of occurences", 1, rpcTestInputCounter);
        assertEquals("RpcTestInput isn't in correct package",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev2013718", rpcTestInput.getPackageName());

        assertNotNull("Generated type for RPC test output wasn't generated", rpcTestOutput);
        assertEquals("RpcTestOutput interface - incorrect number of occurences", 1, rpcTestOutputCounter);
        assertEquals("RpcTestOutput isn't in correct package",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev2013718", rpcTestOutput.getPackageName());

        assertNotNull("Generated type for grouping-rpc-input-test wasn't generated", groupingRpcInputTest);
        assertEquals("RpcTestOutput interface - incorrect number of occurences", 1, groupingRpcInputTestCounter);
        assertEquals("GroupingRpcInputTest isn't in correct package",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev2013718", groupingRpcInputTest.getPackageName());

        assertNotNull("Generated type for grouping-rpc-output-test wasn't generated", groupingRpcOutputTest);
        assertEquals("RpcTestOutput interface - incorrect number of occurences", 1, groupingRpcOutputTestCounter);
        assertEquals("GroupingRpcOutputTest isn't in correct package",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev2013718", groupingRpcOutputTest.getPackageName());

        assertNotNull("Generated type for container-grouping-rpc-input-test wasn't generated",
                containerGroupingRpcInputTest);
        assertEquals("ContainerGroupingRpcInputTest interface - incorrect number of occurences", 1,
                containerGroupingRpcInputTestCounter);
        assertEquals("ContainerGroupingRpcInputTest isn't in correct package",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.rpc.rev2013718.grouping.rpc.input.test",
                containerGroupingRpcInputTest.getPackageName());

        assertTrue("RpcTestInput doesn't extend GroupingRpcInputTest.",
                containsInterface("GroupingRpcInputTest", rpcTestInput));
        assertTrue("RpcTestOutput doesn't extend GroupingRpcOutputTest.",
                containsInterface("GroupingRpcOutputTest", rpcTestOutput));

        assertEquals("Number of method in RpcTestInput is incorrect", 0, rpcTestInput.getMethodDefinitions().size());
        assertEquals("Number of method in RpcTestOutput is incorrect", 0, rpcTestOutput.getMethodDefinitions().size());
        assertEquals("Number of method in GroupingRpcInputTest is incorrect", 2, groupingRpcInputTest
                .getMethodDefinitions().size());
        assertEquals("Number of method in GroupingRpcOutputTest is incorrect", 1, groupingRpcOutputTest
                .getMethodDefinitions().size());
        assertEquals("Number of method in ContainerGroupingRpcInputTest is incorrect", 1, containerGroupingRpcInputTest
                .getMethodDefinitions().size());

        containsSignatures(groupingRpcInputTest.getMethodDefinitions(), new MethodSignaturePattern(
                "getContainerGroupingRpcInputTest", "ContainerGroupingRpcInputTest"), new MethodSignaturePattern(
                "getLeaflistGroupingRpcInputTest", "List<Short>"));
        containsSignatures(groupingRpcOutputTest.getMethodDefinitions(), new MethodSignaturePattern(
                "getLeafGroupingRpcOutputTest", "Byte"));
        containsSignatures(containerGroupingRpcInputTest.getMethodDefinitions(), new MethodSignaturePattern(
                "getLeafContainerGroupingRpcInputTest", "String"));
    }

    @Test
    public void usesInAugmentTest() {
        List<File> testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-augment.yang");
        final YangModelParser parser = new YangParserImpl();
        final Set<Module> modules = parser.parseYangModels(testModels);
        final SchemaContext context = parser.resolveSchemaContext(modules);

        assertNotNull(context);
        final BindingGenerator bindingGen = new BindingGeneratorImpl();
        final List<Type> genTypes = bindingGen.generateTypes(context);

        GeneratedType containerAugment1 = null;
        GeneratedType groupingAugmentTest = null;
        int containerAugment1Counter = 0;
        int groupingAugmentTestCounter = 0;

        for (Type type : genTypes) {
            if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
                GeneratedType genType = (GeneratedType) type;
                if (genType.getName().equals("ContainerAugment1")) {
                    containerAugment1 = genType;
                    containerAugment1Counter++;
                } else if (genType.getName().equals("GroupingAugmentTest")) {
                    groupingAugmentTest = genType;
                    groupingAugmentTestCounter++;
                }
            }
        }

        assertNotNull("Generated type for augment /container-augment wasn't generated.", containerAugment1);
        assertEquals("ContainerAugment1 interface generated more than one time.", 1, containerAugment1Counter);
        assertEquals("ContainerAugment1 is in wrong package.",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.augment.rev2013718", containerAugment1.getPackageName());

        assertNotNull("Generated type for grouping-augment-test wasn't generated.", groupingAugmentTest);
        assertEquals("GroupingAugmentTest interface generated more than one time.", 1, groupingAugmentTestCounter);
        assertEquals("groupingAugmentTest is in wrong package.",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.augment.rev2013718",
                groupingAugmentTest.getPackageName());

        assertTrue("ContainerAugment1 doesn't extend GroupingAugmentTest.",
                containsInterface("GroupingAugmentTest", containerAugment1));

        assertEquals("Number of method in GroupingCaseTest is incorrect", 0, containerAugment1.getMethodDefinitions()
                .size());

        assertEquals("Number of method in ContainerAugment1 is incorrect", 0, containerAugment1.getMethodDefinitions()
                .size());
        assertEquals("Number of method in GroupingCaseTest is incorrect", 1, groupingAugmentTest.getMethodDefinitions()
                .size());

        containsSignatures(groupingAugmentTest.getMethodDefinitions(), new MethodSignaturePattern(
                "getLeafGroupingAugmentTest", "String"));
    }

    @Test
    public void usesInNotification() {
        List<File> testModels = loadTestResources("/uses-of-grouping/uses-of-grouping-notification.yang");
        final YangModelParser parser = new YangParserImpl();
        final Set<Module> modules = parser.parseYangModels(testModels);
        final SchemaContext context = parser.resolveSchemaContext(modules);

        assertNotNull(context);
        final BindingGenerator bindingGen = new BindingGeneratorImpl();
        final List<Type> genTypes = bindingGen.generateTypes(context);

        GeneratedType notificationTest = null;
        GeneratedType groupingNotificationTest = null;
        GeneratedType containerGroupingNotificationTest = null;
        int notificationTestCounter = 0;
        int groupingNotificationTestCounter = 0;
        int containerGroupingNotificationTestCounter = 0;

        for (Type type : genTypes) {
            if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
                GeneratedType genType = (GeneratedType) type;
                if (genType.getName().equals("NotificationTest")) {
                    notificationTest = genType;
                    notificationTestCounter++;
                } else if (genType.getName().equals("GroupingNotificationTest")) {
                    groupingNotificationTest = genType;
                    groupingNotificationTestCounter++;
                } else if (genType.getName().equals("ContainerGroupingNotificationTest")) {
                    containerGroupingNotificationTest = genType;
                    containerGroupingNotificationTestCounter++;
                }
            }
        }

        assertNotNull("Generated type for notification-test wasn't generated.", notificationTest);
        assertEquals("NotificationTest interface generated more than one time.", 1, notificationTestCounter);
        assertEquals("NotificationTest is in wrong package.",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.notification.rev2013718",
                notificationTest.getPackageName());

        assertNotNull("Generated type for grouping-notification-test wasn't generated.", groupingNotificationTest);
        assertEquals("GroupingNotificationTest interface generated more than one time.", 1,
                groupingNotificationTestCounter);
        assertEquals("groupingNotificationTest is in wrong package.",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.notification.rev2013718",
                groupingNotificationTest.getPackageName());

        assertNotNull("Generated type for container-grouping-notification-test wasn't generated.",
                containerGroupingNotificationTest);
        assertEquals("ContainerGroupingNotificationTest interface generated more than one time.", 1,
                containerGroupingNotificationTestCounter);
        assertEquals("ContainerGroupingNotificationTest is in wrong package.",
                "org.opendaylight.yang.gen.v1.urn.grouping.uses.notification.rev2013718.grouping.notification.test",
                containerGroupingNotificationTest.getPackageName());

        assertTrue("NotificationTest doesn't extend GroupingNotificationTest.",
                containsInterface("GroupingNotificationTest", notificationTest));

        assertEquals("Number of method in NotificationTest is incorrect", 1, notificationTest.getMethodDefinitions()
                .size());
        assertEquals("Number of method in GroupingNotificationTest is incorrect", 2, groupingNotificationTest
                .getMethodDefinitions().size());
        assertEquals("Number of method in ContainerGroupingNotificationTest is incorrect", 1,
                containerGroupingNotificationTest.getMethodDefinitions().size());

        containsSignatures(notificationTest.getMethodDefinitions(), new MethodSignaturePattern(
                "getLeafNotificationTest", "String"));
        containsSignatures(groupingNotificationTest.getMethodDefinitions(), new MethodSignaturePattern(
                "getContainerGroupingNotificationTest", "ContainerGroupingNotificationTest"),
                new MethodSignaturePattern("getLeaffllistGroupingNotificationTest", "List<String>"));
        containsSignatures(containerGroupingNotificationTest.getMethodDefinitions(), new MethodSignaturePattern(
                "getLeafContainerGroupingNotificationTest", "Long"));
    }

}