package org.opendaylight.controller.cluster.datastore;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.isA;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
- assertEquals("NormalizedNode isPresent", false, readOptional.isPresent());
+ assertFalse("NormalizedNode isPresent", readOptional.isPresent());
NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
readOptional = transactionProxy.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
- assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
+ assertTrue("NormalizedNode isPresent", readOptional.isPresent());
assertEquals("Response NormalizedNode", expectedNode, readOptional.get());
}
Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
- assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
+ assertTrue("NormalizedNode isPresent", readOptional.isPresent());
assertEquals("Response NormalizedNode", expectedNode, readOptional.get());
InOrder inOrder = Mockito.inOrder(mockActorContext);
Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).get();
- assertEquals("Exists response", false, exists);
+ assertEquals("Exists response", Boolean.FALSE, exists);
doReturn(dataExistsReply(true)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqDataExists(), any(Timeout.class));
exists = transactionProxy.exists(TestModel.TEST_PATH).get();
- assertEquals("Exists response", true, exists);
+ assertEquals("Exists response", Boolean.TRUE, exists);
}
@Test(expected = PrimaryNotFoundException.class)
Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).get();
- assertEquals("Exists response", true, exists);
+ assertEquals("Exists response", Boolean.TRUE, exists);
InOrder inOrder = Mockito.inOrder(mockActorContext);
inOrder.verify(mockActorContext).executeOperationAsync(
ArgumentCaptor<BatchedModifications> batchedMods = ArgumentCaptor.forClass(BatchedModifications.class);
verify(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef1)), batchedMods.capture(), any(Timeout.class));
- assertEquals("Participating shards present", true,
- batchedMods.getValue().getParticipatingShardNames().isPresent());
+ assertTrue("Participating shards present", batchedMods.getValue().getParticipatingShardNames().isPresent());
assertEquals("Participating shards", expShardNames, batchedMods.getValue().getParticipatingShardNames().get());
batchedMods = ArgumentCaptor.forClass(BatchedModifications.class);
verify(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef2)), batchedMods.capture(), any(Timeout.class));
- assertEquals("Participating shards present", true,
- batchedMods.getValue().getParticipatingShardNames().isPresent());
+ assertTrue("Participating shards present", batchedMods.getValue().getParticipatingShardNames().isPresent());
assertEquals("Participating shards", expShardNames, batchedMods.getValue().getParticipatingShardNames().get());
ArgumentCaptor<ReadyLocalTransaction> readyLocalTx = ArgumentCaptor.forClass(ReadyLocalTransaction.class);
verify(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef3)), readyLocalTx.capture(), any(Timeout.class));
- assertEquals("Participating shards present", true,
- readyLocalTx.getValue().getParticipatingShardNames().isPresent());
+ assertTrue("Participating shards present", readyLocalTx.getValue().getParticipatingShardNames().isPresent());
assertEquals("Participating shards", expShardNames, readyLocalTx.getValue().getParticipatingShardNames().get());
}
ArgumentCaptor<ReadyLocalTransaction> readyLocalTx = ArgumentCaptor.forClass(ReadyLocalTransaction.class);
verify(mockActorContext).executeOperationAsync(
eq(actorSelection(shardActorRef)), readyLocalTx.capture(), any(Timeout.class));
- assertEquals("Participating shards present", false,
- readyLocalTx.getValue().getParticipatingShardNames().isPresent());
+ assertFalse("Participating shards present", readyLocalTx.getValue().getParticipatingShardNames().isPresent());
}
@Test
doReturn(dataTreeSnapshot).when(dataTree).takeSnapshot();
doReturn(dataTreeModification).when(dataTreeSnapshot).newModification();
- doReturn(java.util.Optional.of(readResponse)).when(dataTreeModification).readNode(
- any(YangInstanceIdentifier.class));
+ doReturn(Optional.of(readResponse)).when(dataTreeModification).readNode(any(YangInstanceIdentifier.class));
return dataTree;
}
Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(writePath2).get(5, TimeUnit.SECONDS);
- assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
+ assertTrue("NormalizedNode isPresent", readOptional.isPresent());
assertEquals("Response NormalizedNode", writeNode2, readOptional.get());
transactionProxy.merge(mergePath1, mergeNode1);
transactionProxy.delete(deletePath);
Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).get();
- assertEquals("Exists response", true, exists);
+ assertEquals("Exists response", Boolean.TRUE, exists);
- assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
+ assertTrue("NormalizedNode isPresent", readOptional.isPresent());
assertEquals("Response NormalizedNode", mergeNode2, readOptional.get());
List<BatchedModifications> batchedModifications = captureBatchedModifications(actorRef);
TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
- YangInstanceIdentifier.EMPTY).get(5, TimeUnit.SECONDS);
+ YangInstanceIdentifier.empty()).get(5, TimeUnit.SECONDS);
- assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
+ assertTrue("NormalizedNode isPresent", readOptional.isPresent());
NormalizedNode<?, ?> normalizedNode = readOptional.get();
eqCreateTransaction(memberName, TransactionType.READ_ONLY), any(Timeout.class));
doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
- eq(actorSelection(txActorRef)), eqReadData(YangInstanceIdentifier.EMPTY), any(Timeout.class));
+ eq(actorSelection(txActorRef)), eqReadData(YangInstanceIdentifier.empty()), any(Timeout.class));
}
}