Improved unit tests for AveragingProgressTracker class

Change-Id: I079b45304d82bfc9022321a1648fbdba13409c90
Signed-off-by: Ivan Hrasko <ivan.hrasko@pantheon.tech>

diff --git a/opendaylight/md-sal/cds-access-client/src/test/java/org/opendaylight/controller/cluster/access/client/AveragingProgressTrackerTest.java b/opendaylight/md-sal/cds-access-client/src/test/java/org/opendaylight/controller/cluster/access/client/AveragingProgressTrackerTest.java
index fdaff6fb4a631174e126467b2ad146e855e71fb0..934e158d2ac06a5cbd99a79c6ce7017f8b139927 100644 (file)
--- a/opendaylight/md-sal/cds-access-client/src/test/java/org/opendaylight/controller/cluster/access/client/AveragingProgressTrackerTest.java
+++ b/opendaylight/md-sal/cds-access-client/src/test/java/org/opendaylight/controller/cluster/access/client/AveragingProgressTrackerTest.java
@@ -8,52 +8,82 @@
 package org.opendaylight.controller.cluster.access.client;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
 
+import com.google.common.testing.FakeTicker;
+import java.util.concurrent.TimeUnit;
 import org.junit.Before;
 import org.junit.Test;
+import org.mockito.internal.matchers.apachecommons.ReflectionEquals;
 
 public class AveragingProgressTrackerTest {
+    private static final long CHECKER = TimeUnit.MILLISECONDS.toNanos(500);
+    private static final long TICKER_STEP = 100;
 
-    private static final long NOW = 1000000000;
-    private static final long CHECKER = 500000000;
-    private ProgressTracker averagingProgressTracker;
+    private static FakeTicker ticker;
+
+    private AveragingProgressTracker averagingProgressTracker;
 
     @Before
     public void setUp() {
-        averagingProgressTracker = new AveragingProgressTracker(4);
-        long delay = averagingProgressTracker.estimateIsolatedDelay(NOW);
-        assertEquals(0, delay);
-        for (int i = 0; i < 2; i++) {
-            delay = averagingProgressTracker.openTask(NOW);
-            assertEquals(0, delay);
-        }
+        ticker = new FakeTicker();
+        ticker.setAutoIncrementStep(TICKER_STEP, TimeUnit.MILLISECONDS);
+        averagingProgressTracker = new AveragingProgressTracker(3);
     }
 
     @Test
     public void estimateIsolatedDelayTest() {
-        long delay = averagingProgressTracker.openTask(NOW);
-        assertEquals(CHECKER, delay);
+        long time = ticker.read();
+        assertEquals(0, averagingProgressTracker.estimateIsolatedDelay(time));
+
+        // less than half
+        time = ticker.read();
+        assertTrue(averagingProgressTracker.openTask(time) <= CHECKER);
+        assertEquals(0, averagingProgressTracker.estimateIsolatedDelay(time));
 
-        delay = averagingProgressTracker.openTask(NOW);
-        assertEquals(NOW, delay);
+        // more than half but less than limit
+        time = ticker.read();
+        assertTrue(averagingProgressTracker.openTask(time) <= CHECKER);
+        assertTrue(averagingProgressTracker.estimateIsolatedDelay(time) < CHECKER);
 
-        delay = averagingProgressTracker.estimateIsolatedDelay(NOW);
-        assertEquals(CHECKER, delay);
+        // limit reached
+        time = ticker.read();
+        assertTrue(averagingProgressTracker.openTask(time) >= CHECKER);
+        assertEquals(CHECKER, averagingProgressTracker.estimateIsolatedDelay(time));
 
-        averagingProgressTracker.closeTask(3000000000L, 0, 0, 0);
+        // above limit, no higher isolated delays than CHECKER
+        time = ticker.read();
+        assertTrue(averagingProgressTracker.openTask(time) >= CHECKER);
+        assertEquals(CHECKER, averagingProgressTracker.estimateIsolatedDelay(time));
 
-        delay = averagingProgressTracker.estimateIsolatedDelay(NOW);
-        assertEquals(0, delay);
+        // close tasks to get under the half
+        averagingProgressTracker.closeTask(ticker.read(), 0, 0, 0);
+        averagingProgressTracker.closeTask(ticker.read(), 0, 0, 0);
+        averagingProgressTracker.closeTask(ticker.read(), 0, 0, 0);
+
+        assertEquals(0, averagingProgressTracker.estimateIsolatedDelay(ticker.read()));
     }
 
     @Test
     public void copyObjectTest() {
-        final ProgressTracker copyAverageProgressTracker =
-                new AveragingProgressTracker((AveragingProgressTracker) averagingProgressTracker);
-        assertEquals(copyAverageProgressTracker.openTask(NOW), averagingProgressTracker.openTask(NOW));
-        assertEquals(averagingProgressTracker.tasksClosed(), copyAverageProgressTracker.tasksClosed());
-        assertEquals(averagingProgressTracker.tasksEncountered(), copyAverageProgressTracker.tasksEncountered());
-        assertEquals(averagingProgressTracker.tasksOpen(), copyAverageProgressTracker.tasksOpen());
-    }
+        final AveragingProgressTracker copyAverageProgressTracker = new AveragingProgressTracker(
+                averagingProgressTracker);
 
+        // copied object is the same as original
+        assertTrue(new ReflectionEquals(averagingProgressTracker).matches(copyAverageProgressTracker));
+
+        // afterwards work of copied tracker is independent
+        averagingProgressTracker.openTask(ticker.read());
+
+        final long time = ticker.read();
+        assertNotEquals("Trackers are expected to return different results for tracking",
+                averagingProgressTracker.openTask(time), copyAverageProgressTracker.openTask(time));
+        assertNotEquals("Trackers are expected to encounter different amount of tasks",
+                averagingProgressTracker.tasksEncountered(), copyAverageProgressTracker.tasksEncountered());
+
+        // and copied object is then no more the same as original
+        assertFalse(new ReflectionEquals(averagingProgressTracker).matches(copyAverageProgressTracker));
+    }
 }
\ No newline at end of file