* 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"})
doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
- Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
+ 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);
+ NormalizedNode expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
doReturn(readDataReply(expectedNode)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
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());
}
public void testReadWithPriorRecordingOperationSuccessful() throws Exception {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
- NormalizedNode<?, ?> expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode expectedNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModifications(actorRef, 1);
transactionProxy.write(TestModel.TEST_PATH, expectedNode);
- Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
+ 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)
public void testExistsWithPriorRecordingOperationSuccessful() throws Exception {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModifications(actorRef, 1);
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(
dataStoreContextBuilder.shardBatchedModificationCount(1);
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModifications(actorRef, 1);
expectBatchedModificationsReady(actorRef);
- final NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
final TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_WRITE);
final CountDownLatch readComplete = new CountDownLatch(1);
final AtomicReference<Throwable> caughtEx = new AtomicReference<>();
com.google.common.util.concurrent.Futures.addCallback(transactionProxy.read(TestModel.TEST_PATH),
- new FutureCallback<Optional<NormalizedNode<?, ?>>>() {
+ new FutureCallback<Optional<NormalizedNode>>() {
@Override
- public void onSuccess(final Optional<NormalizedNode<?, ?>> result) {
+ public void onSuccess(final Optional<NormalizedNode> result) {
try {
transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
} catch (Exception e) {
dataStoreContextBuilder.shardBatchedModificationCount(1);
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModifications(actorRef, 1);
public void testReadWrite() {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
- final NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
public void testReadyWithReadWrite() {
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE);
- final NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
doReturn(readDataReply(null)).when(mockActorContext).executeOperationAsync(
eq(actorSelection(actorRef)), eqReadData(), any(Timeout.class));
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());
}
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModificationsReady(actorRef, true);
dataStoreContextBuilder.shardBatchedModificationCount(1).writeOnlyTransactionOptimizationsEnabled(true);
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModificationsReady(actorRef, true);
ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectFailedBatchedModifications(actorRef);
expectReadyLocalTransaction(shardActorRef, true);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
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
expectReadyLocalTransaction(shardActorRef, true);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, WRITE_ONLY);
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
return dataTree;
}
- private static DataTree createDataTree(final NormalizedNode<?, ?> readResponse) {
+ private static DataTree createDataTree(final NormalizedNode readResponse) {
DataTree dataTree = mock(DataTree.class);
DataTreeSnapshot dataTreeSnapshot = mock(DataTreeSnapshot.class);
DataTreeModification dataTreeModification = mock(DataTreeModification.class);
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;
}
@Test
public void testWriteCompletionForLocalShard() {
completeOperationLocal(transactionProxy -> {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
transactionProxy.write(TestModel.TEST_PATH, nodeToWrite);
@Test
public void testWriteThrottlingWhenShardFound() {
throttleOperation(transactionProxy -> {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectIncompleteBatchedModifications();
public void testWriteThrottlingWhenShardNotFound() {
// Confirm that there is no throttling when the Shard is not found
completeOperation(transactionProxy -> {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModifications(2);
@Test
public void testWriteCompletion() {
completeOperation(transactionProxy -> {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModifications(2);
@Test
public void testMergeThrottlingWhenShardFound() {
throttleOperation(transactionProxy -> {
- NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectIncompleteBatchedModifications();
@Test
public void testMergeThrottlingWhenShardNotFound() {
completeOperation(transactionProxy -> {
- NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModifications(2);
@Test
public void testMergeCompletion() {
completeOperation(transactionProxy -> {
- NormalizedNode<?, ?> nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToMerge = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModifications(2);
@Test
public void testMergeCompletionForLocalShard() {
completeOperationLocal(transactionProxy -> {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
transactionProxy.merge(TestModel.TEST_PATH, nodeToWrite);
@Test
public void testReadCompletion() {
completeOperation(transactionProxy -> {
- NormalizedNode<?, ?> nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
doReturn(readDataReply(nodeToRead)).when(mockActorContext).executeOperationAsync(
any(ActorSelection.class), eqReadData(), any(Timeout.class));
@Test
public void testReadCompletionForLocalShard() {
- final NormalizedNode<?, ?> nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
completeOperationLocal(transactionProxy -> {
transactionProxy.read(TestModel.TEST_PATH);
@Test
public void testExistsCompletionForLocalShard() {
- final NormalizedNode<?, ?> nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode nodeToRead = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
completeOperationLocal(transactionProxy -> {
transactionProxy.exists(TestModel.TEST_PATH);
public void testReadyThrottling() {
throttleOperation(transactionProxy -> {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
expectBatchedModifications(1);
@Test
public void testReadyThrottlingWithTwoTransactionContexts() {
throttleOperation(transactionProxy -> {
- NormalizedNode<?, ?> nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- NormalizedNode<?, ?> carsNode = ImmutableNodes.containerNode(CarsModel.BASE_QNAME);
+ NormalizedNode nodeToWrite = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode carsNode = ImmutableNodes.containerNode(CarsModel.BASE_QNAME);
expectBatchedModifications(2);
expectBatchedModifications(actorRef, shardBatchedModificationCount);
YangInstanceIdentifier writePath1 = TestModel.TEST_PATH;
- NormalizedNode<?, ?> writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
YangInstanceIdentifier writePath2 = TestModel.OUTER_LIST_PATH;
- NormalizedNode<?, ?> writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
+ NormalizedNode writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
YangInstanceIdentifier writePath3 = TestModel.INNER_LIST_PATH;
- NormalizedNode<?, ?> writeNode3 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
+ NormalizedNode writeNode3 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
YangInstanceIdentifier mergePath1 = TestModel.TEST_PATH;
- NormalizedNode<?, ?> mergeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode mergeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
YangInstanceIdentifier mergePath2 = TestModel.OUTER_LIST_PATH;
- NormalizedNode<?, ?> mergeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
+ NormalizedNode mergeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
YangInstanceIdentifier mergePath3 = TestModel.INNER_LIST_PATH;
- NormalizedNode<?, ?> mergeNode3 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
+ NormalizedNode mergeNode3 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
YangInstanceIdentifier deletePath1 = TestModel.TEST_PATH;
YangInstanceIdentifier deletePath2 = TestModel.OUTER_LIST_PATH;
expectBatchedModifications(actorRef, shardBatchedModificationCount);
final YangInstanceIdentifier writePath1 = TestModel.TEST_PATH;
- final NormalizedNode<?, ?> writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode writeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
YangInstanceIdentifier writePath2 = TestModel.OUTER_LIST_PATH;
- NormalizedNode<?, ?> writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
+ NormalizedNode writeNode2 = ImmutableNodes.containerNode(TestModel.OUTER_LIST_QNAME);
final YangInstanceIdentifier mergePath1 = TestModel.TEST_PATH;
- final NormalizedNode<?, ?> mergeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ final NormalizedNode mergeNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
YangInstanceIdentifier mergePath2 = TestModel.INNER_LIST_PATH;
- NormalizedNode<?, ?> mergeNode2 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
+ NormalizedNode mergeNode2 = ImmutableNodes.containerNode(TestModel.INNER_LIST_QNAME);
final YangInstanceIdentifier deletePath = TestModel.OUTER_LIST_PATH;
transactionProxy.write(writePath1, writeNode1);
transactionProxy.write(writePath2, writeNode2);
- Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(writePath2).get(5, TimeUnit.SECONDS);
+ 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();
doReturn(Sets.newHashSet("test", "cars")).when(configuration).getAllShardNames();
- NormalizedNode<?, ?> expectedNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
- NormalizedNode<?, ?> expectedNode2 = ImmutableNodes.containerNode(CarsModel.CARS_QNAME);
+ NormalizedNode expectedNode1 = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
+ NormalizedNode expectedNode2 = ImmutableNodes.containerNode(CarsModel.CARS_QNAME);
setUpReadData("test", NormalizedNodeAggregatorTest.getRootNode(expectedNode1, schemaContext));
setUpReadData("cars", NormalizedNodeAggregatorTest.getRootNode(expectedNode2, schemaContext));
TransactionProxy transactionProxy = new TransactionProxy(mockComponentFactory, READ_ONLY);
- Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
- YangInstanceIdentifier.EMPTY).get(5, TimeUnit.SECONDS);
+ Optional<NormalizedNode> readOptional = transactionProxy.read(
+ YangInstanceIdentifier.empty()).get(5, TimeUnit.SECONDS);
- assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
+ assertTrue("NormalizedNode isPresent", readOptional.isPresent());
- NormalizedNode<?, ?> normalizedNode = readOptional.get();
+ NormalizedNode normalizedNode = readOptional.get();
- assertTrue("Expect value to be a Collection", normalizedNode.getValue() instanceof Collection);
+ assertTrue("Expect value to be a Collection", normalizedNode.body() instanceof Collection);
@SuppressWarnings("unchecked")
- Collection<NormalizedNode<?,?>> collection = (Collection<NormalizedNode<?,?>>) normalizedNode.getValue();
+ Collection<NormalizedNode> collection = (Collection<NormalizedNode>) normalizedNode.body();
- for (NormalizedNode<?,?> node : collection) {
+ for (NormalizedNode node : collection) {
assertTrue("Expected " + node + " to be a ContainerNode", node instanceof ContainerNode);
}
}
- private void setUpReadData(final String shardName, final NormalizedNode<?, ?> expectedNode) {
+ private void setUpReadData(final String shardName, final NormalizedNode expectedNode) {
ActorSystem actorSystem = getSystem();
ActorRef shardActorRef = getSystem().actorOf(Props.create(DoNothingActor.class));
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));
}
}