<artifactId>akka-testkit_${scala.version}</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>com.google.guava</groupId>
+ <artifactId>guava-testlib</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-clustering-commons</artifactId>
import static org.mockito.Mockito.doReturn;
import akka.actor.ActorRef;
+import com.google.common.testing.FakeTicker;
import org.junit.Before;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.opendaylight.controller.cluster.access.concepts.FrontendIdentifier;
import org.opendaylight.controller.cluster.access.concepts.FrontendType;
import org.opendaylight.controller.cluster.access.concepts.MemberName;
-import org.opendaylight.controller.cluster.common.actor.TestTicker;
/**
* Abstract base class for client actors and their components.
@Mock
private ActorRef mockSelf;
- protected final TestTicker ticker = new TestTicker();
+ protected final FakeTicker ticker = new FakeTicker();
@Before
public void setup() {
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.testkit.TestProbe;
+import com.google.common.testing.FakeTicker;
import java.util.Optional;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import org.opendaylight.controller.cluster.access.concepts.RequestException;
import org.opendaylight.controller.cluster.access.concepts.RequestFailure;
import org.opendaylight.controller.cluster.access.concepts.Response;
-import org.opendaylight.controller.cluster.common.actor.TestTicker;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
import scala.concurrent.duration.FiniteDuration;
@Mock
private ClientActorContext mockContext;
- private TestTicker ticker;
+ private FakeTicker ticker;
private BackendInfo mockBackendInfo;
private MockRequest mockRequest;
private MockRequest mockRequest2;
doNothing().when(mockCallback).accept(any(MockFailure.class));
- ticker = new TestTicker();
- ticker.increment(ThreadLocalRandom.current().nextLong());
+ ticker = new FakeTicker();
+ ticker.advance(ThreadLocalRandom.current().nextLong());
doReturn(ticker).when(mockContext).ticker();
mockActor = TestProbe.apply(actorSystem);
public void testRunTimeoutWithTimeoutLess() throws NoProgressException {
queue.sendRequest(mockRequest, mockCallback);
- ticker.increment(AbstractClientConnection.REQUEST_TIMEOUT_NANOS - 1);
+ ticker.advance(AbstractClientConnection.REQUEST_TIMEOUT_NANOS - 1);
Optional<FiniteDuration> ret = queue.checkTimeout(ticker.read());
assertNotNull(ret);
queue.sendRequest(mockRequest, mockCallback);
- ticker.increment(AbstractClientConnection.REQUEST_TIMEOUT_NANOS);
+ ticker.advance(AbstractClientConnection.REQUEST_TIMEOUT_NANOS);
Optional<FiniteDuration> ret = queue.checkTimeout(ticker.read());
assertNull(ret);
queue.sendRequest(mockRequest, mockCallback);
- ticker.increment(AbstractClientConnection.REQUEST_TIMEOUT_NANOS + 1);
+ ticker.advance(AbstractClientConnection.REQUEST_TIMEOUT_NANOS + 1);
Optional<FiniteDuration> ret = queue.checkTimeout(ticker.read());
assertNull(ret);
public void testRunTimeoutWithoutProgressExact() throws NoProgressException {
queue.sendRequest(mockRequest, mockCallback);
- ticker.increment(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS);
+ ticker.advance(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS);
// Kaboom
queue.runTimer((ClientActorBehavior) mockBehavior);
public void testRunTimeoutWithoutProgressMore() throws NoProgressException {
queue.sendRequest(mockRequest, mockCallback);
- ticker.increment(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS + 1);
+ ticker.advance(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS + 1);
// Kaboom
queue.runTimer((ClientActorBehavior) mockBehavior);
@Test
public void testRunTimeoutEmptyWithoutProgressExact() throws NoProgressException {
- ticker.increment(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS);
+ ticker.advance(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS);
// No problem
Optional<FiniteDuration> ret = queue.checkTimeout(ticker.read());
@Test
public void testRunTimeoutEmptyWithoutProgressMore() throws NoProgressException {
- ticker.increment(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS + 1);
+ ticker.advance(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS + 1);
// No problem
Optional<FiniteDuration> ret = queue.checkTimeout(ticker.read());
queue.sendRequest(mockRequest, mockCallback);
- ticker.increment(10);
+ ticker.advance(10);
queue.sendRequest(mockRequest2, mockCallback);
queue.receiveResponse(mockResponseEnvelope);
- ticker.increment(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS - 11);
+ ticker.advance(AbstractClientConnection.NO_PROGRESS_TIMEOUT_NANOS - 11);
Optional<FiniteDuration> ret = queue.checkTimeout(ticker.read());
assertNull(ret);
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.testkit.TestProbe;
+import com.google.common.testing.FakeTicker;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.Consumer;
import org.junit.After;
import org.opendaylight.controller.cluster.access.concepts.RequestException;
import org.opendaylight.controller.cluster.access.concepts.RequestFailure;
import org.opendaylight.controller.cluster.access.concepts.Response;
-import org.opendaylight.controller.cluster.common.actor.TestTicker;
import org.opendaylight.yangtools.concepts.WritableIdentifier;
/**
@Mock
private ClientActorBehavior<?> mockBehavior;
- private TestTicker ticker;
+ private FakeTicker ticker;
private Request<WritableIdentifier, ?> mockRequest;
private Response<WritableIdentifier, ?> mockResponse;
doNothing().when(mockCallback).accept(any(MockFailure.class));
- ticker = new TestTicker();
- ticker.increment(ThreadLocalRandom.current().nextLong());
+ ticker = new FakeTicker();
+ ticker.advance(ThreadLocalRandom.current().nextLong());
mockActor = TestProbe.apply(actorSystem);
mockRequest = new MockRequest(mockIdentifier, mockReplyTo);
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-java</artifactId>
</dependency>
+ <dependency>
+ <groupId>com.google.guava</groupId>
+ <artifactId>guava-testlib</artifactId>
+ </dependency>
<!-- Scala -->
<dependency>
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
+import com.google.common.testing.FakeTicker;
import java.util.List;
import org.junit.Assert;
import org.junit.Before;
private static final Logger LOG = LoggerFactory.getLogger(MessageTrackerTest.class);
- private TestTicker ticker;
+ private FakeTicker ticker;
private MessageTracker messageTracker;
@Before
public void setup() {
- ticker = new TestTicker();
+ ticker = new FakeTicker();
messageTracker = new MessageTracker(Foo.class, 10, ticker);
}
MessageTracker.Context context1 = messageTracker.received(new Foo());
context1.close();
- ticker.increment(MILLISECONDS.toNanos(20));
+ ticker.advance(20, MILLISECONDS);
MessageTracker.Context context2 = messageTracker.received(new Foo());
context2.close();
}
MessageTracker.Context context1 = messageTracker.received(new Foo());
context1.close();
- ticker.increment(MILLISECONDS.toNanos(20));
+ ticker.advance(20, MILLISECONDS);
MessageTracker.Context context2 = messageTracker.received(new Foo());
Assert.assertEquals(true, context2.error().isPresent());
messageTracker.received(10L).close();
MessageTracker.Context context = messageTracker.received(100);
- ticker.increment(MILLISECONDS.toNanos(20));
+ ticker.advance(20, MILLISECONDS);
context.close();
LOG.error("An error occurred : {}" , error);
}
-
@Test
public void testMetExpectationOnTracking() {
messageTracker.begin();
MessageTracker.Context context1 = messageTracker.received(new Foo());
context1.close();
- ticker.increment(MILLISECONDS.toNanos(1));
+ ticker.advance(1, MILLISECONDS);
MessageTracker.Context context2 = messageTracker.received(new Foo());
Assert.assertEquals(false, context2.error().isPresent());
public void testDelayInFirstExpectedMessageArrival() {
messageTracker.begin();
- ticker.increment(MILLISECONDS.toNanos(20));
+ ticker.advance(20, MILLISECONDS);
MessageTracker.Context context = messageTracker.received(new Foo());
public void testCallingBeginDoesNotResetWatch() {
messageTracker.begin();
- ticker.increment(MILLISECONDS.toNanos(20));
+ ticker.advance(20, MILLISECONDS);
messageTracker.begin();
+++ /dev/null
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * 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.controller.cluster.common.actor;
-
-import com.google.common.base.Ticker;
-
-/**
- * Utility {@link Ticker} where passage of time is explicitly controlled via {@link #increment(long)}.
- *
- * @author Robert Varga
- */
-public final class TestTicker extends Ticker {
- private long counter = 0;
-
- @Override
- public long read() {
- return counter;
- }
-
- public long increment(final long ticks) {
- counter += ticks;
- return counter;
- }
-}