* 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.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;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import scala.concurrent.Promise;
@SuppressWarnings({"resource", "checkstyle:IllegalThrows", "checkstyle:AvoidHidingCauseException"})
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);
}
@Test
- public void testReadRoot() throws InterruptedException, ExecutionException,
- java.util.concurrent.TimeoutException {
- SchemaContext schemaContext = SchemaContextHelper.full();
+ public void testReadRoot() throws InterruptedException, ExecutionException, java.util.concurrent.TimeoutException {
+ EffectiveModelContext schemaContext = SchemaContextHelper.full();
Configuration configuration = mock(Configuration.class);
doReturn(configuration).when(mockActorContext).getConfiguration();
doReturn(schemaContext).when(mockActorContext).getSchemaContext();
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));
}
}