import akka.util.Timeout;
import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.Timer;
-import com.google.common.base.Objects;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.CheckedFuture;
import com.typesafe.config.Config;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Objects;
import java.util.concurrent.TimeUnit;
import org.junit.AfterClass;
import org.junit.Before;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return argThat(matcher);
}
- protected DataExists eqSerializedDataExists() {
- ArgumentMatcher<DataExists> matcher = new ArgumentMatcher<DataExists>() {
- @Override
- public boolean matches(Object argument) {
- return DataExists.SERIALIZABLE_CLASS.equals(argument.getClass()) &&
- DataExists.fromSerializable(argument).getPath().equals(TestModel.TEST_PATH);
- }
- };
-
- return argThat(matcher);
- }
-
protected DataExists eqDataExists() {
ArgumentMatcher<DataExists> matcher = new ArgumentMatcher<DataExists>() {
@Override
return argThat(matcher);
}
- protected ReadData eqSerializedReadData() {
- return eqSerializedReadData(TestModel.TEST_PATH);
- }
-
- protected ReadData eqSerializedReadData(final YangInstanceIdentifier path) {
- ArgumentMatcher<ReadData> matcher = new ArgumentMatcher<ReadData>() {
- @Override
- public boolean matches(Object argument) {
- return ReadData.SERIALIZABLE_CLASS.equals(argument.getClass()) &&
- ReadData.fromSerializable(argument).getPath().equals(path);
- }
- };
-
- return argThat(matcher);
- }
-
protected ReadData eqReadData() {
return eqReadData(TestModel.TEST_PATH);
}
}
protected Future<DataExistsReply> dataExistsReply(boolean exists) {
- return Futures.successful(DataExistsReply.create(exists));
+ return Futures.successful(new DataExistsReply(exists, DataStoreVersions.CURRENT_VERSION));
}
protected Future<BatchedModificationsReply> batchedModificationsReply(int count) {
protected void expectBatchedModifications(ActorRef actorRef, int count) {
doReturn(batchedModificationsReply(count)).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), isA(BatchedModifications.class));
+ eq(actorSelection(actorRef)), isA(BatchedModifications.class), any(Timeout.class));
}
protected void expectBatchedModificationsReady(ActorRef actorRef) {
protected void expectBatchedModificationsReady(ActorRef actorRef, boolean doCommitOnReady) {
doReturn(doCommitOnReady ? Futures.successful(new CommitTransactionReply().toSerializable()) :
readyTxReply(actorRef.path().toString())).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), isA(BatchedModifications.class));
+ eq(actorSelection(actorRef)), isA(BatchedModifications.class), any(Timeout.class));
}
protected void expectBatchedModifications(int count) {
doReturn(batchedModificationsReply(count)).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), isA(BatchedModifications.class));
+ any(ActorSelection.class), isA(BatchedModifications.class), any(Timeout.class));
}
protected void expectIncompleteBatchedModifications() {
doReturn(incompleteFuture()).when(mockActorContext).executeOperationAsync(
- any(ActorSelection.class), isA(BatchedModifications.class));
+ any(ActorSelection.class), isA(BatchedModifications.class), any(Timeout.class));
}
protected void expectFailedBatchedModifications(ActorRef actorRef) {
doReturn(Futures.failed(new TestException())).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(actorRef)), isA(BatchedModifications.class));
+ eq(actorSelection(actorRef)), isA(BatchedModifications.class), any(Timeout.class));
}
protected void expectReadyLocalTransaction(ActorRef actorRef, boolean doCommitOnReady) {
protected Future<PrimaryShardInfo> primaryShardInfoReply(ActorSystem actorSystem, ActorRef actorRef,
short transactionVersion) {
return Futures.successful(new PrimaryShardInfo(actorSystem.actorSelection(actorRef.path()),
- transactionVersion, Optional.<DataTree>absent()));
+ transactionVersion));
}
protected ActorRef setupActorContextWithoutInitialCreateTransaction(ActorSystem actorSystem, String shardName) {
doReturn(primaryShardInfoReply(actorSystem, actorRef, transactionVersion)).
when(mockActorContext).findPrimaryShardAsync(eq(shardName));
- doReturn(false).when(mockActorContext).isPathLocal(actorRef.path().toString());
-
return actorRef;
}
ArgumentCaptor<BatchedModifications> batchedModificationsCaptor =
ArgumentCaptor.forClass(BatchedModifications.class);
verify(mockActorContext, Mockito.atLeastOnce()).executeOperationAsync(
- eq(actorSelection(actorRef)), batchedModificationsCaptor.capture());
+ eq(actorSelection(actorRef)), batchedModificationsCaptor.capture(), any(Timeout.class));
List<BatchedModifications> batchedModifications = filterCaptured(
batchedModificationsCaptor, BatchedModifications.class);
}
}
- for(int i = 0; i < expReplies.length; i++) {
- Object expReply = expReplies[i];
+ for (Object expReply : expReplies) {
boolean found = false;
Iterator<?> iter = futureResults.iterator();
while(iter.hasNext()) {
Object actual = iter.next();
- if(CommitTransactionReply.SERIALIZABLE_CLASS.isInstance(expReply) &&
- CommitTransactionReply.SERIALIZABLE_CLASS.isInstance(actual)) {
+ if(CommitTransactionReply.isSerializedType(expReply) &&
+ CommitTransactionReply.isSerializedType(actual)) {
found = true;
- } else if(expReply instanceof ActorSelection && Objects.equal(expReply, actual)) {
+ } else if(expReply instanceof ActorSelection && Objects.equals(expReply, actual)) {
found = true;
} else if(expReply instanceof Class && ((Class<?>)expReply).isInstance(actual)) {
found = true;