X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatabroker%2Factors%2Fdds%2FClientTransactionCommitCohortTest.java;h=b30986ee3d330009a46ee809449ceabdf57fde01;hb=refs%2Fchanges%2F22%2F65622%2F11;hp=294c62a23ca70426c6879d28fdd8ae32c776c31d;hpb=df34f194596eed9494f64a691bec244be70c2a5e;p=controller.git

diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/actors/dds/ClientTransactionCommitCohortTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/actors/dds/ClientTransactionCommitCohortTest.java
index 294c62a23c..b30986ee3d 100644
--- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/actors/dds/ClientTransactionCommitCohortTest.java
+++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/actors/dds/ClientTransactionCommitCohortTest.java
@@ -14,8 +14,8 @@ import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtil
 import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.getWithTimeout;
 
 import akka.actor.ActorSystem;
-import akka.testkit.JavaTestKit;
 import akka.testkit.TestProbe;
+import akka.testkit.javadsl.TestKit;
 import com.google.common.primitives.UnsignedLong;
 import com.google.common.util.concurrent.ListenableFuture;
 import java.util.ArrayList;
@@ -56,7 +56,7 @@ public class ClientTransactionCommitCohortTest {
     @Mock
     private AbstractClientHistory history;
     private ActorSystem system;
-    private List<TransactionTester> transactions;
+    private List<TransactionTester<RemoteProxyTransaction>> transactions;
     private ClientTransactionCommitCohort cohort;
 
     @Before
@@ -79,13 +79,13 @@ public class ClientTransactionCommitCohortTest {
 
     @After
     public void tearDown() throws Exception {
-        JavaTestKit.shutdownActorSystem(system);
+        TestKit.shutdownActorSystem(system);
     }
 
     @Test
     public void testCanCommit() throws Exception {
         testOpSuccess(ClientTransactionCommitCohort::canCommit, this::expectCanCommit,
-                this::replyCanCommitSuccess, true);
+                this::replyCanCommitSuccess, Boolean.TRUE);
     }
 
     @Test
@@ -130,43 +130,43 @@ public class ClientTransactionCommitCohortTest {
         Assert.assertEquals(PersistenceProtocol.THREE_PHASE, request.getPersistenceProtocol().get());
     }
 
-    void expectPreCommit(final TransactionTester tester) {
+    void expectPreCommit(final TransactionTester<?> tester) {
         tester.expectTransactionRequest(TransactionPreCommitRequest.class);
     }
 
-    void expectCommit(final TransactionTester tester) {
+    void expectCommit(final TransactionTester<?> tester) {
         tester.expectTransactionRequest(TransactionDoCommitRequest.class);
     }
 
-    void expectAbort(final TransactionTester tester) {
+    void expectAbort(final TransactionTester<?> tester) {
         tester.expectTransactionRequest(TransactionAbortRequest.class);
     }
 
-    void replyCanCommitSuccess(final TransactionTester tester) {
+    void replyCanCommitSuccess(final TransactionTester<?> tester) {
         final RequestSuccess<?, ?> success = new TransactionCanCommitSuccess(tester.getTransaction().getIdentifier(),
                 tester.getLastReceivedMessage().getSequence());
         tester.replySuccess(success);
     }
 
-    void replyPreCommitSuccess(final TransactionTester tester) {
+    void replyPreCommitSuccess(final TransactionTester<?> tester) {
         final RequestSuccess<?, ?> success = new TransactionPreCommitSuccess(tester.getTransaction().getIdentifier(),
                 tester.getLastReceivedMessage().getSequence());
         tester.replySuccess(success);
     }
 
-    void replyCommitSuccess(final TransactionTester tester) {
+    void replyCommitSuccess(final TransactionTester<?> tester) {
         final RequestSuccess<?, ?> success = new TransactionCommitSuccess(tester.getTransaction().getIdentifier(),
                 tester.getLastReceivedMessage().getSequence());
         tester.replySuccess(success);
     }
 
-    void replyAbortSuccess(final TransactionTester tester) {
+    void replyAbortSuccess(final TransactionTester<?> tester) {
         final RequestSuccess<?, ?> success = new TransactionAbortSuccess(tester.getTransaction().getIdentifier(),
                 tester.getLastReceivedMessage().getSequence());
         tester.replySuccess(success);
     }
 
-    private static TransactionTester createTransactionTester(final TestProbe backendProbe,
+    private static TransactionTester<RemoteProxyTransaction> createTransactionTester(final TestProbe backendProbe,
                                                              final ClientActorContext context,
                                                              final AbstractClientHistory history) {
         final ShardBackendInfo backend = new ShardBackendInfo(backendProbe.ref(), 0L, ABIVersion.BORON,
@@ -175,14 +175,13 @@ public class ClientTransactionCommitCohortTest {
                 AccessClientUtil.createConnectedConnection(context, 0L, backend);
         final ProxyHistory proxyHistory = ProxyHistory.createClient(history, connection, HISTORY_ID);
         final RemoteProxyTransaction transaction =
-                new RemoteProxyTransaction(proxyHistory, TRANSACTION_ID, false, false);
-        return new TransactionTester(transaction, connection, backendProbe);
+                new RemoteProxyTransaction(proxyHistory, TRANSACTION_ID, false, false, false);
+        return new TransactionTester<>(transaction, connection, backendProbe);
     }
 
-    private void replySuccess(final Collection<TransactionTester> transactions,
-                              final Consumer<TransactionTester> expect,
-                              final Consumer<TransactionTester> reply) {
-        for (final TransactionTester transaction : transactions) {
+    private static <T extends TransactionTester<?>> void replySuccess(final Collection<T> transactions,
+                              final Consumer<T> expect, final Consumer<T> reply) {
+        for (final T transaction : transactions) {
             expect.accept(transaction);
             reply.accept(transaction);
         }
@@ -201,8 +200,8 @@ public class ClientTransactionCommitCohortTest {
      * @throws Exception unexpected exception
      */
     private <T> void testOpSuccess(final Function<ClientTransactionCommitCohort, ListenableFuture<T>> operation,
-                                   final Consumer<TransactionTester> expectFunction,
-                                   final Consumer<TransactionTester> replyFunction,
+                                   final Consumer<TransactionTester<RemoteProxyTransaction>> expectFunction,
+                                   final Consumer<TransactionTester<RemoteProxyTransaction>> replyFunction,
                                    final T expectedResult) throws Exception {
         final ListenableFuture<T> result = operation.apply(cohort);
         replySuccess(transactions, expectFunction, replyFunction);
@@ -221,20 +220,21 @@ public class ClientTransactionCommitCohortTest {
      * @throws Exception unexpected exception
      */
     private <T> void testOpFail(final Function<ClientTransactionCommitCohort, ListenableFuture<T>> operation,
-                                final Consumer<TransactionTester> expectFunction,
-                                final Consumer<TransactionTester> replyFunction) throws Exception {
+            final Consumer<TransactionTester<RemoteProxyTransaction>> expectFunction,
+            final Consumer<TransactionTester<RemoteProxyTransaction>> replyFunction) throws Exception {
         final ListenableFuture<T> canCommit = operation.apply(cohort);
         //reply success to all except last transaction
         replySuccess(transactions.subList(0, transactions.size() - 1), expectFunction, replyFunction);
         //reply fail to last transaction
-        final TransactionTester last = transactions.get(transactions.size() - 1);
+        final TransactionTester<RemoteProxyTransaction> last = transactions.get(transactions.size() - 1);
         expectFunction.accept(last);
-        final RuntimeRequestException cause = new RuntimeRequestException("fail", new RuntimeException());
+        final RuntimeException e = new RuntimeException();
+        final RuntimeRequestException cause = new RuntimeRequestException("fail", e);
         last.replyFailure(cause);
         //check future fail
         final ExecutionException exception =
                 assertOperationThrowsException(() -> getWithTimeout(canCommit), ExecutionException.class);
-        Assert.assertEquals(cause, exception.getCause());
+        Assert.assertEquals(e, exception.getCause());
     }
 
-}
\ No newline at end of file
+}