Remove redundant exception declarations

[openflowplugin.git] / openflowplugin-impl / src / test / java / org / opendaylight / openflowplugin / impl / services / batch / FlatBatchGroupAdaptersTest.java

diff --git a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchGroupAdaptersTest.java b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchGroupAdaptersTest.java
index 086a5304a095f372735b00dbc38843d97d885497..e3a403caa5dac90acadc073d5d6153db4a281809 100644 (file)
--- a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchGroupAdaptersTest.java
+++ b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchGroupAdaptersTest.java
@@ -12,7 +12,6 @@ import com.google.common.collect.Lists;
 import org.junit.Assert;
 import org.junit.Test;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.add.group._case.FlatBatchAddGroup;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.add.group._case.FlatBatchAddGroupBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.remove.group._case.FlatBatchRemoveGroup;
@@ -54,14 +53,15 @@ public class FlatBatchGroupAdaptersTest {
     private static final NodeRef NODE_REF = new NodeRef(NODE_II);
 
     @Test
-    public void testAdaptFlatBatchAddGroup() throws Exception {
+    public void testAdaptFlatBatchAddGroup() {
         final BatchPlanStep planStep = new BatchPlanStep(BatchStepType.FLOW_ADD);
         planStep.setBarrierAfter(true);
         planStep.getTaskBag().addAll(Lists.newArrayList(
                 createAddGroupBatch(1L),
                 createAddGroupBatch(2L)));
 
-        final AddGroupsBatchInput addGroupsBatchInput = FlatBatchGroupAdapters.adaptFlatBatchAddGroup(planStep, NODE_REF);
+        final AddGroupsBatchInput addGroupsBatchInput =
+                FlatBatchGroupAdapters.adaptFlatBatchAddGroup(planStep, NODE_REF);
 
         Assert.assertTrue(addGroupsBatchInput.isBarrierAfter());
         Assert.assertEquals(2, addGroupsBatchInput.getBatchAddGroups().size());
@@ -93,82 +93,75 @@ public class FlatBatchGroupAdaptersTest {
     }
 
     @Test
-    public void testAdaptFlatBatchRemoveGroup() throws Exception {
+    public void testAdaptFlatBatchRemoveGroup() {
         final BatchPlanStep planStep = new BatchPlanStep(BatchStepType.FLOW_REMOVE);
         planStep.setBarrierAfter(true);
         planStep.getTaskBag().addAll(Lists.newArrayList(
                 createRemoveGroupBatch(1L),
                 createRemoveGroupBatch(2L)));
 
-        final RemoveGroupsBatchInput removeGroupsBatchInput = FlatBatchGroupAdapters.adaptFlatBatchRemoveGroup(planStep, NODE_REF);
+        final RemoveGroupsBatchInput removeGroupsBatchInput =
+                FlatBatchGroupAdapters.adaptFlatBatchRemoveGroup(planStep, NODE_REF);
 
         Assert.assertTrue(removeGroupsBatchInput.isBarrierAfter());
         Assert.assertEquals(2, removeGroupsBatchInput.getBatchRemoveGroups().size());
-        Assert.assertEquals(1L, removeGroupsBatchInput.getBatchRemoveGroups().get(0).getGroupId().getValue().longValue());
-        Assert.assertEquals(2L, removeGroupsBatchInput.getBatchRemoveGroups().get(1).getGroupId().getValue().longValue());
+        Assert.assertEquals(1L,
+                removeGroupsBatchInput.getBatchRemoveGroups().get(0).getGroupId().getValue().longValue());
+        Assert.assertEquals(2L,
+                removeGroupsBatchInput.getBatchRemoveGroups().get(1).getGroupId().getValue().longValue());
     }
 
     @Test
-    public void testAdaptFlatBatchUpdateGroup() throws Exception {
+    public void testAdaptFlatBatchUpdateGroup() {
         final BatchPlanStep planStep = new BatchPlanStep(BatchStepType.FLOW_UPDATE);
         planStep.setBarrierAfter(true);
         planStep.getTaskBag().addAll(Lists.newArrayList(
                 createUpdateGroupBatch(1L),
                 createUpdateGroupBatch(2L)));
 
-        final UpdateGroupsBatchInput updateGroupsBatchInput = FlatBatchGroupAdapters.adaptFlatBatchUpdateGroup(planStep, NODE_REF);
+        final UpdateGroupsBatchInput updateGroupsBatchInput =
+                FlatBatchGroupAdapters.adaptFlatBatchUpdateGroup(planStep, NODE_REF);
 
         Assert.assertTrue(updateGroupsBatchInput.isBarrierAfter());
         Assert.assertEquals(2, updateGroupsBatchInput.getBatchUpdateGroups().size());
-        Assert.assertEquals(1L, updateGroupsBatchInput.getBatchUpdateGroups().get(0).getUpdatedBatchedGroup().getGroupId().getValue().longValue());
-        Assert.assertEquals(2L, updateGroupsBatchInput.getBatchUpdateGroups().get(1).getUpdatedBatchedGroup().getGroupId().getValue().longValue());
+        Assert.assertEquals(1L, updateGroupsBatchInput.getBatchUpdateGroups().get(0)
+                .getUpdatedBatchedGroup().getGroupId().getValue().longValue());
+        Assert.assertEquals(2L, updateGroupsBatchInput.getBatchUpdateGroups().get(1)
+                .getUpdatedBatchedGroup().getGroupId().getValue().longValue());
     }
 
     @Test
-    public void testCreateBatchGroupChainingFunction_failures() throws Exception {
-        final RpcResult<ProcessFlatBatchOutput> chainInput = RpcResultBuilder.<ProcessFlatBatchOutput>failed()
-                .withError(RpcError.ErrorType.APPLICATION, "ut-chainError")
-                .withResult(new ProcessFlatBatchOutputBuilder()
-                        .setBatchFailure(Lists.newArrayList(
-                                createChainFailure(0, 1L),
-                                createChainFailure(1, 2L)))
-                        .build())
-                .build();
-
+    public void testCreateBatchGroupChainingFunction_failures() {
         final RpcResult<BatchGroupOutputListGrouping> input = RpcResultBuilder.<BatchGroupOutputListGrouping>failed()
                 .withError(RpcError.ErrorType.APPLICATION, "ut-groupError")
                 .withResult(new AddGroupsBatchOutputBuilder()
                         .setBatchFailedGroupsOutput(Lists.newArrayList(
-                                createBatchFailedGroupsOutput(0, 3L),
-                                createBatchFailedGroupsOutput(1, 4L)
+                                createBatchFailedGroupsOutput(0, 1L),
+                                createBatchFailedGroupsOutput(1, 2L)
                         ))
                         .build())
                 .build();
 
         final RpcResult<ProcessFlatBatchOutput> rpcResult = FlatBatchGroupAdapters
-                .createBatchGroupChainingFunction(chainInput, 2).apply(input);
+                .convertBatchGroupResult(3).apply(input);
 
         Assert.assertFalse(rpcResult.isSuccessful());
-        Assert.assertEquals(2, rpcResult.getErrors().size());
-        Assert.assertEquals(4, rpcResult.getResult().getBatchFailure().size());
-        Assert.assertEquals(0, rpcResult.getResult().getBatchFailure().get(0).getBatchOrder().intValue());
-        Assert.assertEquals(1, rpcResult.getResult().getBatchFailure().get(1).getBatchOrder().intValue());
-        Assert.assertEquals(2, rpcResult.getResult().getBatchFailure().get(2).getBatchOrder().intValue());
-        Assert.assertEquals(3, rpcResult.getResult().getBatchFailure().get(3).getBatchOrder().intValue());
-        Assert.assertEquals(4L, ((FlatBatchFailureGroupIdCase) rpcResult.getResult().getBatchFailure().get(3).getBatchItemIdChoice()).getGroupId().getValue().longValue());
+        Assert.assertEquals(1, rpcResult.getErrors().size());
+        Assert.assertEquals(2, rpcResult.getResult().getBatchFailure().size());
+        Assert.assertEquals(3, rpcResult.getResult().getBatchFailure().get(0).getBatchOrder().intValue());
+        Assert.assertEquals(4, rpcResult.getResult().getBatchFailure().get(1).getBatchOrder().intValue());
+        Assert.assertEquals(2L, ((FlatBatchFailureGroupIdCase) rpcResult.getResult().getBatchFailure().get(1)
+                .getBatchItemIdChoice()).getGroupId().getValue().longValue());
     }
 
     @Test
-    public void testCreateBatchGroupChainingFunction_successes() throws Exception {
-        final RpcResult<ProcessFlatBatchOutput> chainInput = RpcResultBuilder
-                .success(new ProcessFlatBatchOutputBuilder().build())
-                .build();
+    public void testCreateBatchGroupChainingFunction_successes() {
         final RpcResult<BatchGroupOutputListGrouping> input = RpcResultBuilder
                 .<BatchGroupOutputListGrouping>success(new AddGroupsBatchOutputBuilder().build())
                 .build();
 
         final RpcResult<ProcessFlatBatchOutput> rpcResult = FlatBatchGroupAdapters
-                .createBatchGroupChainingFunction(chainInput, 0).apply(input);
+                .convertBatchGroupResult(0).apply(input);
 
         Assert.assertTrue(rpcResult.isSuccessful());
         Assert.assertEquals(0, rpcResult.getErrors().size());