added partical test files

Change-Id: I04e3bad4091e7b8446caffe1c298be01609ba829
Signed-off-by: saomenmen <zhangmroy@163.com>

diff --git a/nemo-impl/src/test/java/org/opendaylight/nemo/intent/action/ActionResolverUtilsTest.java b/nemo-impl/src/test/java/org/opendaylight/nemo/intent/action/ActionResolverUtilsTest.java
new file mode 100644 (file)
index 0000000..b3f9b5b
--- /dev/null
+++ b/nemo-impl/src/test/java/org/opendaylight/nemo/intent/action/ActionResolverUtilsTest.java
@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) 2015 Huawei, 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.nemo.intent.action;
+
+import junit.framework.TestCase;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+import org.junit.runner.RunWith;
+import org.opendaylight.nemo.intent.IntentResolverUtils;
+import org.opendaylight.nemo.intent.computation.VNMappingUnit;
+import org.opendaylight.nemo.intent.computation.VNMappingUnitUtils;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.networks.virtual.network.virtual.nodes.VirtualNode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.networks.virtual.network.virtual.paths.VirtualPath;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.networks.virtual.network.virtual.paths.VirtualPathBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.path.instance.VirtualLink;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.path.instance.VirtualLinkBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.intent.mapping.result.rev151010.intent.vn.mapping.results.user.intent.vn.mapping.IntentVnMappingResult;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.intent.mapping.result.rev151010.intent.vn.mapping.results.user.intent.vn.mapping.intent.vn.mapping.result.VirtualResource;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.*;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.PropertyValues;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.engine.common.rev151010.VirtualLinkId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.engine.common.rev151010.VirtualNodeId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.engine.common.rev151010.VirtualPathId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.Flow;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.Node;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.flow.instance.MatchItem;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.node.instance.Property;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.property.values.StringValue;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.operation.instance.Action;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.match.item.instance.MatchItemValue;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.engine.common.rev151010.VirtualResourceEntityId;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.api.support.membermodification.MemberMatcher;
+import org.powermock.api.support.membermodification.MemberModifier;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.UUID;
+import static org.mockito.Mockito.*;
+/**
+ * Created by zhangmeng on 2015/12/25.
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({ActionResolverUtils.class,IntentResolverUtils.class})
+public class ActionResolverUtilsTest extends TestCase {
+    private ActionResolverUtils actionResolverUtils;
+    @Before
+    public void setUp() throws Exception {
+        actionResolverUtils = new ActionResolverUtils();
+    }
+
+    @Test
+    public void testGetAction() throws Exception {
+        List<Action> actions = new ArrayList<Action>();
+        ActionName actionName = mock(ActionName.class);
+        Action action = mock(Action.class);
+
+        actions.add(action);
+
+        when(action.getActionName())
+                .thenReturn(mock(ActionName.class))
+                .thenReturn(actionName);
+
+        Assert.assertTrue(ActionResolverUtils.getAction(actions,actionName) == null);
+        Assert.assertTrue(ActionResolverUtils.getAction(actions,actionName) == action);
+
+    }
+
+    @Test
+    public void testModifyVirtualLinkBandwidth() throws Exception {
+        List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.networks.virtual.network.virtual.links.VirtualLink>
+                virtualLinks = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.networks.virtual.network.virtual.links.VirtualLink>();
+        VirtualLinkId virtualLinkId = mock(VirtualLinkId.class);
+        org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.networks.virtual.network.virtual.links.VirtualLink
+                virtualLink = mock(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.networks.virtual.network.virtual.links.VirtualLink.class);
+        long bandwidth = 1L;
+
+        virtualLinks.add(virtualLink);
+
+        when(virtualLink.getLinkId())
+                .thenReturn(mock(VirtualLinkId.class))
+                .thenReturn(virtualLinkId);
+
+        ActionResolverUtils.modifyVirtualLinkBandwidth(virtualLinks, virtualLinkId, bandwidth);
+        ActionResolverUtils.modifyVirtualLinkBandwidth(virtualLinks,virtualLinkId,bandwidth);
+        verify(virtualLink, times(4)).getLinkId();
+    }
+
+    @Test
+    public void testSortVirtualResources() throws Exception {
+        List<VirtualResource> virtualResources = new ArrayList<VirtualResource>();
+        Assert.assertTrue(ActionResolverUtils.sortVirtualResources(virtualResources) == virtualResources);
+
+        VirtualResource virtualResource = mock(VirtualResource.class);
+        VirtualResource virtualResource1 = mock(VirtualResource.class);
+
+        virtualResources.add(virtualResource);
+        virtualResources.add(virtualResource1);
+
+        when(virtualResource.getOrder()).thenReturn(1L);
+        when(virtualResource1.getOrder()).thenReturn(0L);
+        Assert.assertTrue(ActionResolverUtils.sortVirtualResources(virtualResources).get(0) == virtualResource1);
+    }
+
+    @Test
+    public void testSortParameterValues() throws Exception {
+        List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValue>
+                parameterValues = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValue>();
+        Assert.assertTrue(ActionResolverUtils.sortParameterValues(parameterValues) == parameterValues);
+
+        org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValue
+                parameterValue = mock(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValue.class);
+        org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValue
+                parameterValue1 = mock(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValue.class);
+
+        parameterValues.add(parameterValue);
+        parameterValues.add(parameterValue1);
+
+        when(parameterValue.getOrder()).thenReturn(1L);
+        when(parameterValue1.getOrder()).thenReturn(0L);
+        Assert.assertTrue(ActionResolverUtils.sortParameterValues(parameterValues).get(0) == parameterValue1);
+    }
+
+    @Test
+    public void testGetSourceVirtualRouterOfFlow() throws Exception {
+        List<VirtualNode> virtualNodes = new ArrayList<VirtualNode>();
+        VirtualNode virtualNode = mock(VirtualNode.class);
+        Flow flow = mock(Flow.class);
+        NodeId nodeId = mock(NodeId.class);
+        Node node = mock(Node.class);
+        Property property = mock(Property.class);
+        VirtualResource virtualResource = mock(VirtualResource.class);
+        PropertyValues propertyValues_temp = mock(PropertyValues.class);
+        MatchItem matchItem = mock(MatchItem.class);
+        StringValue stringValue = mock(StringValue.class);
+        MatchItemValue matchItemValue = mock(MatchItemValue.class);
+        IntentVnMappingResult intentVnMappingResult = mock(IntentVnMappingResult.class);
+        VirtualResourceEntityId virtualResourceEntityId = mock(VirtualResourceEntityId.class);
+
+        List<Property> propertyList = new ArrayList<Property>();
+        List<Node> nodes = new ArrayList<Node>();
+        List<IntentVnMappingResult> intentVnMappingResults = new ArrayList<IntentVnMappingResult>();
+        List<MatchItem> matchItems = new ArrayList<MatchItem>();
+        List<StringValue> propertyValues = new ArrayList<StringValue>();
+        List<VirtualResource> virtualResourceList = new ArrayList<VirtualResource>();
+
+        matchItems.add(matchItem);
+        intentVnMappingResults.add(intentVnMappingResult);
+        nodes.add(node);
+        virtualNodes.add(virtualNode);
+        propertyValues.add(stringValue);
+        virtualResourceList.add(virtualResource);
+
+        //get into method "getMatchItem" args(matchItems ,new MatchItemName("src-ip"))
+        when(flow.getMatchItem()).thenReturn(matchItems);
+        when(matchItem.getMatchItemName())
+                .thenReturn(mock(MatchItemName.class))
+                .thenReturn(new MatchItemName("src-ip"));
+        //return null
+        Assert.assertTrue(ActionResolverUtils.getSourceVirtualRouterOfFlow(virtualNodes, flow, nodes, intentVnMappingResults) == null);
+        //not null
+        when(matchItem.getMatchItemValue()).thenReturn(matchItemValue);
+        when(matchItemValue.getStringValue()).thenReturn(new String("test"));
+        //get into method "getVirtualRouterWithIpPrefix" args(virtualNodes,matchItemValue,nodes, intentVnMappingResults)
+        when(node.getNodeType()).thenReturn(new NodeType("l2-group"));
+        when(node.getProperty()).thenReturn(propertyList);
+        PowerMockito.mockStatic(IntentResolverUtils.class);
+        PowerMockito.when(IntentResolverUtils.getNodeProperty(any(List.class), any(PropertyName.class))).thenReturn(property);
+        when(property.getPropertyValues()).thenReturn(propertyValues_temp);
+        when(propertyValues_temp.getStringValue()).thenReturn(propertyValues);
+        when(stringValue.getValue()).thenReturn(new String("test"));
+        when(node.getNodeId()).thenReturn(nodeId);
+        when(nodeId.getValue()).thenReturn(new String("00001111-0000-0000-0000-000011112222"));
+        PowerMockito.when(IntentResolverUtils.getIntentVnMappingResult(intentVnMappingResults, new IntentId(node.getNodeId().getValue())))
+                .thenReturn(intentVnMappingResult);
+        when(intentVnMappingResult.getVirtualResource()).thenReturn(virtualResourceList);
+        when(virtualResource.getVirtualResourceType()).thenReturn(VirtualResource.VirtualResourceType.Vport);
+        when(virtualResource.getParentVirtualResourceEntityId()).thenReturn(virtualResourceEntityId);
+        when(virtualResourceEntityId.getValue()).thenReturn(new String("00001111-1111-0000-0000-000011112222"));
+        PowerMockito.when(IntentResolverUtils.getVirtualNode(any(List.class), any(VirtualNodeId.class)))
+                .thenReturn(virtualNode);
+        when(virtualNode.getNodeType()).thenReturn(VirtualNode.NodeType.Vrouter);
+        Assert.assertTrue(ActionResolverUtils.getSourceVirtualRouterOfFlow(virtualNodes, flow, nodes, intentVnMappingResults) != null);
+
+    }
+
+    @Test
+    public void testGetDestinationVirtualRouterOfFlow() throws Exception {
+        List<VirtualNode> virtualNodes = new ArrayList<VirtualNode>();
+        Flow flow = mock(Flow.class);
+        List<Node> nodes = new ArrayList<Node>();
+        List<IntentVnMappingResult> intentVnMappingResults = new ArrayList<IntentVnMappingResult>();
+
+        MatchItem matchItem = mock(MatchItem.class);
+        MatchItemValue matchItemValue = mock(MatchItemValue.class);
+        List<MatchItem> matchItems = new ArrayList<MatchItem>();
+
+        matchItems.add(matchItem);
+
+        when(flow.getMatchItem()).thenReturn(matchItems);
+        when(matchItem.getMatchItemName())
+                .thenReturn(mock(MatchItemName.class))
+                .thenReturn(new MatchItemName("dst-ip"));
+        //test null
+        Assert.assertTrue(ActionResolverUtils.getDestinationVirtualRouterOfFlow(virtualNodes, flow, nodes, intentVnMappingResults) == null);
+
+        when(matchItem.getMatchItemValue()).thenReturn(matchItemValue);
+        when(matchItemValue.getStringValue()).thenReturn(new String("test"));
+        //get into method "getVirtualRouterWithIpPrefix" args(virtualNodes,matchItemValue,nodes, intentVnMappingResults)
+        //return null
+        Assert.assertTrue(ActionResolverUtils.getDestinationVirtualRouterOfFlow(virtualNodes, flow, nodes, intentVnMappingResults) == null);
+
+    }
+
+    @Test
+    public void testMergeVirtualPaths() throws Exception {
+        List<VirtualPath> virtualPaths = new ArrayList<VirtualPath>();
+
+        VirtualPath virtualPath = mock(VirtualPath.class);
+        VirtualPath virtualPath1 = mock(VirtualPath.class);
+        VirtualLink virtualLink = mock(VirtualLink.class);
+        List<VirtualLink> virtualLinkList = new ArrayList<VirtualLink>();
+        
+        virtualLinkList.add(virtualLink);
+        
+        // when virtualPaths is empty
+        Assert.assertTrue(ActionResolverUtils.mergeVirtualPaths(virtualPaths) != null);
+        // size 1
+        virtualPaths.add(virtualPath);
+        Assert.assertTrue(ActionResolverUtils.mergeVirtualPaths(virtualPaths) == virtualPath);
+        // size >1
+        virtualPaths.add(virtualPath1);
+        when(virtualPath.getVirtualLink()).thenReturn(virtualLinkList);
+        when(virtualPath1.getVirtualLink()).thenReturn(virtualLinkList);
+        when(virtualPath.getMetric()).thenReturn(1L);
+        when(virtualPath.getDelay()).thenReturn(1L);
+        when(virtualPath1.getMetric()).thenReturn(1L);
+        when(virtualPath1.getDelay()).thenReturn(1L);
+        when(virtualPath.getBandwidth()).thenReturn(1L);
+        when(virtualPath1.getBandwidth()).thenReturn(1L);
+        Assert.assertTrue(ActionResolverUtils.mergeVirtualPaths(virtualPaths) != null);
+        verify(virtualPath).getMetric();
+        verify(virtualPath1).getMetric();
+
+    }
+}
\ No newline at end of file

diff --git a/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/deleteintentlang/DeleteConnectionLangTest.java b/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/deleteintentlang/DeleteConnectionLangTest.java
new file mode 100644 (file)
index 0000000..9e9f6e6
--- /dev/null
+++ b/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/deleteintentlang/DeleteConnectionLangTest.java
@@ -0,0 +1,59 @@
+/*\r
+ * Copyright (c) 2015 Huawei, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+package org.opendaylight.nemo.user.vnspacemanager.languagestyle.deleteintentlang;\r
+\r
+import junit.framework.TestCase;\r
+import org.junit.Assert;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.nemo.user.tenantmanager.TenantManage;\r
+import org.opendaylight.nemo.user.vnspacemanager.structurestyle.deleteintent.DeleteConnection;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.ConnectionId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.UserId;\r
+\r
+import java.lang.reflect.Field;\r
+\r
+import static org.mockito.Mockito.*;\r
+/**\r
+ * Created by zhangmeng on 2015/12/28.\r
+ */\r
+public class DeleteConnectionLangTest extends TestCase {\r
+    private DataBroker dataBroker;\r
+    private TenantManage tenantManage;\r
+    private DeleteConnectionLang deleteConnectionLang;\r
+    @Before\r
+    public void setUp() throws Exception {\r
+        dataBroker = mock(DataBroker.class);\r
+        tenantManage = mock(TenantManage.class);\r
+\r
+        deleteConnectionLang = new DeleteConnectionLang(dataBroker,tenantManage);\r
+    }\r
+\r
+    @Test\r
+    public void testDeleteConnectionHandling() throws Exception {\r
+        Class<DeleteConnectionLang> class1 = DeleteConnectionLang.class;\r
+        Field field = class1.getDeclaredField("deleteConnection");\r
+        field.setAccessible(true);\r
+\r
+        UserId userId = mock(UserId.class);\r
+        String connectionname = new String("test");\r
+\r
+        DeleteConnection deleteConnection = mock(DeleteConnection.class);\r
+\r
+        when(tenantManage.getObjectId(userId,connectionname))\r
+                .thenReturn(null)\r
+                .thenReturn(new String("00001111-0000-0000-0000-000011112222"));\r
+        field.set(deleteConnectionLang, deleteConnection);\r
+        when(deleteConnection.DeleteConnectionHandling(any(UserId.class),any(ConnectionId.class))).thenReturn(new String("test"));\r
+\r
+        Assert.assertTrue(deleteConnectionLang.DeleteConnectionHandling(userId, connectionname).equals("The connection " + connectionname + " is not exist."));\r
+        Assert.assertTrue(deleteConnectionLang.DeleteConnectionHandling(userId,connectionname).equals("test"));\r
+        verify(tenantManage,times(3)).getObjectId(userId,connectionname);\r
+    }\r
+}
\ No newline at end of file

diff --git a/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/deleteintentlang/DeleteFlowLangTest.java b/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/deleteintentlang/DeleteFlowLangTest.java
new file mode 100644 (file)
index 0000000..1374ffa
--- /dev/null
+++ b/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/deleteintentlang/DeleteFlowLangTest.java
@@ -0,0 +1,59 @@
+/*\r
+ * Copyright (c) 2015 Huawei, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+package org.opendaylight.nemo.user.vnspacemanager.languagestyle.deleteintentlang;\r
+\r
+import junit.framework.TestCase;\r
+import org.junit.Assert;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.nemo.user.tenantmanager.TenantManage;\r
+import org.opendaylight.nemo.user.vnspacemanager.structurestyle.deleteintent.DeleteFlow;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.FlowId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.UserId;\r
+\r
+import java.lang.reflect.Field;\r
+\r
+import static org.mockito.Mockito.*;\r
+/**\r
+ * Created by zhangmeng on 2015/12/28.\r
+ */\r
+public class DeleteFlowLangTest extends TestCase {\r
+    private DataBroker dataBroker;\r
+    private TenantManage tenantManage;\r
+    private DeleteFlowLang deleteFlowLang;\r
+    @Before\r
+    public void setUp() throws Exception {\r
+        dataBroker = mock(DataBroker.class);\r
+        tenantManage = mock(TenantManage.class);\r
+\r
+        deleteFlowLang = new DeleteFlowLang(dataBroker,tenantManage);\r
+    }\r
+\r
+    @Test\r
+    public void testDeleteFlowHandling() throws Exception {\r
+        Class<DeleteFlowLang> class1 = DeleteFlowLang.class;\r
+        Field field = class1.getDeclaredField("deleteFlow");\r
+        field.setAccessible(true);\r
+\r
+        UserId userId = mock(UserId.class);\r
+        String flowname = new String("test");\r
+        DeleteFlow deleteFlow = mock(DeleteFlow.class);\r
+\r
+        when(tenantManage.getObjectId(userId,flowname))\r
+                .thenReturn(null)\r
+                .thenReturn("00001111-0000-0000-0000-000011112222");\r
+\r
+        Assert.assertTrue(deleteFlowLang.DeleteFlowHandling(userId, flowname).equals("The flow " + flowname + " is not exist."));\r
+\r
+        field.set(deleteFlowLang, deleteFlow);\r
+        when(deleteFlow.DeleteFlowHandling(any(UserId.class),any(FlowId.class))).thenReturn(new String("test"));\r
+        Assert.assertTrue(deleteFlowLang.DeleteFlowHandling(userId, flowname).equals("test"));\r
+\r
+    }\r
+}
\ No newline at end of file

diff --git a/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/deleteintentlang/DeleteNodeLangTest.java b/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/deleteintentlang/DeleteNodeLangTest.java
new file mode 100644 (file)
index 0000000..0f1a28b
--- /dev/null
+++ b/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/deleteintentlang/DeleteNodeLangTest.java
@@ -0,0 +1,61 @@
+/*\r
+ * Copyright (c) 2015 Huawei, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+package org.opendaylight.nemo.user.vnspacemanager.languagestyle.deleteintentlang;\r
+\r
+import junit.framework.TestCase;\r
+import org.junit.Assert;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.nemo.user.tenantmanager.TenantManage;\r
+import org.opendaylight.nemo.user.vnspacemanager.structurestyle.deleteintent.DeleteNode;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.NodeId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.UserId;\r
+\r
+import java.lang.reflect.Field;\r
+\r
+import static org.mockito.Mockito.*;\r
+/**\r
+ * Created by zhangmeng on 2015/12/28.\r
+ */\r
+public class DeleteNodeLangTest extends TestCase {\r
+    private DataBroker dataBroker;\r
+    private TenantManage tenantManage;\r
+    private DeleteNodeLang deleteNodeLang;\r
+    @Before\r
+    public void setUp() throws Exception {\r
+        dataBroker = mock(DataBroker.class);\r
+        tenantManage = mock(TenantManage.class);\r
+\r
+        deleteNodeLang = new DeleteNodeLang(dataBroker,tenantManage);\r
+    }\r
+\r
+    @Test\r
+    public void testDeleteNodeHandling() throws Exception {\r
+        Class<DeleteNodeLang> class1 = DeleteNodeLang.class;\r
+        Field field = class1.getDeclaredField("deleteNode");\r
+        field.setAccessible(true);\r
+\r
+        UserId userId = mock(UserId.class);\r
+        String nodename = new String("test");\r
+        DeleteNode deleteNode = mock(DeleteNode.class);\r
+\r
+        when(tenantManage.getObjectId(userId,nodename))\r
+                .thenReturn(null)\r
+                .thenReturn(new String("00001111-0000-0000-0000-000011112222"));\r
+        Assert.assertTrue(deleteNodeLang.DeleteNodeHandling(userId, nodename).equals("The node " + nodename + " is not exist."));\r
+        verify(tenantManage).getObjectId(userId, nodename);\r
+\r
+        field.set(deleteNodeLang, deleteNode);\r
+        when(deleteNode.DeleNodeHandling(any(UserId.class),any(NodeId.class))).thenReturn(new String("test"));\r
+        Assert.assertTrue(deleteNodeLang.DeleteNodeHandling(userId, nodename).equals("test"));\r
+        verify(tenantManage,times(3)).getObjectId(userId, nodename);\r
+\r
+    }\r
+}
\ No newline at end of file

diff --git a/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/deleteintentlang/DeleteOperationLangTest.java b/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/deleteintentlang/DeleteOperationLangTest.java
new file mode 100644 (file)
index 0000000..2e4a72c
--- /dev/null
+++ b/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/deleteintentlang/DeleteOperationLangTest.java
@@ -0,0 +1,62 @@
+/*\r
+ * Copyright (c) 2015 Huawei, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+package org.opendaylight.nemo.user.vnspacemanager.languagestyle.deleteintentlang;\r
+\r
+import junit.framework.TestCase;\r
+import org.junit.Assert;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.nemo.user.tenantmanager.TenantManage;\r
+import org.opendaylight.nemo.user.vnspacemanager.structurestyle.deleteintent.DeleteOperation;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.OperationId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.UserId;\r
+\r
+import java.lang.reflect.Field;\r
+\r
+import static org.mockito.Mockito.*;\r
+\r
+/**\r
+ * Created by zhangmeng on 2015/12/28.\r
+ */\r
+public class DeleteOperationLangTest extends TestCase {\r
+    private DataBroker dataBroker;\r
+    private TenantManage tenantManage;\r
+    private DeleteOperationLang deleteOperationLang;\r
+    @Before\r
+    public void setUp() throws Exception {\r
+        dataBroker = mock(DataBroker.class);\r
+        tenantManage = mock(TenantManage.class);\r
+\r
+        deleteOperationLang = new DeleteOperationLang(dataBroker,tenantManage);\r
+    }\r
+\r
+    @Test\r
+    public void testDeleteOperationHandling() throws Exception {\r
+        Class<DeleteOperationLang> class1 = DeleteOperationLang.class;\r
+        Field field = class1.getDeclaredField("deleteOperation");\r
+        field.setAccessible(true);\r
+\r
+        UserId userId = mock(UserId.class);\r
+        String operationname = new String("test");\r
+        DeleteOperation deleteOperation = mock(DeleteOperation.class);\r
+\r
+        when(tenantManage.getObjectId(userId,operationname))\r
+                .thenReturn(null)\r
+                .thenReturn(new String("00001111-0000-0000-0000-000011112222"));\r
+        Assert.assertTrue(deleteOperationLang.DeleteOperationHandling(userId, operationname).equals("The operation " + operationname + " is not exist."));\r
+        verify(tenantManage).getObjectId(userId, operationname);\r
+\r
+        field.set(deleteOperationLang, deleteOperation);\r
+        when(deleteOperation.DeleteOperationhandling(any(UserId.class),any(OperationId.class))).thenReturn(new String("test"));\r
+        Assert.assertTrue(deleteOperationLang.DeleteOperationHandling(userId, operationname).equals("test"));\r
+        verify(tenantManage,times(3)).getObjectId(userId, operationname);\r
+\r
+    }\r
+}
\ No newline at end of file

diff --git a/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/structurestyle/updateintent/UpdateTemplateDefinitionTest.java b/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/structurestyle/updateintent/UpdateTemplateDefinitionTest.java
new file mode 100644 (file)
index 0000000..5eeb99e
--- /dev/null
+++ b/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/structurestyle/updateintent/UpdateTemplateDefinitionTest.java
@@ -0,0 +1,413 @@
+/*
+ * Copyright (c) 2015 Huawei, 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.nemo.user.vnspacemanager.structurestyle.updateintent;
+
+import junit.framework.TestCase;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.ParameterValues;
+import static org.junit.Assert.*;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.nemo.user.tenantmanager.TenantManage;
+import org.opendaylight.nemo.user.vnspacemanager.structurestyle.updateintent.GetDefinitions;
+import org.opendaylight.nemo.user.vnspacemanager.structurestyle.updateintent.UpdateTemplateDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.PropertyName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.match.item.instance.MatchItemValue;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.*;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.PropertyValues;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.definitions.ConnectionDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.EndNode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.flow.instance.MatchItem;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.match.item.definitions.MatchItemDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.node.definitions.NodeDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.node.instance.Property;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.node.instance.SubNode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.definitions.PropertyDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.property.values.StringValue;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.definitions.ActionDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.instance.ConditionSegment;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.parameter.definitions.ConditionParameterDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.operation.instance.Action;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping.AbstractIntents;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping.TemplateParameter;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.objects.AbstractConnection;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.objects.AbstractFlow;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.objects.AbstractNode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.operations.AbstractOperation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.ConditionParameterName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.instance.condition.segment.ConditionParameterTargetValue;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.TemplateName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents.AbstractObjects;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import static org.mockito.Mockito.*;
+/**
+ * Created by zhangmeng on 2015/12/28.
+ */
+public class UpdateTemplateDefinitionTest extends TestCase {
+    private DataBroker dataBroker;
+    private TenantManage tenantManage;
+    private UpdateTemplateDefinition updateTemplateDefinition;
+    private Class<UpdateTemplateDefinition> class1;
+    private Field field;
+    private Method method;
+    @Before
+    public void setUp() throws Exception {
+        class1 = UpdateTemplateDefinition.class;
+        dataBroker = mock(DataBroker.class);
+        tenantManage = mock(TenantManage.class);
+
+        updateTemplateDefinition = new UpdateTemplateDefinition(dataBroker,tenantManage);
+    }
+
+    @Test
+    public void testCheckTemplateDefinition() throws Exception {
+        field = class1.getDeclaredField("getDefinitions");
+        field.setAccessible(true);
+
+        GetDefinitions getDefinitions = mock(GetDefinitions.class);
+        UserId userId = mock(UserId.class);
+        NodeId nodeId = mock(NodeId.class);
+        SubNode subNode = mock(SubNode.class);
+        EndNode endNode = mock(EndNode.class);
+        TemplateDefinition templateDefinition = mock(TemplateDefinition.class);
+        TemplateName templateName = mock(TemplateName.class);
+        ParameterName parameterName = mock(ParameterName.class);
+        AbstractIntents abstractIntents = mock(AbstractIntents.class);
+        TemplateParameter.ParameterValueType parameterValueType = TemplateParameter.ParameterValueType.Int;
+        TemplateParameter templateParameter = mock(TemplateParameter.class);
+        AbstractObjects abstractObjects = mock(AbstractObjects.class);
+        AbstractNode node = mock(AbstractNode.class);
+        AbstractNode node1 = mock(AbstractNode.class);
+        NodeType nodeType = mock(NodeType.class);
+        NodeDefinition nodeDefinition = mock(NodeDefinition.class);
+        AbstractConnection connection = mock(AbstractConnection.class);
+        List<PropertyDefinition> propertyDefinitions = new ArrayList<PropertyDefinition>();
+        List<TemplateParameter> list = new ArrayList<TemplateParameter>();
+        List<AbstractNode> nodeList = new ArrayList<AbstractNode>();
+        List<SubNode> subNodeList = new ArrayList<SubNode>();
+        List<EndNode> endNodeList = new ArrayList<EndNode>();
+        List<AbstractNode> nodeList1 = new ArrayList<AbstractNode>();
+        List<AbstractConnection> connectionList = new ArrayList<AbstractConnection>();
+        Map<TemplateName, TemplateDefinition> map = mock(Map.class);
+        Map<NodeType, NodeDefinition> nodeDefinitions = mock(Map.class);
+        Map<ConnectionType, ConnectionDefinition> connDefinitions =mock(Map.class);
+        field.set(updateTemplateDefinition, getDefinitions);
+//        nodeDefinitions.put(nodeType, nodeDefinition);
+        list.add(templateParameter);
+        endNodeList.add(endNode);
+        nodeList.add(node);
+        nodeList1.add(node1);
+        subNodeList.add(subNode);
+        connectionList.add(connection);
+
+        when(getDefinitions.getNodeDefinition()).thenReturn(nodeDefinitions);
+        when(tenantManage.getTempalteDefinition(userId))
+                .thenReturn(map)
+                .thenReturn(map)
+                .thenReturn(null);
+        when(templateDefinition.getTemplateName()).thenReturn(templateName);
+        when(templateName.getValue()).thenReturn("test");
+        when(map.containsKey(templateDefinition.getTemplateName())).thenReturn(true);
+        Assert.assertTrue(updateTemplateDefinition.checkTemplateDefinition(userId, templateDefinition).equals("The template " + templateDefinition.getTemplateName().getValue() + " has been defined."));
+        verify(tenantManage, times(2)).getTempalteDefinition(userId);
+        when(templateDefinition.getTemplateParameter()).thenReturn(list);
+        when(templateParameter.getParameterName()).thenReturn(parameterName);
+        when(templateParameter.getParameterValueType()).thenReturn(parameterValueType);
+        when(templateDefinition.getAbstractIntents()).thenReturn(abstractIntents);
+        when(abstractIntents.getAbstractObjects()).thenReturn(abstractObjects);
+        when(abstractObjects.getAbstractNode()).thenReturn(nodeList);
+        when(node.getNodeId()).thenReturn(nodeId);
+        when(node.getSubNode()).thenReturn(subNodeList);
+        when(subNode.getNodeId())
+                .thenReturn(mock(NodeId.class))
+                .thenReturn(nodeId);
+        Assert.assertTrue(updateTemplateDefinition.checkTemplateDefinition(userId, templateDefinition).equals("The sub node is not defined."));
+        //get into method "checkNodeTemplate" args(node,map) map(parameterName,parameterValueType)
+        when(node.getNodeType()).thenReturn(nodeType);
+        when(nodeDefinitions.containsKey(node.getNodeType())).thenReturn(true);
+        when(nodeDefinitions.get(node.getNodeType())).thenReturn(nodeDefinition);
+        when(nodeDefinition.getPropertyDefinition()).thenReturn(null);
+        when(node.getProperty()).thenReturn(null);
+        //return
+
+    }
+
+    @Test
+    public void testCheckNodeTemplate() throws Exception{
+        method = class1.getDeclaredMethod("checkNodeTemplate",new Class[]{
+                AbstractNode.class,
+                Map.class
+        });
+        method.setAccessible(true);
+        field = class1.getDeclaredField("getDefinitions");
+        field.setAccessible(true);
+
+        GetDefinitions getDefinitions = mock(GetDefinitions.class);
+        AbstractNode node = mock(AbstractNode.class);
+        NodeType nodeType = mock(NodeType.class);
+        NodeDefinition nodeDefinition = mock(NodeDefinition.class);
+        PropertyName propertyName = mock(PropertyName.class);
+        Property property = mock(Property.class);
+        StringValue stringValue = mock(StringValue.class);
+        PropertyValues propertyValues = mock(PropertyValues.class);
+        PropertyDefinition.PropertyValueType type = PropertyDefinition.PropertyValueType.String;
+        PropertyDefinition propertyDefinition = mock(PropertyDefinition.class);
+        TemplateParameter.ParameterValueType valueType = TemplateParameter.ParameterValueType.Int;
+        List<Property> properties = new ArrayList<Property>();
+        List<StringValue> stringValues = new ArrayList<StringValue>();
+        List<PropertyDefinition> propertyDefinitions = new ArrayList<PropertyDefinition>();
+        Map<ParameterName, TemplateParameter.ParameterValueType> parameterValueTypeMap = new HashMap<ParameterName, TemplateParameter.ParameterValueType>();
+        Map<NodeType, NodeDefinition> nodeDefinitions = new HashMap<NodeType, NodeDefinition>();
+
+        parameterValueTypeMap.put(new ParameterName("ParameterName"),valueType);
+
+        field.set(updateTemplateDefinition, getDefinitions);
+        when(getDefinitions.getNodeDefinition()).thenReturn(nodeDefinitions);
+        when(node.getNodeType()).thenReturn(nodeType);
+        when(nodeType.getValue()).thenReturn("test");
+        //test null
+        Assert.assertTrue(method.invoke(updateTemplateDefinition,node,parameterValueTypeMap).equals("The node type " + node.getNodeType().getValue() + " is not defined."));
+        verify(node,times(3)).getNodeType();
+        //test not null
+        nodeDefinitions.put(nodeType, nodeDefinition);
+        propertyDefinitions.add(propertyDefinition);
+        properties.add(property);
+        stringValues.add(stringValue);
+        Assert.assertTrue(nodeDefinitions.get(nodeType) == nodeDefinition);
+        when(nodeDefinition.getPropertyDefinition()).thenReturn(propertyDefinitions);
+        when(propertyDefinition.getPropertyName()).thenReturn(propertyName);
+        when(propertyName.getValue()).thenReturn("test");
+        when(node.getProperty())
+                .thenReturn(null)
+                .thenReturn(properties);
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, node, parameterValueTypeMap) == null);
+        when(property.getPropertyName())
+                .thenReturn(mock(PropertyName.class))
+                .thenReturn(propertyName);
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, node, parameterValueTypeMap).equals("The property name " + property.getPropertyName().getValue() + " is not defined."));
+        when(propertyDefinition.getPropertyValueType())
+                .thenReturn(PropertyDefinition.PropertyValueType.Int)
+                .thenReturn(type);
+//        System.out.println("type" + type.getIntValue());
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, node, parameterValueTypeMap) == null);
+        when(property.getPropertyValues()).thenReturn(propertyValues);
+        when(propertyValues.getStringValue()).thenReturn(stringValues);
+        when(stringValue.getValue()).thenReturn(new String("ParameterName"));
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, node, parameterValueTypeMap).equals("The property " + property.getPropertyName().getValue() + " type is not right."));
+
+    }
+
+    @Test
+    public void testCheckConnectionTemplate() throws Exception{
+        method = class1.getDeclaredMethod("checkConnectionTemplate", new Class[]{
+                AbstractConnection.class,
+                Map.class
+        });
+        method.setAccessible(true);
+        field = class1.getDeclaredField("getDefinitions");
+        field.setAccessible(true);
+
+        GetDefinitions getDefinitions = mock(GetDefinitions.class);
+        AbstractConnection connection = mock(AbstractConnection.class);
+        ConnectionDefinition connectionDefinition = mock(ConnectionDefinition.class);
+        ConnectionType connectionType = mock(ConnectionType.class);
+        PropertyDefinition propertyDefinition = mock(PropertyDefinition.class);
+        PropertyName propertyName = mock(PropertyName.class);
+        PropertyValues propertyValues = mock(PropertyValues.class);
+        StringValue stringValue = mock(StringValue.class);
+        PropertyDefinition.PropertyValueType type = PropertyDefinition.PropertyValueType.String;
+        TemplateParameter.ParameterValueType valueType = TemplateParameter.ParameterValueType.Int;
+        org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.Property
+                property = mock(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.Property.class);
+        List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.Property>
+                properties = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.Property>();
+        List<PropertyDefinition> propertyDefinitions = new ArrayList<PropertyDefinition>();
+        List<StringValue> stringValues = new ArrayList<StringValue>();
+        Map<ParameterName, TemplateParameter.ParameterValueType> parameterValueTypeMap = new HashMap<ParameterName, TemplateParameter.ParameterValueType>();
+        Map<ConnectionType, ConnectionDefinition> connDefinitions = new HashMap<ConnectionType, ConnectionDefinition>();
+
+        field.set(updateTemplateDefinition, getDefinitions);
+        propertyDefinitions.add(propertyDefinition);
+        properties.add(property);
+        stringValues.add(stringValue);
+        parameterValueTypeMap.put(new ParameterName("ParameterName"), valueType);
+
+        when(getDefinitions.getConnectionDefinition()).thenReturn(connDefinitions);
+        when(connection.getConnectionType()).thenReturn(connectionType);
+        when(connectionType.getValue()).thenReturn("test");
+        //test null
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, connection, parameterValueTypeMap).equals("The connection type " + connection.getConnectionType().getValue() + " is not defined."));
+        //test not null
+        connDefinitions.put(connectionType, connectionDefinition);
+        when(connectionDefinition.getPropertyDefinition()).thenReturn(propertyDefinitions);
+        when(propertyDefinition.getPropertyName()).thenReturn(propertyName);
+        when(connection.getProperty())
+                .thenReturn(null)
+                .thenReturn(properties);
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, connection, parameterValueTypeMap) == null);
+        when(property.getPropertyName())
+                .thenReturn(mock(PropertyName.class))
+                .thenReturn(propertyName);
+        when(propertyName.getValue()).thenReturn("test");
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, connection, parameterValueTypeMap).equals("The property name " + property.getPropertyName().getValue() + " is not defined."));
+        Assert.assertTrue(type.getIntValue() == 0);
+        when(propertyDefinition.getPropertyValueType())
+                .thenReturn(PropertyDefinition.PropertyValueType.Int)
+                .thenReturn(type);
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, connection, parameterValueTypeMap) == null);
+        verify(propertyDefinition).getPropertyValueType();
+        when(property.getPropertyValues()).thenReturn(propertyValues);
+        when(propertyValues.getStringValue()).thenReturn(stringValues);
+        when(stringValue.getValue()).thenReturn(new String("ParameterName"));
+        Assert.assertTrue(parameterValueTypeMap.get(new ParameterName("ParameterName")) == valueType);
+//        System.out.println((String) method.invoke(updateTemplateDefinition, connection, parameterValueTypeMap));
+//        System.out.println("valuetype" + valueType.getIntValue());
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, connection, parameterValueTypeMap).equals("The property " + property.getPropertyName().getValue() + " type is not right."));
+        verify(stringValue).getValue();
+    }
+
+    @Test
+    public void testCheckFlowTemplate() throws Exception{
+        method = class1.getDeclaredMethod("checkFlowTemplate",new Class[]{
+                AbstractFlow.class,
+                Map.class
+        });
+        method.setAccessible(true);
+        field = class1.getDeclaredField("getDefinitions");
+        field.setAccessible(true);
+
+        GetDefinitions getDefinitions = mock(GetDefinitions.class);
+        AbstractFlow flow = mock(AbstractFlow.class);
+        MatchItem matchItem = mock(MatchItem.class);
+        List<MatchItem> matchItemList = new ArrayList<MatchItem>();
+        MatchItemValue matchItemValue = mock(MatchItemValue.class);
+        MatchItemName matchItemName = mock(MatchItemName.class);
+        MatchItemDefinition matchItemDefinition = mock(MatchItemDefinition.class);
+        MatchItemDefinition.MatchItemValueType type = MatchItemDefinition.MatchItemValueType.String;
+        TemplateParameter.ParameterValueType valueType = TemplateParameter.ParameterValueType.Int;
+        Map<MatchItemName, MatchItemDefinition> matchItemDefinitionMap = new HashMap<MatchItemName, MatchItemDefinition>();
+        Map<ParameterName, TemplateParameter.ParameterValueType> parameterValueTypeMap = new HashMap<ParameterName, TemplateParameter.ParameterValueType>();
+
+        field.set(updateTemplateDefinition, getDefinitions);
+        parameterValueTypeMap.put(new ParameterName("ParameterName"),valueType);
+
+        when(getDefinitions.getMatchItemDefinition()).thenReturn(matchItemDefinitionMap);
+        when(flow.getMatchItem()).thenReturn(matchItemList);
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, flow, parameterValueTypeMap) == null);
+        matchItemList.add(matchItem);
+        when(matchItem.getMatchItemName()).thenReturn(matchItemName);
+        when(matchItemName.getValue()).thenReturn("test");
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, flow, parameterValueTypeMap).equals("The match item " + matchItem.getMatchItemName().getValue() +" is not defined."));
+        //test add matchItem
+        matchItemDefinitionMap.put(matchItemName,matchItemDefinition);
+        Assert.assertTrue(matchItemDefinitionMap.containsKey(matchItemName));
+        when(matchItemDefinition.getMatchItemValueType())
+                .thenReturn(MatchItemDefinition.MatchItemValueType.Int)
+                .thenReturn(type);
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, flow, parameterValueTypeMap) == null);
+        when(matchItem.getMatchItemValue()).thenReturn(matchItemValue);
+        when(matchItemValue.getStringValue()).thenReturn("ParameterName");
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, flow, parameterValueTypeMap).equals("The match item " + "ParameterName" +" type is not right."));
+
+    }
+
+    @Test
+    public void testCheckOperationTemplate() throws Exception{
+        method = class1.getDeclaredMethod("checkOperationTemplate",new Class[]{
+                AbstractOperation.class,
+                Map.class
+        });
+        method.setAccessible(true);
+        field = class1.getDeclaredField("getDefinitions");
+        field.setAccessible(true);
+
+        GetDefinitions getDefinitions = mock(GetDefinitions.class);
+        Action action = mock(Action.class);
+        ActionName actionName = mock(ActionName.class);
+        ActionDefinition actionDefinition = mock(ActionDefinition.class);
+        AbstractOperation operation = mock(AbstractOperation.class);
+        ConditionSegment conditionSegment = mock(ConditionSegment.class);
+        ParameterName parameterName = mock(ParameterName.class);
+        ParameterValues parameterValues = mock(ParameterValues.class);
+        ConditionParameterName conditionParameterName = mock(ConditionParameterName.class);
+        ConditionParameterDefinition definition = mock(ConditionParameterDefinition.class);
+        ConditionParameterDefinition conditionParameterDefinition = mock(ConditionParameterDefinition.class);
+        ConditionParameterTargetValue conditionParameterTargetValue = mock(ConditionParameterTargetValue.class);
+        ConditionParameterDefinition.ParameterValueType type = ConditionParameterDefinition.ParameterValueType.String;
+        TemplateParameter.ParameterValueType valueType = TemplateParameter.ParameterValueType.Int;
+        ActionDefinition.ParameterValueType type1 = ActionDefinition.ParameterValueType.String;
+        org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValue
+                stringValue = mock(org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValue.class);
+        List<Action> actionList = new ArrayList<Action>();
+        List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValue>
+                stringValues = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValue>();
+        List<ConditionSegment> conditionSegmentList = new ArrayList<ConditionSegment>();
+        Map<ParameterName, TemplateParameter.ParameterValueType> parameterValueTypeMap = new HashMap<ParameterName, TemplateParameter.ParameterValueType>();
+        Map<ActionName, ActionDefinition> actionDefinitionMap = new HashMap<ActionName, ActionDefinition>();
+        Map<ParameterName, ConditionParameterDefinition> conditionParameterDefinitionMap = mock(Map.class);
+
+        field.set(updateTemplateDefinition, getDefinitions);
+        conditionSegmentList.add(conditionSegment);
+        parameterValueTypeMap.put(new ParameterName("ParameterName"), valueType);
+        conditionParameterDefinitionMap.put(parameterName, conditionParameterDefinition);
+
+        when(getDefinitions.getActionDefinition()).thenReturn(actionDefinitionMap);
+        when(getDefinitions.getConditionParameterDefinition()).thenReturn(conditionParameterDefinitionMap);
+        when(operation.getConditionSegment())
+                .thenReturn(null)
+                .thenReturn(conditionSegmentList);
+        when(operation.getAction())
+                .thenReturn(null)
+                .thenReturn(actionList);
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap) == null);
+        //test condition
+        when(conditionSegment.getConditionParameterName())
+                .thenReturn(conditionParameterName);
+        when(conditionParameterDefinitionMap.containsKey(conditionSegment.getConditionParameterName()))
+                .thenReturn(false)
+                .thenReturn(true);
+        when(parameterName.getValue()).thenReturn("test");
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap).equals("The Condition " + conditionSegment.getConditionParameterName().getValue() + " is not defined."));
+        when(conditionSegment.getConditionParameterTargetValue())
+                .thenReturn(null)
+                .thenReturn(conditionParameterTargetValue);
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap) == null);
+        when(conditionParameterDefinitionMap.get(conditionSegment.getConditionParameterName())).thenReturn(definition);
+        when(definition.getParameterValueType())
+                .thenReturn(ConditionParameterDefinition.ParameterValueType.Int)
+                .thenReturn(type);
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap) == null);
+        when(conditionParameterTargetValue.getStringValue()).thenReturn("ParameterName");
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap).equals("The condition " + conditionSegment.getConditionParameterName().getValue() + " type is not right."));
+
+        //test action
+        conditionSegmentList.clear();
+        actionList.add(action);
+        stringValues.add(stringValue);
+
+        when(action.getActionName()).thenReturn(actionName);
+        when(actionName.getValue()).thenReturn("test");
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap).equals("The action " + action.getActionName().getValue() + " is not defined."));
+        actionDefinitionMap.put(actionName, actionDefinition);
+        when(action.getParameterValues())
+                .thenReturn(null)
+                .thenReturn(parameterValues);
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap) == null);
+        when(actionDefinition.getParameterValueType()).thenReturn(type1);
+        when(parameterValues.getStringValue()).thenReturn(stringValues);
+        when(stringValue.getValue()).thenReturn("ParameterName");
+        Assert.assertTrue(method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap).equals("The action " + action.getActionName().getValue() +" type is not right."));
+    }
+}
\ No newline at end of file