Remove useless UnsupportedOperationExceptions

[bgpcep.git] / testtool-util / src / main / java / org / opendaylight / protocol / util / CheckUtil.java

diff --git a/testtool-util/src/main/java/org/opendaylight/protocol/util/CheckUtil.java b/testtool-util/src/main/java/org/opendaylight/protocol/util/CheckUtil.java
index 26b20291983a5761f629a931296f8ce9925c8295..603719e225e760250158449916b119cfb607b864 100644 (file)
--- a/testtool-util/src/main/java/org/opendaylight/protocol/util/CheckUtil.java
+++ b/testtool-util/src/main/java/org/opendaylight/protocol/util/CheckUtil.java
@@ -7,58 +7,79 @@
  */
 package org.opendaylight.protocol.util;
 
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
+import static com.google.common.base.Verify.verify;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
 
-import com.google.common.base.Optional;
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Stopwatch;
-import com.google.common.base.Verify;
 import com.google.common.util.concurrent.Uninterruptibles;
 import io.netty.util.concurrent.Future;
+import java.util.Optional;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
 public final class CheckUtil {
-    private static final int LATCH_TIMEOUT = 10;
     private static final int SLEEP_FOR = 200;
     private static final int TIMEOUT = 30;
 
     private CheckUtil() {
-        throw new UnsupportedOperationException();
+        // Hidden on purpose
     }
 
     public static <T extends Future<?>> void waitFutureSuccess(final T future) {
+        waitFutureSuccess(future, SLEEP_FOR, TimeUnit.SECONDS);
+    }
+
+    @VisibleForTesting
+    static <T extends Future<?>> void waitFutureSuccess(final T future, final long timeout, final TimeUnit unit) {
         final CountDownLatch latch = new CountDownLatch(1);
         future.addListener(future1 -> latch.countDown());
-        Uninterruptibles.awaitUninterruptibly(latch, LATCH_TIMEOUT, TimeUnit.SECONDS);
-        Verify.verify(future.isSuccess());
+        Uninterruptibles.awaitUninterruptibly(latch, timeout, unit);
+        verify(future.isSuccess());
+    }
+
+    public static <R, T extends DataObject> R readDataOperational(final DataBroker dataBroker,
+            final InstanceIdentifier<T> iid, final Function<T, R> function) throws InterruptedException,
+                ExecutionException {
+        return readDataOperational(dataBroker, iid, function, TIMEOUT);
+    }
+
+    @VisibleForTesting
+    static <R, T extends DataObject> R readDataOperational(final DataBroker dataBroker,
+            final InstanceIdentifier<T> iid, final Function<T, R> function, final int timeout)
+            throws InterruptedException, ExecutionException {
+        return readData(dataBroker, OPERATIONAL, iid, function, timeout);
     }
 
-    public static <R, T extends DataObject> R readDataOperational(final DataBroker dataBroker, final InstanceIdentifier<T> iid,
-        final Function<T, R> function) throws ReadFailedException {
-        return readData(dataBroker, OPERATIONAL, iid, function);
+    public static <R, T extends DataObject> R readDataConfiguration(final DataBroker dataBroker,
+            final InstanceIdentifier<T> iid, final Function<T, R> function) throws InterruptedException,
+                ExecutionException {
+        return readDataConfiguration(dataBroker, iid, function, TIMEOUT);
     }
 
-    public static <R, T extends DataObject> R readDataConfiguration(final DataBroker dataBroker, final InstanceIdentifier<T> iid,
-        final Function<T, R> function) throws ReadFailedException {
-        return readData(dataBroker, CONFIGURATION, iid, function);
+    @VisibleForTesting
+    static <R, T extends DataObject> R readDataConfiguration(final DataBroker dataBroker,
+            final InstanceIdentifier<T> iid, final Function<T, R> function, final int timeout)
+            throws InterruptedException, ExecutionException {
+        return readData(dataBroker, CONFIGURATION, iid, function, timeout);
     }
 
     private static <R, T extends DataObject> R readData(final DataBroker dataBroker, final LogicalDatastoreType ldt,
-        final InstanceIdentifier<T> iid, final Function<T, R> function) throws ReadFailedException {
+            final InstanceIdentifier<T> iid, final Function<T, R> function, final int timeout)
+            throws InterruptedException, ExecutionException {
         AssertionError lastError = null;
         final Stopwatch sw = Stopwatch.createStarted();
-        while (sw.elapsed(TimeUnit.SECONDS) <= TIMEOUT) {
-            try (final ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
-                final Optional<T> data = tx.read(ldt, iid).checkedGet();
+        do {
+            try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
+                final Optional<T> data = tx.read(ldt, iid).get();
                 if (data.isPresent()) {
                     try {
                         return function.apply(data.get());
@@ -68,37 +89,38 @@ public final class CheckUtil {
                     }
                 }
             }
-        }
+        } while (sw.elapsed(TimeUnit.SECONDS) <= timeout);
         throw lastError;
     }
 
-    public static <T extends DataObject> T checkPresentOperational(final DataBroker dataBroker, final InstanceIdentifier<T> iid)
-        throws ReadFailedException {
-        return readData(dataBroker, OPERATIONAL, iid, bgpRib -> bgpRib);
+    public static <T extends DataObject> T checkPresentOperational(final DataBroker dataBroker,
+            final InstanceIdentifier<T> iid) throws InterruptedException, ExecutionException {
+        return readData(dataBroker, OPERATIONAL, iid, bgpRib -> bgpRib, TIMEOUT);
     }
 
     public static <T extends DataObject> T checkPresentConfiguration(final DataBroker dataBroker,
-        final InstanceIdentifier<T> iid) throws ReadFailedException {
-        return readData(dataBroker, CONFIGURATION, iid, bgpRib -> bgpRib);
+            final InstanceIdentifier<T> iid) throws InterruptedException, ExecutionException {
+        return readData(dataBroker, CONFIGURATION, iid, bgpRib -> bgpRib, TIMEOUT);
     }
 
     public static <T extends DataObject> void checkNotPresentOperational(final DataBroker dataBroker,
-        final InstanceIdentifier<T> iid) throws ReadFailedException {
+            final InstanceIdentifier<T> iid) throws InterruptedException, ExecutionException {
         checkNotPresent(dataBroker, OPERATIONAL, iid);
     }
 
     public static <T extends DataObject> void checkNotPresentConfiguration(final DataBroker dataBroker,
-        final InstanceIdentifier<T> iid) throws ReadFailedException {
+            final InstanceIdentifier<T> iid) throws InterruptedException, ExecutionException {
         checkNotPresent(dataBroker, CONFIGURATION, iid);
     }
 
     private static <T extends DataObject> void checkNotPresent(final DataBroker dataBroker,
-        final LogicalDatastoreType ldt, final InstanceIdentifier<T> iid) throws ReadFailedException {
+            final LogicalDatastoreType ldt, final InstanceIdentifier<T> iid) throws InterruptedException,
+                ExecutionException {
         AssertionError lastError = null;
         final Stopwatch sw = Stopwatch.createStarted();
         while (sw.elapsed(TimeUnit.SECONDS) <= 10) {
-            try (final ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
-                final com.google.common.base.Optional<T> data = tx.read(ldt, iid).checkedGet();
+            try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
+                final Optional<T> data = tx.read(ldt, iid).get();
                 try {
                     assert !data.isPresent();
                     return;
@@ -112,9 +134,13 @@ public final class CheckUtil {
     }
 
     public static void checkEquals(final CheckEquals function) throws Exception {
+        checkEquals(function, TIMEOUT);
+    }
+
+    public static void checkEquals(final CheckEquals function, final int timeout) throws Exception {
         AssertionError lastError = null;
         final Stopwatch sw = Stopwatch.createStarted();
-        while (sw.elapsed(TimeUnit.SECONDS) <= TIMEOUT) {
+        while (sw.elapsed(TimeUnit.SECONDS) <= timeout) {
             try {
                 function.check();
                 return;
@@ -126,10 +152,15 @@ public final class CheckUtil {
         throw lastError;
     }
 
-    public static void checkReceivedMessages(final ListenerCheck listener, final int numberOfMessages)
-        throws ReadFailedException {
+    public static void checkReceivedMessages(final ListenerCheck listener, final int numberOfMessages) {
+        checkReceivedMessages(listener, numberOfMessages, TIMEOUT);
+    }
+
+    @VisibleForTesting
+    static void checkReceivedMessages(final ListenerCheck listener, final int numberOfMessages,
+            final int timeout) {
         final Stopwatch sw = Stopwatch.createStarted();
-        while (sw.elapsed(TimeUnit.SECONDS) <= TIMEOUT) {
+        while (sw.elapsed(TimeUnit.SECONDS) <= timeout) {
             if (listener.getListMessageSize() != numberOfMessages) {
                 Uninterruptibles.sleepUninterruptibly(SLEEP_FOR, TimeUnit.MILLISECONDS);
             } else {
@@ -137,14 +168,15 @@ public final class CheckUtil {
             }
         }
         throw new AssertionError("Expected " + numberOfMessages + " but received "
-            + listener.getListMessageSize());
+                + listener.getListMessageSize());
     }
 
     public interface ListenerCheck {
         int getListMessageSize();
     }
+
     @FunctionalInterface
     public interface CheckEquals {
         void check() throws ExecutionException, InterruptedException;
     }
-}
\ No newline at end of file
+}