Refine test refined

Change-Id: I7df61166dc755e7eb9c50bc01f2a3d4cca1642e5
Signed-off-by: Jozef Gloncak <jgloncak@cisco.com>

diff --git a/code-generator/binding-generator-impl/src/test/java/org/opendaylight/yangtools/sal/binding/generator/impl/RefineTest.java b/code-generator/binding-generator-impl/src/test/java/org/opendaylight/yangtools/sal/binding/generator/impl/RefineTest.java
index 0af7923d6564278a67e528b4d3eb9a8bdab85ab0..92185784c9bdd2ccdff2cbe68c966f78b9268215 100644 (file)
--- a/code-generator/binding-generator-impl/src/test/java/org/opendaylight/yangtools/sal/binding/generator/impl/RefineTest.java
+++ b/code-generator/binding-generator-impl/src/test/java/org/opendaylight/yangtools/sal/binding/generator/impl/RefineTest.java
@@ -7,28 +7,35 @@
  */
 package org.opendaylight.yangtools.sal.binding.generator.impl;
 
-import static org.junit.Assert.*;
-import static org.opendaylight.yangtools.sal.binding.generator.impl.SupportTestUtil.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
 
 import java.io.File;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.*;
 
 import org.junit.Test;
-import org.opendaylight.yangtools.sal.binding.generator.api.BindingGenerator;
-import org.opendaylight.yangtools.sal.binding.model.api.GeneratedTransferObject;
-import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType;
-import org.opendaylight.yangtools.sal.binding.model.api.Type;
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
-import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.*;
 import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
+import org.opendaylight.yangtools.yang.parser.util.GroupingUtils;
+import org.opendaylight.yangtools.yang.parser.util.RefineHolder;
+import org.opendaylight.yangtools.yang.parser.util.RefineUtils;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
 
 //Test for class RefineUtils
 public class RefineTest {
@@ -40,13 +47,13 @@ public class RefineTest {
         testModels.add(listModelFile);
     }
 
-    private void findUnknownNode(DataSchemaNode childNode, String unknownNodeValue, String unknownNodeName) {
-        List<UnknownSchemaNode> unknownSchemaNodes = childNode.getUnknownSchemaNodes();
+    private void findUnknownNode(DataSchemaNodeBuilder childNode, String unknownNodeValue, String unknownNodeName) {
+        List<UnknownSchemaNodeBuilder> unknownSchemaNodesBuilder = childNode.getUnknownNodeBuilders();
         boolean refinedUnknownNodeLflstFound = false;
 
-        for (UnknownSchemaNode unknownSchemaNode : unknownSchemaNodes) {
-            if (unknownSchemaNode.getNodeType().getLocalName().equals(unknownNodeName)
-                    && unknownSchemaNode.getQName().getLocalName().equals(unknownNodeValue)) {
+        for (UnknownSchemaNodeBuilder unknownSchemaNodeBuilders : unknownSchemaNodesBuilder) {
+            if (unknownSchemaNodeBuilders.getNodeType().getLocalName().equals(unknownNodeName)
+                    && unknownSchemaNodeBuilders.getQName().getLocalName().equals(unknownNodeValue)) {
                 refinedUnknownNodeLflstFound = true;
             }
         }
@@ -54,9 +61,9 @@ public class RefineTest {
                 refinedUnknownNodeLflstFound);
     }
 
-    private void findMustConstraint(ConstraintDefinition conDef, String mustValue) {
+    private void findMustConstraint(ConstraintsBuilder conDef, String mustValue) {
         boolean mustLflstFound = false;
-        for (MustDefinition mustDef : conDef.getMustConstraints()) {
+        for (MustDefinition mustDef : conDef.getMustDefinitions()) {
             if (mustDef.toString().equals(mustValue)) {
                 mustLflstFound = true;
                 break;
@@ -68,77 +75,187 @@ public class RefineTest {
     @Test
     public void usesInGroupingDependenciesTest() {
         loadTestResources();
-        final YangModelParser parser = new YangParserImpl();
-        final Set<Module> modules = parser.parseYangModels(testModels);
+        assertEquals("Incorrect number of test files.", 1, testModels.size());
 
-        Module refineModule = null;
-        for (Module module : modules) {
-            if (module.getName().equals("module-refine")) {
-                refineModule = module;
+        Set<UsesNodeBuilder> usesNodeBuilders = getModuleBuilder().getUsesNodes();
+        List<RefineHolder> refineHolders = null;
+        Set<DataSchemaNodeBuilder> dataSchemaNodeBuilders = null;
+        for (UsesNodeBuilder usesNodeBuilder : usesNodeBuilders) {
+            if (usesNodeBuilder.getGroupingPathAsString().equals("grp")) {
+                refineHolders = usesNodeBuilder.getRefines();
+                GroupingUtils.updateUsesParent(usesNodeBuilder);
+                dataSchemaNodeBuilders = usesNodeBuilder.getParent().getChildNodeBuilders();
+                break;
             }
         }
-        assertNotNull("Refine module wasn't found.", refineModule);
-        Set<DataSchemaNode> moduleChilds = refineModule.getChildNodes();
-        DataSchemaNode lflstNode = null;
-        DataSchemaNode chcNode = null;
-        DataSchemaNode chc2Node = null;
-        DataSchemaNode dataNode = null;
-        for (DataSchemaNode childNode : moduleChilds) {
-            if (childNode.getQName().getLocalName().equals("lflst")) {
-                lflstNode = childNode;
-            } else if (childNode.getQName().getLocalName().equals("chc")) {
-                chcNode = childNode;
-            } else if (childNode.getQName().getLocalName().equals("chc2")) {
-                chc2Node = childNode;
-            } else if (childNode.getQName().getLocalName().equals("data")) {
-                dataNode = childNode;
+
+        assertNotNull("List of refine holders wasn't initialized.", refineHolders);
+        assertEquals("Incorrect number of refine holders", 4, refineHolders.size());
+
+        checkLflstRefineHolderAndSchemaNodeBuilder("lflst", refineHolders, dataSchemaNodeBuilders);
+        checkChcRefineHolderAndSchemaNodeBuilder("chc", refineHolders, dataSchemaNodeBuilders);
+        checkChc2RefineHolderAndSchemaNodeBuilder("chc2", refineHolders, dataSchemaNodeBuilders);
+        checkAnyXmlRefineHolderAndSchemaNodeBuilder("data", refineHolders, dataSchemaNodeBuilders);
+    }
+
+    private ModuleBuilder getModuleBuilder() {
+        Class<YangParserImpl> cl = YangParserImpl.class;
+
+        YangParserImpl yangParserImpl = null;
+        yangParserImpl = new YangParserImpl();
+        assertNotNull("Instance of YangParserImpl isn't created", yangParserImpl);
+
+        Method methodResolveModuleBuilders = null;
+        try {
+            methodResolveModuleBuilders = cl.getDeclaredMethod("resolveModuleBuilders", List.class, Map.class);
+        } catch (NoSuchMethodException | SecurityException e1) {
+        }
+        assertNotNull("The method resolveModuleBuilders cannot be found", methodResolveModuleBuilders);
+
+        final Map<InputStream, File> inputStreams = Maps.newHashMap();
+
+        for (final File yangFile : testModels) {
+            try {
+                inputStreams.put(new FileInputStream(yangFile), yangFile);
+            } catch (FileNotFoundException e) {
             }
         }
+        assertEquals("Map with input streams contains incorrect number of files.", 1, inputStreams.size());
+
+        Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();
+        Map<String, Map<Date, ModuleBuilder>> modules = null;
+        try {
+            methodResolveModuleBuilders.setAccessible(true);
+            modules = (Map<String, Map<Date, ModuleBuilder>>) methodResolveModuleBuilders.invoke(yangParserImpl,
+                    Lists.newArrayList(inputStreams.keySet()), builderToStreamMap);
+        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+            e.printStackTrace();
+        }
+        assertEquals("Map with modules contains incorrect number of modules", 1, modules.size());
+        Map<Date, ModuleBuilder> mapWithModuleBuilder = modules.get("module-refine");
+        assertEquals("Map with module builders contains incorrect number of modules", 1, mapWithModuleBuilder.size());
+        Date date = new GregorianCalendar(2013, GregorianCalendar.SEPTEMBER, 11).getTime();
+        ModuleBuilder moduleBuilder = mapWithModuleBuilder.get(date);
+        assertNotNull("Module builder wasn't find", moduleBuilder);
+        return moduleBuilder;
+    }
+
+    private void checkAnyXmlRefineHolderAndSchemaNodeBuilder(String string, List<RefineHolder> refineHolders,
+            Set<DataSchemaNodeBuilder> dataSchemaNodeBuilders) {
+        RefineHolder refHolderData = getRefineHolder("data", refineHolders);
+
+        QName qname = createQname();
+        DataSchemaNodeBuilder builderData = new AnyXmlBuilder("module", 4, qname, createSchemaPath(qname));
+
+        assertNotNull("Refine holder data wasn't initialized.", refHolderData);
+        RefineUtils.refineAnyxml((AnyXmlBuilder) builderData, refHolderData, 3);
+
+        // data node
+        ConstraintsBuilder conDefData = builderData.getConstraints();
+        assertFalse("'data' has incorrect value for 'mandatory'", conDefData.isMandatory());
+
+        String unknownNodeDataValue = "some value from data";
+        String unknownNodeDataName = "new-subnode-data";
+        findUnknownNode(builderData, unknownNodeDataValue, unknownNodeDataName);
+        findMustConstraint(conDefData, "something-else = 9");
+
+    }
+
+    private void checkChc2RefineHolderAndSchemaNodeBuilder(String nodeName, List<RefineHolder> refineHolders,
+            Set<DataSchemaNodeBuilder> dataSchemaNodeBuilders) {
+        RefineHolder refHolderChc2 = getRefineHolder("chc2", refineHolders);
+
+        QName qname = createQname();
+        DataSchemaNodeBuilder builderChc2 = new ChoiceBuilder("module", 4, qname);
+        assertNotNull("Refine holder chc2 wasn't initialized.", refHolderChc2);
+
+        RefineUtils.refineChoice((ChoiceBuilder) builderChc2, refHolderChc2, 3);
+
+        // chc2 node
+        ConstraintsBuilder conDefChc2 = builderChc2.getConstraints();
+        assertFalse("'chc2' has incorrect value for 'mandatory'", conDefChc2.isMandatory());
+    }
+
+    private void checkChcRefineHolderAndSchemaNodeBuilder(String nodeName, List<RefineHolder> refineHolders,
+            Set<DataSchemaNodeBuilder> dataSchemaNodeBuilders) {
+        RefineHolder refHolderChc = getRefineHolder("chc", refineHolders);
+
+        QName qname = createQname();
+        DataSchemaNodeBuilder builderChc = new ChoiceBuilder("module", 4, qname);
+
+        assertNotNull("Refine holder chc wasn't initialized.", refHolderChc);
+        assertNotNull("Data schema node builder chc wasn't initialized.", builderChc);
+        RefineUtils.refineChoice((ChoiceBuilder) builderChc, refHolderChc, 2);
+
+        ChoiceBuilder choiceBuilder = null;
+        if (builderChc instanceof ChoiceBuilder) {
+            choiceBuilder = (ChoiceBuilder) builderChc;
+        }
+        assertNotNull("Choice node chc isn't of type ChoiceBuilder", choiceBuilder);
+        assertEquals("chc node has incorrect default node.", "first", choiceBuilder.getDefaultCase());
+        String unknownNodeChcValue = "some value from chc";
+        String unknownNodeChcName = "new-subnode-chc";
+        findUnknownNode(choiceBuilder, unknownNodeChcValue, unknownNodeChcName);
+    }
+
+    private void checkLflstRefineHolderAndSchemaNodeBuilder(String nodeName, List<RefineHolder> refineHolders,
+            Set<DataSchemaNodeBuilder> dataSchemaNodeBuilders) {
+        RefineHolder refHolderLflst = getRefineHolder(nodeName, refineHolders);
+
+        QName qname = createQname();
+        DataSchemaNodeBuilder builderLflst = new LeafListSchemaNodeBuilder("module", 4, qname, createSchemaPath(qname));
 
+        assertNotNull("Refine holder " + nodeName + " wasn't initialized.", refHolderLflst);
+        assertNotNull("Data schema node builder " + nodeName + " wasn't initialized.", builderLflst);
+        RefineUtils.refineLeafList((LeafListSchemaNodeBuilder) builderLflst, refHolderLflst, 1);
         // lflst node
-        assertNotNull("Node 'lflst' wasn't found.", lflstNode);
-        ConstraintDefinition conDefLflst = lflstNode.getConstraints();
-        assertEquals("Max elements number in 'lflst' is incorrect.", new Integer(64), conDefLflst.getMaxElements());
-        assertEquals("Max elements number in 'lflst' is incorrect.", new Integer(32), conDefLflst.getMinElements());
+
+        ConstraintsBuilder conDefLflst = builderLflst.getConstraints();
+        assertEquals("Max elements number in " + nodeName + " is incorrect.", new Integer(64),
+                conDefLflst.getMaxElements());
+        assertEquals("Max elements number in " + nodeName + " is incorrect.", new Integer(32),
+                conDefLflst.getMinElements());
 
         findMustConstraint(conDefLflst, "new = 57");
 
         boolean mustLflstFound = false;
-        for (MustDefinition mustDef : conDefLflst.getMustConstraints()) {
+        for (MustDefinition mustDef : conDefLflst.getMustDefinitions()) {
             if (mustDef.toString().equals("new = 57")) {
                 mustLflstFound = true;
                 break;
             }
         }
-        assertTrue("Must element in 'lflst' is missing.", mustLflstFound);
+        assertTrue("Must element in " + nodeName + " is missing.", mustLflstFound);
 
-        findUnknownNode(lflstNode, "some value from lflst", "new-subnode");
+        findUnknownNode(builderLflst, "some value from " + nodeName, "new-subnode");
 
-        // chc node
-        assertNotNull("Node 'chc' wasn't found.", chcNode);
-        ChoiceNode choiceNode = null;
-        if (chcNode instanceof ChoiceNode) {
-            choiceNode = (ChoiceNode) chcNode;
-        }
-        assertNotNull("Choice node chc isn't of type ChoiceNode", choiceNode);
-        assertEquals("chc node has incorrect default node.", "first", choiceNode.getDefaultCase());
-        String unknownNodeChcValue = "some value from chc";
-        String unknownNodeChcName = "new-subnode-chc";
-        findUnknownNode(chcNode, unknownNodeChcValue, unknownNodeChcName);
+    }
 
-        // chc2 node
-        assertNotNull("Node 'chc2' wasn't found.", chc2Node);
-        ConstraintDefinition conDefChc2 = chc2Node.getConstraints();
-        assertFalse("'chc2' has incorrect value for 'mandatory'", conDefChc2.isMandatory());
+    private RefineHolder getRefineHolder(String refHolderName, List<RefineHolder> refineHolders) {
+        for (RefineHolder refineHolder : refineHolders) {
+            if (refineHolder.getName().equals(refHolderName)) {
+                return refineHolder;
+            }
+        }
+        return null;
+    }
 
-        // data node
-        assertNotNull("Node 'data' wasn't found.", dataNode);
-        ConstraintDefinition conDefData = dataNode.getConstraints();
-        assertFalse("'data' has incorrect value for 'mandatory'", conDefData.isMandatory());
+    private QName createQname() {
+        QName qname = null;
+        boolean uriCreated = false;
+        try {
+            qname = new QName(new URI("uri"), "q name");
+            uriCreated = true;
+        } catch (URISyntaxException e) {
+        }
+        assertTrue("Qname wasn't created sucessfully.", uriCreated);
+        return qname;
+    }
 
-        String unknownNodeDataValue = "some value from data";
-        String unknownNodeDataName = "new-subnode-data";
-        findUnknownNode(dataNode, unknownNodeDataValue, unknownNodeDataName);
-        findMustConstraint(conDefData, "something-else = 9");
+    private SchemaPath createSchemaPath(QName qname) {
+        List<QName> qnames = new ArrayList<>();
+        qnames.add(createQname());
+        return new SchemaPath(qnames, true);
     }
+
 }

diff --git a/code-generator/binding-generator-impl/src/test/resources/refine.yang b/code-generator/binding-generator-impl/src/test/resources/refine.yang
index 46f51daa3711713527674578cbea3808cabef6e2..11115f87c9b7815ec541b03922afe61bce46ae24 100644 (file)
--- a/code-generator/binding-generator-impl/src/test/resources/refine.yang
+++ b/code-generator/binding-generator-impl/src/test/resources/refine.yang
@@ -6,7 +6,7 @@ module module-refine {
     organization "OPEN DAYLIGHT";
     contact "http://www.opendaylight.org/";
 
-    revision 2013-11-09 {
+    revision 2013-9-11 {
     }
 
     grouping grp {