X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=openflowplugin-impl%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fopenflowplugin%2Fimpl%2Futil%2FFlowUtilTest.java;h=95f066018b0f9ce8b6a06e4a5dd2cc8534ae10a6;hb=26d73dba20bcdcbe3d97e8b41e6ee8801495569e;hp=144472a6a637103ef682ab8dea05fa72b4b016a6;hpb=effa31f9335a3fc6ae33aa85f09ea81b3bc2481f;p=openflowplugin.git diff --git a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/util/FlowUtilTest.java b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/util/FlowUtilTest.java index 144472a6a6..95f066018b 100644 --- a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/util/FlowUtilTest.java +++ b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/util/FlowUtilTest.java @@ -5,18 +5,13 @@ * 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.openflowplugin.impl.util; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; - -import com.google.common.base.Function; import com.google.common.collect.Lists; import java.util.Collections; import java.util.List; -import java.util.regex.Matcher; -import java.util.regex.Pattern; +import java.util.Map; +import java.util.function.Function; import org.apache.commons.lang3.tuple.Pair; import org.junit.Assert; import org.junit.Test; @@ -24,6 +19,7 @@ import org.mockito.Mockito; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.SendBarrierOutput; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowRef; import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.AddFlowsBatchOutput; import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.AddFlowsBatchOutputBuilder; @@ -31,6 +27,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.Bat import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.BatchFlowOutputListGrouping; import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.batch.flow.output.list.grouping.BatchFailedFlowsOutput; import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.batch.flow.output.list.grouping.BatchFailedFlowsOutputBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.batch.flow.output.list.grouping.BatchFailedFlowsOutputKey; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; @@ -39,37 +36,17 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.common.RpcError; import org.opendaylight.yangtools.yang.common.RpcResult; import org.opendaylight.yangtools.yang.common.RpcResultBuilder; +import org.opendaylight.yangtools.yang.common.Uint16; +import org.opendaylight.yangtools.yang.common.Uint8; public class FlowUtilTest { - - public static final Pattern INDEX_PATTERN = Pattern.compile("^#UF\\$TABLE\\*1-([0-9]+)$"); public static final NodeId DUMMY_NODE_ID = new NodeId("dummyNodeId"); public static final FlowId DUMMY_FLOW_ID = new FlowId("dummyFlowId"); public static final FlowId DUMMY_FLOW_ID_2 = new FlowId("dummyFlowId_2"); - public static final Short DUMMY_TABLE_ID = 1; - - @Test - public void createAlienFlowIdTest() { - final String alienFlowId1 = FlowUtil.createAlienFlowId(DUMMY_TABLE_ID).getValue(); - final Integer index1 = parseIndex(alienFlowId1); - final String alienFlowId2 = FlowUtil.createAlienFlowId(DUMMY_TABLE_ID).getValue(); - final Integer index2 = parseIndex(alienFlowId2); - - assertNotNull("index1 parsing failed: " + alienFlowId1, index1); - assertNotNull("index2 parsing failed: " + alienFlowId2, index2); - assertTrue(index1 < index2); - } - - private static Integer parseIndex(String alienFlowIdValue) { - final Matcher mach = INDEX_PATTERN.matcher(alienFlowIdValue); - if (mach.find()) { - return Integer.valueOf(mach.group(1)); - } - return null; - } + public static final Uint8 DUMMY_TABLE_ID = Uint8.ONE; @Test - public void testBuildFlowPath() throws Exception { + public void testBuildFlowPath() { final InstanceIdentifier nodePath = InstanceIdentifier .create(Nodes.class) .child(Node.class, new NodeKey(DUMMY_NODE_ID)); @@ -82,7 +59,7 @@ public class FlowUtilTest { } @Test - public void testCreateCumulatingFunction() throws Exception { + public void testCreateCumulatingFunction() { final Function>, RpcResult>> function = FlowUtil.createCumulatingFunction(Lists.newArrayList(createBatchFlowIdGrouping(DUMMY_FLOW_ID), createBatchFlowIdGrouping(DUMMY_FLOW_ID_2))); @@ -107,93 +84,103 @@ public class FlowUtilTest { } @Test - public void testFLOW_ADD_TRANSFORM__failure() throws Exception { + public void testFlowAddTransformFailure() { final RpcResult> input = createBatchOutcomeWithError(); checkBatchErrorOutcomeTransformation(FlowUtil.FLOW_ADD_TRANSFORM.apply(input)); } @Test - public void testFLOW_ADD_TRANSFORM__success() throws Exception { + public void testFlowAddTransformSuccess() { final RpcResult> input = createEmptyBatchOutcome(); checkBatchSuccessOutcomeTransformation(FlowUtil.FLOW_ADD_TRANSFORM.apply(input)); } @Test - public void testFLOW_REMOVE_TRANSFORM__failure() throws Exception { + public void testFlowRemoveTransformFailure() { final RpcResult> input = createBatchOutcomeWithError(); checkBatchErrorOutcomeTransformation(FlowUtil.FLOW_REMOVE_TRANSFORM.apply(input)); } @Test - public void testFLOW_REMOVE_TRANSFORM__success() throws Exception { + public void testFlowRemoveTransformSuccess() { final RpcResult> input = createEmptyBatchOutcome(); checkBatchSuccessOutcomeTransformation(FlowUtil.FLOW_REMOVE_TRANSFORM.apply(input)); } @Test - public void testFLOW_UPDATE_TRANSFORM__failure() throws Exception { + public void testFlowUpdateTransformFailure() { final RpcResult> input = createBatchOutcomeWithError(); checkBatchErrorOutcomeTransformation(FlowUtil.FLOW_UPDATE_TRANSFORM.apply(input)); } @Test - public void testFLOW_UPDATE_TRANSFORM__success() throws Exception { + public void testFlowUpdateTransformSuccess() { final RpcResult> input = createEmptyBatchOutcome(); checkBatchSuccessOutcomeTransformation(FlowUtil.FLOW_UPDATE_TRANSFORM.apply(input)); } - private void checkBatchSuccessOutcomeTransformation(final RpcResult output) { + private static void checkBatchSuccessOutcomeTransformation( + final RpcResult output) { Assert.assertTrue(output.isSuccessful()); - Assert.assertEquals(0, output.getResult().getBatchFailedFlowsOutput().size()); + Map failedFlows + = output.getResult().nonnullBatchFailedFlowsOutput(); + Assert.assertEquals(0, failedFlows.size()); Assert.assertEquals(0, output.getErrors().size()); } - private RpcResult> createEmptyBatchOutcome() { + private static RpcResult> createEmptyBatchOutcome() { return RpcResultBuilder - .>success(Collections.emptyList()) + .success(Collections.emptyList()) .build(); } - private RpcResult> createBatchOutcomeWithError() { + private static RpcResult> createBatchOutcomeWithError() { return RpcResultBuilder.>failed() .withError(RpcError.ErrorType.APPLICATION, "ut-flowAddFail") .withResult(Collections.singletonList(new BatchFailedFlowsOutputBuilder() .setFlowId(DUMMY_FLOW_ID) + .setBatchOrder(Uint16.ZERO) .build())) .build(); } - private void checkBatchErrorOutcomeTransformation(final RpcResult output) { + private static void checkBatchErrorOutcomeTransformation( + final RpcResult output) { Assert.assertFalse(output.isSuccessful()); - Assert.assertEquals(1, output.getResult().getBatchFailedFlowsOutput().size()); - Assert.assertEquals(DUMMY_FLOW_ID, output.getResult().getBatchFailedFlowsOutput().get(0).getFlowId()); + Assert.assertEquals(1, output.getResult().nonnullBatchFailedFlowsOutput().size()); + Assert.assertEquals(DUMMY_FLOW_ID, + output.getResult().nonnullBatchFailedFlowsOutput().values().iterator().next().getFlowId()); Assert.assertEquals(1, output.getErrors().size()); } @Test - public void testCreateComposingFunction_success_success() throws Exception { - final Function, RpcResult>, RpcResult> compositeFunction = - FlowUtil.createComposingFunction(); + public void testCreateComposingFunction_success_success() { + final Function, RpcResult>, + RpcResult> compositeFunction = FlowUtil.createComposingFunction(); final RpcResult addFlowBatchOutput = createAddFlowsBatchSuccessOutput(); - final RpcResult barrierOutput = RpcResultBuilder.success().build(); - final Pair, RpcResult> input = Pair.of(addFlowBatchOutput, barrierOutput); + final RpcResult barrierOutput = RpcResultBuilder.success().build(); + final Pair, RpcResult> input + = Pair.of(addFlowBatchOutput, barrierOutput); final RpcResult composite = compositeFunction.apply(input); Assert.assertTrue(composite.isSuccessful()); Assert.assertEquals(0, composite.getErrors().size()); - Assert.assertEquals(0, composite.getResult().getBatchFailedFlowsOutput().size()); + Map failedFlows + = composite.getResult().nonnullBatchFailedFlowsOutput(); + Assert.assertEquals(0, failedFlows.size()); } @Test - public void testCreateComposingFunction_failure_success() throws Exception { - final Function, RpcResult>, RpcResult> compositeFunction = - FlowUtil.createComposingFunction(); + public void testCreateComposingFunction_failure_success() { + final Function, RpcResult>, + RpcResult> compositeFunction = FlowUtil.createComposingFunction(); final RpcResult addFlowBatchOutput = createAddFlowsBatchFailureOutcome(); - final RpcResult barrierOutput = RpcResultBuilder.success().build(); - final Pair, RpcResult> input = Pair.of(addFlowBatchOutput, barrierOutput); + final RpcResult barrierOutput = RpcResultBuilder.success().build(); + final Pair, RpcResult> input + = Pair.of(addFlowBatchOutput, barrierOutput); final RpcResult composite = compositeFunction.apply(input); Assert.assertFalse(composite.isSuccessful()); @@ -202,28 +189,32 @@ public class FlowUtilTest { } @Test - public void testCreateComposingFunction_success_failure() throws Exception { - final Function, RpcResult>, RpcResult> compositeFunction = - FlowUtil.createComposingFunction(); + public void testCreateComposingFunction_success_failure() { + final Function, RpcResult>, + RpcResult> compositeFunction = FlowUtil.createComposingFunction(); final RpcResult addFlowBatchOutput = createAddFlowsBatchSuccessOutput(); - final RpcResult barrierOutput = createBarrierFailureOutcome(); - final Pair, RpcResult> input = Pair.of(addFlowBatchOutput, barrierOutput); + final RpcResult barrierOutput = createBarrierFailureOutcome(); + final Pair, RpcResult> input + = Pair.of(addFlowBatchOutput, barrierOutput); final RpcResult composite = compositeFunction.apply(input); Assert.assertFalse(composite.isSuccessful()); Assert.assertEquals(1, composite.getErrors().size()); - Assert.assertEquals(0, composite.getResult().getBatchFailedFlowsOutput().size()); + Map failedFlows + = composite.getResult().nonnullBatchFailedFlowsOutput(); + Assert.assertEquals(0, failedFlows.size()); } @Test - public void testCreateComposingFunction_failure_failure() throws Exception { - final Function, RpcResult>, RpcResult> compositeFunction = - FlowUtil.createComposingFunction(); + public void testCreateComposingFunction_failure_failure() { + final Function, RpcResult>, + RpcResult> compositeFunction = FlowUtil.createComposingFunction(); final RpcResult addFlowBatchOutput = createAddFlowsBatchFailureOutcome(); - final RpcResult barrierOutput = createBarrierFailureOutcome(); - final Pair, RpcResult> input = Pair.of(addFlowBatchOutput, barrierOutput); + final RpcResult barrierOutput = createBarrierFailureOutcome(); + final Pair, RpcResult> input + = Pair.of(addFlowBatchOutput, barrierOutput); final RpcResult composite = compositeFunction.apply(input); Assert.assertFalse(composite.isSuccessful()); @@ -231,21 +222,21 @@ public class FlowUtilTest { Assert.assertEquals(1, composite.getResult().getBatchFailedFlowsOutput().size()); } - private RpcResult createBarrierFailureOutcome() { - return RpcResultBuilder.failed() + private static RpcResult createBarrierFailureOutcome() { + return RpcResultBuilder.failed() .withError(RpcError.ErrorType.APPLICATION, "ut-barrier-error") .build(); } - private RpcResult createAddFlowsBatchSuccessOutput() { + private static RpcResult createAddFlowsBatchSuccessOutput() { return RpcResultBuilder .success(new AddFlowsBatchOutputBuilder() - .setBatchFailedFlowsOutput(Collections.emptyList()) + .setBatchFailedFlowsOutput(Collections.emptyList()) .build()) .build(); } - private RpcResult createAddFlowsBatchFailureOutcome() { + private static RpcResult createAddFlowsBatchFailureOutcome() { final RpcResult> batchOutcomeWithError = createBatchOutcomeWithError(); return RpcResultBuilder.failed() .withResult(new AddFlowsBatchOutputBuilder()