From 6b41d226b30a35b13462b3ca8d395ce335402023 Mon Sep 17 00:00:00 2001 From: ldzd11 <1875840145@qq.com> Date: Sat, 19 Dec 2015 13:46:36 +0800 Subject: [PATCH] Modified two test files Change-Id: I1ccac3aeeb2615e59c3ea82cb7e8b9fd16bbea88 Signed-off-by: ldzd11 <1875840145@qq.com> --- .../updateintent/UpdateFlowTest.java | 357 ++++++++++++++---- .../updateintent/UpdateIntentTest.java | 182 +++++++-- 2 files changed, 437 insertions(+), 102 deletions(-) diff --git a/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/structurestyle/updateintent/UpdateFlowTest.java b/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/structurestyle/updateintent/UpdateFlowTest.java index 599f516..1935462 100644 --- a/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/structurestyle/updateintent/UpdateFlowTest.java +++ b/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/structurestyle/updateintent/UpdateFlowTest.java @@ -1,71 +1,288 @@ -/* - * 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 org.opendaylight.nemo.user.vnspacemanager.structurestyle.updateintent.UpdateFlow; - -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.*; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; - -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; -import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; -import org.opendaylight.nemo.user.tenantmanager.TenantManage; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.UserId; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.Users; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.Objects; -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.FlowBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.FlowKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.User; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.UserKey; -import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; -import com.google.common.util.concurrent.CheckedFuture; -import com.google.common.util.concurrent.FutureCallback; -import com.google.common.util.concurrent.Futures; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class UpdateFlowTest { - - private UpdateFlow updateFlow; - - private DataBroker dataBroker; - private TenantManage tenantManage; - private UserId userId; - private Flow flow; - - @org.junit.Before - public void setUp() throws Exception { - dataBroker = mock(DataBroker.class); - tenantManage = mock(TenantManage.class); - userId = mock(UserId.class); - flow = mock(Flow.class); - - updateFlow = new UpdateFlow(dataBroker, tenantManage); - } - - @org.junit.Test - public void testFlowHandling() throws Exception { - - String errorDefinition = new String("The match item has not been defined."); - - CheckedFuture connectiondefinitionFuture = mock(CheckedFuture.class); - ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class); - when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction); - when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(connectiondefinitionFuture); - - Assert.assertEquals(updateFlow.FlowHandling(userId,flow),errorDefinition); - - } +/* + * 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 org.junit.Before; +import org.junit.Test; +import org.opendaylight.nemo.user.tenantmanager.TenantManage; + +import com.google.common.base.Optional; +import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.FutureCallback; +import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.ListenableFuture; +import com.google.common.util.concurrent.SettableFuture; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; +import org.opendaylight.nemo.user.tenantmanager.TenantManage; +import org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOConstants; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.MatchItemName; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.UserId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.Users; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.Objects; +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.FlowBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.FlowKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.User; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.UserKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.MatchItemDefinitions; +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.match.item.instance.MatchItemValue; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.FlowId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.FlowName; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.LinkedList; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import java.util.*; +import java.util.List; + +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import com.google.common.util.concurrent.CheckedFuture; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.List; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; + + +import static org.junit.Assert.*; + +/** + * Created by ldzd11 on 2015/12/22. + */ +public class UpdateFlowTest { + + private UpdateFlow updateFlow; + private DataBroker dataBroker; + private TenantManage tenantManage; + private MatchItemName matchItemName; + private MatchItemName matchItemName2; + private MatchItem matchItem; + private List matchItemList; + private List matchItemListnull; + private User user; + private UserId userId; + private Objects objects; + private List flowList; + private FlowId flowId; + private FlowName flowName; + private FlowName flowName2; + + + + private MatchItemValue matchItemValue; + private Flow flow; + private Flow flow2; + + @Before + public void setUp() throws Exception { + dataBroker = mock(DataBroker.class); + tenantManage = mock(TenantManage.class); + matchItemName = mock(MatchItemName.class); + matchItemName2= mock(MatchItemName.class); + matchItem = mock(MatchItem.class); + matchItemList = new ArrayList(1); + matchItemListnull = new ArrayList(); + userId = mock(UserId.class); + user = mock(User.class); + matchItemList.add(matchItem); + flow = mock(Flow.class); + flow2 = mock(Flow.class); + flowId = mock(FlowId.class); + flowName = mock(FlowName.class); + flowName2 = mock(FlowName.class); + + matchItemValue = mock(MatchItemValue.class); + objects = mock(Objects.class); + flowList = new ArrayList(1); + flowList.add(flow2); + + updateFlow = new UpdateFlow(dataBroker,tenantManage); + + } + + + + + @Test + public void testFlowHandling() throws Exception { + //into checkdefinition for error = null + CheckedFuture matchitemdefinitionFuture = mock(CheckedFuture.class); + ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class); + when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction); + when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(matchitemdefinitionFuture); + + List matchItemDefinitions = new ArrayList(); + MatchItemDefinition matchItemDefinition = mock(MatchItemDefinition.class); + matchItemDefinitions.add(matchItemDefinition); + when(matchItemDefinition.getMatchItemName()).thenReturn(matchItemName); + + Class class1 = UpdateFlow.class; + Class class2 = GetDefinitions.class; + Field field = class1.getDeclaredField("getDefinitions"); + field.setAccessible(true); + Field field1 = class2.getDeclaredField("matchItemDefinitionList"); + field1.setAccessible(true); + + field1.set(field.get(updateFlow), matchItemDefinitions); + when(flow.getMatchItem()).thenReturn(null); + //into checkinstance for error = null + when(tenantManage.getUser()).thenReturn(null); + + WriteTransaction writeTransaction = mock(WriteTransaction.class); + when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction); + when(flow.getFlowId()).thenReturn(flowId); + when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction); + CheckedFuture f; + f=mock(CheckedFuture.class); + when(writeTransaction.submit()).thenReturn(f); + + Assert.assertEquals(updateFlow.FlowHandling(userId, flow), null); + + + + + } + + @Test + public void testcheckInstance() throws Exception { + Class class1 = UpdateFlow.class; + Method method = class1.getDeclaredMethod("checkInstance",new Class[]{UserId.class,Flow.class}); + method.setAccessible(true); + + when(tenantManage.getUser()).thenReturn(user); + when(user.getObjects()).thenReturn(objects); + when(user.getObjects().getFlow()).thenReturn(flowList); + + when(flow2.getFlowId()).thenReturn(flowId); + when(flow.getFlowId()).thenReturn(flowId); + when(flow2.getFlowName()).thenReturn(flowName2); + when(flow.getFlowName()).thenReturn(flowName); + Assert.assertEquals(method.invoke(updateFlow, userId, flow), "The flow name should not be changed."); + + + + + } + + @Test + public void testcheckDefinition() throws Exception { + Class class3 = UpdateFlow.class; + Method method = class3.getDeclaredMethod("checkDefinition",new Class[]{Flow.class}); + method.setAccessible(true); + + CheckedFuture matchitemdefinitionFuture = mock(CheckedFuture.class); + ReadOnlyTransaction readOnlyTransaction = mock(ReadOnlyTransaction.class); + when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction); + when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(matchitemdefinitionFuture); + + + List matchItemDefinitions = new ArrayList(); + List matchItemDefinitionsnull = new ArrayList(); + MatchItemDefinition matchItemDefinition = mock(MatchItemDefinition.class); + matchItemDefinitions.add(matchItemDefinition); + when(matchItemDefinition.getMatchItemName()).thenReturn(matchItemName); + + + Class class1 = UpdateFlow.class; + Class class2 = GetDefinitions.class; + Field field = class1.getDeclaredField("getDefinitions"); + field.setAccessible(true); + Field field1 = class2.getDeclaredField("matchItemDefinitionList"); + field1.setAccessible(true); + + //the else + field1.set(field.get(updateFlow), matchItemDefinitions); + when(flow.getMatchItem()).thenReturn(matchItemList); + when(matchItem.getMatchItemName()).thenReturn(matchItemName2); + Assert.assertEquals(method.invoke(updateFlow, flow), "The match item has not been defined."); + + //the upper + field1.set(field.get(updateFlow), matchItemDefinitionsnull); + Assert.assertEquals(method.invoke(updateFlow, flow), "The match item has not been defined."); + + //the if errorInfo == null into checkPredefine + field1.set(field.get(updateFlow), matchItemDefinitions); + when(flow.getMatchItem()).thenReturn(matchItemListnull); + //into checkPredefine + Assert.assertEquals(method.invoke(updateFlow, flow), null); + + + + + } + + @Test + public void testcheckPredefine() throws Exception { + Class class1 = UpdateFlow.class; + Method method = class1.getDeclaredMethod("checkPredefine",new Class[]{List.class}); + method.setAccessible(true); + + when(matchItem.getMatchItemName()).thenReturn(matchItemName); + when(matchItem.getMatchItemName().getValue()).thenReturn(new String("src-ip")); + when(matchItem.getMatchItemValue()).thenReturn(matchItemValue); + + //stringValues.contains("/") + when(matchItem.getMatchItemValue().getStringValue()).thenReturn(new String("110/")); + //into checkIpPrefix(stringvalues) legalValue=false + Assert.assertEquals(method.invoke(updateFlow, matchItemList),"The " + NEMOConstants.ip_address + " is not legal."); + + when(matchItem.getMatchItemValue().getStringValue()).thenReturn(new String("110\\.")); + //into checkip address + Assert.assertEquals(method.invoke(updateFlow, matchItemList),"The " + NEMOConstants.ip_address + " is not legal."); + + + when(matchItem.getMatchItemName().getValue()).thenReturn(new String("src-mac")); + when(matchItem.getMatchItemValue()).thenReturn(matchItemValue); + when(matchItem.getMatchItemValue().getStringValue()).thenReturn(new String("110:")); + //into valuecheck.checkMac + Assert.assertEquals(method.invoke(updateFlow, matchItemList), "The " + NEMOConstants.mac_address + " is not legal."); + + + + + + + + + + + + } } \ No newline at end of file diff --git a/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/structurestyle/updateintent/UpdateIntentTest.java b/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/structurestyle/updateintent/UpdateIntentTest.java index 48efaca..9448d70 100644 --- a/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/structurestyle/updateintent/UpdateIntentTest.java +++ b/nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/structurestyle/updateintent/UpdateIntentTest.java @@ -6,65 +6,183 @@ * and is available at http://www.eclipse.org/legal/epl-v10.html */ package org.opendaylight.nemo.user.vnspacemanager.structurestyle.updateintent; -import org.opendaylight.nemo.user.vnspacemanager.structurestyle.updateintent.UpdateIntent; -import org.opendaylight.nemo.user.tenantmanager.TenantManage; -import org.opendaylight.nemo.user.vnspacemanager.structurestyle.updateintent.UpdateIntent; +import org.junit.Before; +import org.junit.Test; import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.nemo.user.tenantmanager.AAA; import org.opendaylight.nemo.user.tenantmanager.TenantManage; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.Objects; +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.intent.rev151010.StructureStyleNemoUpdateInput; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.Results; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.Connection; 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.intent.rev151010.user.intent.operations.Operation; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.*; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.UserId; + +import java.util.List; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.LinkedList; import org.junit.Assert; import org.junit.Before; import org.junit.Test; +import java.util.*; +import java.util.List; -public class UpdateIntentTest { - +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import com.google.common.util.concurrent.CheckedFuture; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.List; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.Operations; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.Results; +import static org.junit.Assert.*; - UpdateIntent updateIntent; +/** + * Created by ldzd11 on 2015/12/22. + */ +public class UpdateIntentTest { + private UpdateIntent updateIntent; private DataBroker dataBroker; private TenantManage tenantManage; - private UpdateNode updateNode; - private UpdateConnection updateConnection; - private UpdateFlow updateFlow; - private UpdateOperation updateOperation; - private UpdateResult updateResult; private AAA aaa; + private UserId userId; + private Objects objects; + private Node node; + private List nodeList; + private Connection connection; + private List connectionList; + private Flow flow; + private List flowList; + private Operations operations; + private Operation operation; + private List operationList; + private Results results; private StructureStyleNemoUpdateInput structureStyleNemoUpdateInput; - - @org.junit.Before + @Before public void setUp() throws Exception { - dataBroker = mock(DataBroker.class); tenantManage = mock(TenantManage.class); - updateNode = mock(UpdateNode.class); - updateConnection = mock(UpdateConnection.class); - updateFlow = mock(UpdateFlow.class); - updateOperation = mock(UpdateOperation.class); - updateResult = mock(UpdateResult.class); aaa = mock(AAA.class); structureStyleNemoUpdateInput = mock(StructureStyleNemoUpdateInput.class); - - updateIntent = new UpdateIntent(dataBroker, tenantManage); + userId = mock(UserId.class); + objects = mock(Objects.class); + node = mock(Node.class); + nodeList = new ArrayList(1); + nodeList.add(node); + operations = mock(Operations.class); + operation = mock(Operation.class); + operationList = new ArrayList(1); + operationList.add(operation); + + connection = mock(Connection.class); + connectionList = new ArrayList(1); + connectionList.add(connection); + results = mock(Results.class); + + flow = mock(Flow.class); + flowList = new ArrayList(1); + flowList.add(flow); + + + + updateIntent = new UpdateIntent(dataBroker,tenantManage); + } - @org.junit.Test + @Test public void testUpdateIntent() throws Exception { - - String erroInfo = new String("Case 0"); - when(aaa.checkUser(structureStyleNemoUpdateInput.getUserId())).thenReturn(erroInfo); - Assert.assertEquals(updateIntent.updateIntent(aaa,structureStyleNemoUpdateInput),erroInfo); - - when(structureStyleNemoUpdateInput.getObjects()).thenReturn(null); - - Assert.assertNotNull(updateIntent.updateIntent(aaa,structureStyleNemoUpdateInput)); + when(structureStyleNemoUpdateInput.getUserId()).thenReturn(userId); + when(aaa.checkUser(structureStyleNemoUpdateInput.getUserId())).thenReturn(null); + //else + when(structureStyleNemoUpdateInput.getObjects()).thenReturn(objects); + //node + when(structureStyleNemoUpdateInput.getObjects().getNode()).thenReturn(nodeList); + ///////test////// + Class class_1 = UpdateIntent.class; + Field field_1 = class_1.getDeclaredField("updateNode"); + field_1.setAccessible(true); + + UpdateNode updateNode_1 = mock(UpdateNode.class); + field_1.set(updateIntent,updateNode_1); + when(updateNode_1.NodeHandling(userId,node)).thenReturn(new String("node success")); + Assert.assertEquals(updateIntent.updateIntent(aaa, structureStyleNemoUpdateInput), "node success"); + + //connection + when(structureStyleNemoUpdateInput.getObjects().getNode()).thenReturn(null); + when(structureStyleNemoUpdateInput.getObjects().getConnection()).thenReturn(connectionList); + + Field field_2 = class_1.getDeclaredField("updateConnection"); + field_2.setAccessible(true); + UpdateConnection updateConnection = mock(UpdateConnection.class); + field_2.set(updateIntent, updateConnection); + + when(updateConnection.ConnectionHandling(userId,connection)).thenReturn(new String("connection success")); + Assert.assertEquals(updateIntent.updateIntent(aaa, structureStyleNemoUpdateInput), "connection success"); + + //flow + when(structureStyleNemoUpdateInput.getObjects().getNode()).thenReturn(null); + when(structureStyleNemoUpdateInput.getObjects().getConnection()).thenReturn(null); + when(structureStyleNemoUpdateInput.getObjects().getFlow()).thenReturn(flowList); + + Field field_3 = class_1.getDeclaredField("updateFlow"); + field_3.setAccessible(true); + UpdateFlow updateFlow = mock(UpdateFlow.class); + field_3.set(updateIntent, updateFlow); + when(updateFlow.FlowHandling(userId,flow)).thenReturn(new String("flow success")); + Assert.assertEquals(updateIntent.updateIntent(aaa, structureStyleNemoUpdateInput), "flow success"); + + //operations + when(structureStyleNemoUpdateInput.getObjects()).thenReturn(null); + when(structureStyleNemoUpdateInput.getOperations()).thenReturn(operations); + when(structureStyleNemoUpdateInput.getOperations().getOperation()).thenReturn(operationList); + + + Field field_4 = class_1.getDeclaredField("updateOperation"); + field_4.setAccessible(true); + UpdateOperation updateOperation = mock(UpdateOperation.class); + field_4.set(updateIntent, updateOperation); + when(updateOperation.OperationHandling(userId,operation)).thenReturn(new String("operation success")); + Assert.assertEquals(updateIntent.updateIntent(aaa, structureStyleNemoUpdateInput), "operation success"); + + + //getResults + when(structureStyleNemoUpdateInput.getObjects()).thenReturn(null); + when(structureStyleNemoUpdateInput.getOperations()).thenReturn(null); + when(structureStyleNemoUpdateInput.getResults()).thenReturn(results); + + Field field_5 = class_1.getDeclaredField("updateResult"); + field_5.setAccessible(true); + UpdateResult updateResult = mock(UpdateResult.class); + field_5.set(updateIntent, updateResult); + when(updateResult.ResultHandling(userId, results)).thenReturn(new String("result success")); + Assert.assertEquals(updateIntent.updateIntent(aaa, structureStyleNemoUpdateInput), "result success"); + + + + + + + + } } \ No newline at end of file -- 2.36.6