This patch removes implicit boxing/unboxing by aligning boolean/Boolean
expectations.
Future<Boolean>.get() will return a Boolean, hence use assertEquals() for
these (and Optional<Boolean>). Doing that instead of assertTrue()/assertFalse()
eliminates a single Eclipse info-level message about Boolean being unboxes.
This also has better behavior: if the tested method returns null, we'll get
an assertion failure instead of a NPE.
For isPersent() and other methods which return a boolean, use assertTrue()
or assertFalse(). Doing that instead of assertEquals() eliminates two Eclipse
info-level messages about boxing the two arguments to Boolean, for some
reason there is no assertEquals(boolean, boolean).
Change-Id: If86ef9fb1ecf4cdceb45bc079bba1a86cff311ac
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
43 files changed:
*/
package org.opendaylight.controller.cluster.databroker;
*/
package org.opendaylight.controller.cluster.databroker;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.doReturn;
+
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Optional;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Optional;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.opendaylight.controller.cluster.access.client.ClientActorContext;
import org.opendaylight.controller.cluster.databroker.actors.dds.ClientSnapshot;
import org.mockito.MockitoAnnotations;
import org.opendaylight.controller.cluster.access.client.ClientActorContext;
import org.opendaylight.controller.cluster.databroker.actors.dds.ClientSnapshot;
public void setUp() {
MockitoAnnotations.initMocks(this);
public void setUp() {
MockitoAnnotations.initMocks(this);
- Mockito.doReturn(CLIENT_ID).when(clientContext).getIdentifier();
- Mockito.doReturn(TRANSACTION_ID).when(delegate).getIdentifier();
+ doReturn(CLIENT_ID).when(clientContext).getIdentifier();
+ doReturn(TRANSACTION_ID).when(delegate).getIdentifier();
- Mockito.doReturn(Futures.immediateCheckedFuture(Boolean.TRUE)).when(delegate)
- .exists(YangInstanceIdentifier.EMPTY);
- Mockito.doReturn(Futures.immediateCheckedFuture(Optional.of(data))).when(delegate)
- .read(YangInstanceIdentifier.EMPTY);
+ doReturn(Futures.immediateCheckedFuture(Boolean.TRUE)).when(delegate).exists(YangInstanceIdentifier.EMPTY);
+ doReturn(Futures.immediateCheckedFuture(Optional.of(data))).when(delegate).read(YangInstanceIdentifier.EMPTY);
object = new ClientBackedReadTransaction(delegate, null, null);
}
@Test
public void testRead() throws Exception {
object = new ClientBackedReadTransaction(delegate, null, null);
}
@Test
public void testRead() throws Exception {
- final ListenableFuture<Optional<NormalizedNode<?, ?>>> result = object().read(
- YangInstanceIdentifier.EMPTY);
+ final ListenableFuture<Optional<NormalizedNode<?, ?>>> result = object().read(YangInstanceIdentifier.EMPTY);
final Optional<NormalizedNode<?, ?>> resultData = result.get();
final Optional<NormalizedNode<?, ?>> resultData = result.get();
- Assert.assertTrue(resultData.isPresent());
- Assert.assertEquals(data, resultData.get());
+ assertTrue(resultData.isPresent());
+ assertEquals(data, resultData.get());
}
@Test
public void testExists() throws Exception {
final ListenableFuture<Boolean> result = object().exists(YangInstanceIdentifier.EMPTY);
}
@Test
public void testExists() throws Exception {
final ListenableFuture<Boolean> result = object().exists(YangInstanceIdentifier.EMPTY);
- Assert.assertTrue(result.get());
+ assertEquals(Boolean.TRUE, result.get());
*/
package org.opendaylight.controller.cluster.databroker;
*/
package org.opendaylight.controller.cluster.databroker;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.doReturn;
+
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import java.util.Optional;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import java.util.Optional;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.opendaylight.controller.cluster.databroker.actors.dds.ClientTransaction;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
import org.mockito.MockitoAnnotations;
import org.opendaylight.controller.cluster.databroker.actors.dds.ClientTransaction;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
public void setUp() {
MockitoAnnotations.initMocks(this);
public void setUp() {
MockitoAnnotations.initMocks(this);
- Mockito.doReturn(TRANSACTION_ID).when(delegate).getIdentifier();
- Mockito.doReturn(readyCohort).when(delegate).ready();
+ doReturn(TRANSACTION_ID).when(delegate).getIdentifier();
+ doReturn(readyCohort).when(delegate).ready();
- Mockito.doReturn(Futures.immediateCheckedFuture(Boolean.TRUE)).when(delegate)
- .exists(YangInstanceIdentifier.EMPTY);
- Mockito.doReturn(Futures.immediateCheckedFuture(Optional.of(data))).when(delegate)
- .read(YangInstanceIdentifier.EMPTY);
+ doReturn(Futures.immediateCheckedFuture(Boolean.TRUE)).when(delegate).exists(YangInstanceIdentifier.EMPTY);
+ doReturn(Futures.immediateCheckedFuture(Optional.of(data))).when(delegate).read(YangInstanceIdentifier.EMPTY);
object = new ClientBackedReadWriteTransaction(delegate, null);
}
object = new ClientBackedReadWriteTransaction(delegate, null);
}
public void testRead() throws Exception {
final FluentFuture<Optional<NormalizedNode<?, ?>>> result = object().read(YangInstanceIdentifier.EMPTY);
final Optional<NormalizedNode<?, ?>> resultData = result.get();
public void testRead() throws Exception {
final FluentFuture<Optional<NormalizedNode<?, ?>>> result = object().read(YangInstanceIdentifier.EMPTY);
final Optional<NormalizedNode<?, ?>> resultData = result.get();
- Assert.assertTrue(resultData.isPresent());
- Assert.assertEquals(data, resultData.get());
+ assertTrue(resultData.isPresent());
+ assertEquals(data, resultData.get());
}
@Test
public void testExists() throws Exception {
}
@Test
public void testExists() throws Exception {
- Assert.assertTrue(object().exists(YangInstanceIdentifier.EMPTY).get());
+ assertEquals(Boolean.TRUE, object().exists(YangInstanceIdentifier.EMPTY).get());
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFalseFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateNullFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateTrueFluentFuture;
import com.google.common.base.Throwables;
import com.google.common.collect.ClassToInstanceMap;
import com.google.common.base.Throwables;
import com.google.common.collect.ClassToInstanceMap;
new Thread(() -> {
Uninterruptibles.awaitUninterruptibly(asyncCanCommitContinue,
10, TimeUnit.SECONDS);
new Thread(() -> {
Uninterruptibles.awaitUninterruptibly(asyncCanCommitContinue,
10, TimeUnit.SECONDS);
+ future.set(Boolean.TRUE);
+ future.set(Boolean.TRUE);
}
return future;
};
doAnswer(asyncCanCommit).when(mockCohort1).canCommit();
}
return future;
};
doAnswer(asyncCanCommit).when(mockCohort1).canCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort1).preCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort1).commit();
+ doReturn(immediateNullFluentFuture()).when(mockCohort1).preCommit();
+ doReturn(immediateNullFluentFuture()).when(mockCohort1).commit();
- doReturn(Futures.immediateFuture(true)).when(mockCohort2).canCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort2).preCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort2).commit();
+ doReturn(immediateTrueFluentFuture()).when(mockCohort2).canCommit();
+ doReturn(immediateNullFluentFuture()).when(mockCohort2).preCommit();
+ doReturn(immediateNullFluentFuture()).when(mockCohort2).commit();
ListenableFuture<? extends CommitInfo> future =
coordinator.commit(transaction, Arrays.asList(mockCohort1, mockCohort2));
ListenableFuture<? extends CommitInfo> future =
coordinator.commit(transaction, Arrays.asList(mockCohort1, mockCohort2));
asyncCanCommitContinue.countDown();
asyncCanCommitContinue.countDown();
- assertEquals("Submit complete", true, doneLatch.await(5, TimeUnit.SECONDS));
+ assertTrue("Submit complete", doneLatch.await(5, TimeUnit.SECONDS));
if (caughtEx.get() != null) {
Throwables.throwIfUnchecked(caughtEx.get());
if (caughtEx.get() != null) {
Throwables.throwIfUnchecked(caughtEx.get());
@Test
public void testSubmitWithNegativeCanCommitResponse() throws Exception {
@Test
public void testSubmitWithNegativeCanCommitResponse() throws Exception {
- doReturn(Futures.immediateFuture(true)).when(mockCohort1).canCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort1).abort();
+ doReturn(immediateTrueFluentFuture()).when(mockCohort1).canCommit();
+ doReturn(immediateNullFluentFuture()).when(mockCohort1).abort();
- doReturn(Futures.immediateFuture(false)).when(mockCohort2).canCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort2).abort();
+ doReturn(Futures.immediateFuture(Boolean.FALSE)).when(mockCohort2).canCommit();
+ doReturn(immediateNullFluentFuture()).when(mockCohort2).abort();
DOMStoreThreePhaseCommitCohort mockCohort3 = mock(DOMStoreThreePhaseCommitCohort.class);
DOMStoreThreePhaseCommitCohort mockCohort3 = mock(DOMStoreThreePhaseCommitCohort.class);
- doReturn(Futures.immediateFuture(false)).when(mockCohort3).canCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort3).abort();
+ doReturn(Futures.immediateFuture(Boolean.FALSE)).when(mockCohort3).canCommit();
+ doReturn(immediateNullFluentFuture()).when(mockCohort3).abort();
ListenableFuture<? extends CommitInfo> future = coordinator.commit(
transaction, Arrays.asList(mockCohort1, mockCohort2, mockCohort3));
ListenableFuture<? extends CommitInfo> future = coordinator.commit(
transaction, Arrays.asList(mockCohort1, mockCohort2, mockCohort3));
assertFailure(future, null, mockCohort1, mockCohort2, mockCohort3);
}
assertFailure(future, null, mockCohort1, mockCohort2, mockCohort3);
}
- private static void assertFailure(final ListenableFuture<?> future,
- final Exception expCause, final DOMStoreThreePhaseCommitCohort... mockCohorts)
- throws Exception {
+ private static void assertFailure(final ListenableFuture<?> future, final Exception expCause,
+ final DOMStoreThreePhaseCommitCohort... mockCohorts) throws Exception {
try {
future.get(5, TimeUnit.SECONDS);
fail("Expected TransactionCommitFailedException");
try {
future.get(5, TimeUnit.SECONDS);
fail("Expected TransactionCommitFailedException");
@Test
public void testSubmitWithCanCommitException() throws Exception {
@Test
public void testSubmitWithCanCommitException() throws Exception {
- doReturn(Futures.immediateFuture(true)).when(mockCohort1).canCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort1).abort();
+ doReturn(immediateTrueFluentFuture()).when(mockCohort1).canCommit();
+ doReturn(immediateNullFluentFuture()).when(mockCohort1).abort();
IllegalStateException cause = new IllegalStateException("mock");
doReturn(Futures.immediateFailedFuture(cause)).when(mockCohort2).canCommit();
IllegalStateException cause = new IllegalStateException("mock");
doReturn(Futures.immediateFailedFuture(cause)).when(mockCohort2).canCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort2).abort();
+ doReturn(immediateNullFluentFuture()).when(mockCohort2).abort();
FluentFuture<? extends CommitInfo> future = coordinator.commit(
transaction, Arrays.asList(mockCohort1, mockCohort2));
FluentFuture<? extends CommitInfo> future = coordinator.commit(
transaction, Arrays.asList(mockCohort1, mockCohort2));
@Test
public void testSubmitWithCanCommitDataStoreUnavailableException() throws Exception {
@Test
public void testSubmitWithCanCommitDataStoreUnavailableException() throws Exception {
- doReturn(Futures.immediateFuture(true)).when(mockCohort1).canCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort1).abort();
+ doReturn(immediateTrueFluentFuture()).when(mockCohort1).canCommit();
+ doReturn(immediateNullFluentFuture()).when(mockCohort1).abort();
NoShardLeaderException rootCause = new NoShardLeaderException("mock");
DataStoreUnavailableException cause = new DataStoreUnavailableException(rootCause.getMessage(), rootCause);
doReturn(Futures.immediateFailedFuture(rootCause)).when(mockCohort2).canCommit();
NoShardLeaderException rootCause = new NoShardLeaderException("mock");
DataStoreUnavailableException cause = new DataStoreUnavailableException(rootCause.getMessage(), rootCause);
doReturn(Futures.immediateFailedFuture(rootCause)).when(mockCohort2).canCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort2).abort();
+ doReturn(immediateNullFluentFuture()).when(mockCohort2).abort();
FluentFuture<? extends CommitInfo> future = coordinator.commit(
transaction, Arrays.asList(mockCohort1, mockCohort2));
FluentFuture<? extends CommitInfo> future = coordinator.commit(
transaction, Arrays.asList(mockCohort1, mockCohort2));
@Test
public void testSubmitWithPreCommitException() throws Exception {
@Test
public void testSubmitWithPreCommitException() throws Exception {
- doReturn(Futures.immediateFuture(true)).when(mockCohort1).canCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort1).preCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort1).abort();
+ doReturn(immediateTrueFluentFuture()).when(mockCohort1).canCommit();
+ doReturn(immediateNullFluentFuture()).when(mockCohort1).preCommit();
+ doReturn(immediateNullFluentFuture()).when(mockCohort1).abort();
- doReturn(Futures.immediateFuture(true)).when(mockCohort2).canCommit();
+ doReturn(immediateTrueFluentFuture()).when(mockCohort2).canCommit();
IllegalStateException cause = new IllegalStateException("mock");
doReturn(Futures.immediateFailedFuture(cause)).when(mockCohort2).preCommit();
IllegalStateException cause = new IllegalStateException("mock");
doReturn(Futures.immediateFailedFuture(cause)).when(mockCohort2).preCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort2).abort();
+ doReturn(immediateNullFluentFuture()).when(mockCohort2).abort();
DOMStoreThreePhaseCommitCohort mockCohort3 = mock(DOMStoreThreePhaseCommitCohort.class);
DOMStoreThreePhaseCommitCohort mockCohort3 = mock(DOMStoreThreePhaseCommitCohort.class);
- doReturn(Futures.immediateFuture(true)).when(mockCohort3).canCommit();
+ doReturn(immediateTrueFluentFuture()).when(mockCohort3).canCommit();
doReturn(Futures.immediateFailedFuture(new IllegalStateException("mock2")))
.when(mockCohort3).preCommit();
doReturn(Futures.immediateFailedFuture(new IllegalStateException("mock2")))
.when(mockCohort3).preCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort3).abort();
+ doReturn(immediateNullFluentFuture()).when(mockCohort3).abort();
FluentFuture<? extends CommitInfo> future = coordinator.commit(
transaction, Arrays.asList(mockCohort1, mockCohort2, mockCohort3));
FluentFuture<? extends CommitInfo> future = coordinator.commit(
transaction, Arrays.asList(mockCohort1, mockCohort2, mockCohort3));
@Test
public void testSubmitWithCommitException() throws Exception {
@Test
public void testSubmitWithCommitException() throws Exception {
- doReturn(Futures.immediateFuture(true)).when(mockCohort1).canCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort1).preCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort1).commit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort1).abort();
+ doReturn(immediateTrueFluentFuture()).when(mockCohort1).canCommit();
+ doReturn(immediateNullFluentFuture()).when(mockCohort1).preCommit();
+ doReturn(immediateNullFluentFuture()).when(mockCohort1).commit();
+ doReturn(immediateNullFluentFuture()).when(mockCohort1).abort();
- doReturn(Futures.immediateFuture(true)).when(mockCohort2).canCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort2).preCommit();
+ doReturn(immediateTrueFluentFuture()).when(mockCohort2).canCommit();
+ doReturn(immediateNullFluentFuture()).when(mockCohort2).preCommit();
IllegalStateException cause = new IllegalStateException("mock");
doReturn(Futures.immediateFailedFuture(cause)).when(mockCohort2).commit();
IllegalStateException cause = new IllegalStateException("mock");
doReturn(Futures.immediateFailedFuture(cause)).when(mockCohort2).commit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort2).abort();
+ doReturn(immediateNullFluentFuture()).when(mockCohort2).abort();
DOMStoreThreePhaseCommitCohort mockCohort3 = mock(DOMStoreThreePhaseCommitCohort.class);
DOMStoreThreePhaseCommitCohort mockCohort3 = mock(DOMStoreThreePhaseCommitCohort.class);
- doReturn(Futures.immediateFuture(true)).when(mockCohort3).canCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort3).preCommit();
+ doReturn(immediateTrueFluentFuture()).when(mockCohort3).canCommit();
+ doReturn(immediateNullFluentFuture()).when(mockCohort3).preCommit();
doReturn(Futures.immediateFailedFuture(new IllegalStateException("mock2")))
.when(mockCohort3).commit();
doReturn(Futures.immediateFailedFuture(new IllegalStateException("mock2")))
.when(mockCohort3).commit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort3).abort();
+ doReturn(immediateNullFluentFuture()).when(mockCohort3).abort();
FluentFuture<? extends CommitInfo> future = coordinator.commit(
transaction, Arrays.asList(mockCohort1, mockCohort2, mockCohort3));
FluentFuture<? extends CommitInfo> future = coordinator.commit(
transaction, Arrays.asList(mockCohort1, mockCohort2, mockCohort3));
@Test
public void testSubmitWithAbortException() throws Exception {
@Test
public void testSubmitWithAbortException() throws Exception {
- doReturn(Futures.immediateFuture(true)).when(mockCohort1).canCommit();
+ doReturn(immediateTrueFluentFuture()).when(mockCohort1).canCommit();
doReturn(Futures.immediateFailedFuture(new IllegalStateException("mock abort error")))
.when(mockCohort1).abort();
IllegalStateException cause = new IllegalStateException("mock canCommit error");
doReturn(Futures.immediateFailedFuture(cause)).when(mockCohort2).canCommit();
doReturn(Futures.immediateFailedFuture(new IllegalStateException("mock abort error")))
.when(mockCohort1).abort();
IllegalStateException cause = new IllegalStateException("mock canCommit error");
doReturn(Futures.immediateFailedFuture(cause)).when(mockCohort2).canCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort2).abort();
+ doReturn(immediateNullFluentFuture()).when(mockCohort2).abort();
FluentFuture<? extends CommitInfo> future = coordinator.commit(
transaction, Arrays.asList(mockCohort1, mockCohort2));
FluentFuture<? extends CommitInfo> future = coordinator.commit(
transaction, Arrays.asList(mockCohort1, mockCohort2));
doReturn(mockStoreReadWriteTransaction).when(operationalDomStore).newReadWriteTransaction();
doReturn(mockCohort).when(mockStoreReadWriteTransaction).ready();
doReturn(mockStoreReadWriteTransaction).when(operationalDomStore).newReadWriteTransaction();
doReturn(mockCohort).when(mockStoreReadWriteTransaction).ready();
- doReturn(Futures.immediateFuture(false)).when(mockCohort).canCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohort).abort();
+ doReturn(immediateFalseFluentFuture()).when(mockCohort).canCommit();
+ doReturn(immediateNullFluentFuture()).when(mockCohort).abort();
final CountDownLatch latch = new CountDownLatch(1);
final List<DOMStoreThreePhaseCommitCohort> commitCohorts = new ArrayList<>();
final CountDownLatch latch = new CountDownLatch(1);
final List<DOMStoreThreePhaseCommitCohort> commitCohorts = new ArrayList<>();
doReturn(configTransaction).when(configDomStore).newReadWriteTransaction();
doReturn(mockCohortOperational).when(operationalTransaction).ready();
doReturn(configTransaction).when(configDomStore).newReadWriteTransaction();
doReturn(mockCohortOperational).when(operationalTransaction).ready();
- doReturn(Futures.immediateFuture(false)).when(mockCohortOperational).canCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohortOperational).abort();
+ doReturn(immediateFalseFluentFuture()).when(mockCohortOperational).canCommit();
+ doReturn(immediateNullFluentFuture()).when(mockCohortOperational).abort();
doReturn(mockCohortConfig).when(configTransaction).ready();
doReturn(mockCohortConfig).when(configTransaction).ready();
- doReturn(Futures.immediateFuture(false)).when(mockCohortConfig).canCommit();
- doReturn(Futures.immediateFuture(null)).when(mockCohortConfig).abort();
+ doReturn(immediateFalseFluentFuture()).when(mockCohortConfig).canCommit();
+ doReturn(immediateNullFluentFuture()).when(mockCohortConfig).abort();
final CountDownLatch latch = new CountDownLatch(1);
final List<DOMStoreThreePhaseCommitCohort> commitCohorts = new ArrayList<>();
final CountDownLatch latch = new CountDownLatch(1);
final List<DOMStoreThreePhaseCommitCohort> commitCohorts = new ArrayList<>();
*/
package org.opendaylight.controller.cluster.databroker.actors.dds;
*/
package org.opendaylight.controller.cluster.databroker.actors.dds;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.getWithTimeout;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Optional;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.getWithTimeout;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Optional;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public void testExists() throws Exception {
final ListenableFuture<Boolean> exists = getHandle().exists(PATH);
verify(getDataTreeSnapshot()).readNode(PATH);
public void testExists() throws Exception {
final ListenableFuture<Boolean> exists = getHandle().exists(PATH);
verify(getDataTreeSnapshot()).readNode(PATH);
- Assert.assertFalse(getWithTimeout(exists));
+ assertEquals(Boolean.FALSE, getWithTimeout(exists));
}
@Test
public void testRead() throws Exception {
final ListenableFuture<Optional<NormalizedNode<?, ?>>> exists = getHandle().read(PATH);
verify(getDataTreeSnapshot()).readNode(PATH);
}
@Test
public void testRead() throws Exception {
final ListenableFuture<Optional<NormalizedNode<?, ?>>> exists = getHandle().read(PATH);
verify(getDataTreeSnapshot()).readNode(PATH);
- Assert.assertFalse(getWithTimeout(exists).isPresent());
+ assertFalse(getWithTimeout(exists).isPresent());
*/
package org.opendaylight.controller.cluster.databroker.actors.dds;
*/
package org.opendaylight.controller.cluster.databroker.actors.dds;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.TRANSACTION_ID;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.TRANSACTION_ID;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Optional;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Optional;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
public void testExists() throws Exception {
final FluentFuture<Boolean> exists = getHandle().exists(PATH);
verify(modification).readNode(PATH);
public void testExists() throws Exception {
final FluentFuture<Boolean> exists = getHandle().exists(PATH);
verify(modification).readNode(PATH);
- Assert.assertTrue(getWithTimeout(exists));
+ assertEquals(Boolean.TRUE, getWithTimeout(exists));
final FluentFuture<Optional<NormalizedNode<?, ?>>> resultFuture = getHandle().read(PATH);
verify(modification).readNode(PATH);
final Optional<NormalizedNode<?, ?>> result = getWithTimeout(resultFuture);
final FluentFuture<Optional<NormalizedNode<?, ?>>> resultFuture = getHandle().read(PATH);
verify(modification).readNode(PATH);
final Optional<NormalizedNode<?, ?>> result = getWithTimeout(resultFuture);
- Assert.assertTrue(result.isPresent());
- Assert.assertEquals(DATA, result.get());
+ assertTrue(result.isPresent());
+ assertEquals(DATA, result.get());
@Test
public void testReadyEmpty() throws Exception {
final DOMStoreThreePhaseCommitCohort cohort = getHandle().ready();
@Test
public void testReadyEmpty() throws Exception {
final DOMStoreThreePhaseCommitCohort cohort = getHandle().ready();
- assertFutureEquals(true, cohort.canCommit());
+ assertFutureEquals(Boolean.TRUE, cohort.canCommit());
assertFutureEquals(null, cohort.preCommit());
assertFutureEquals(null, cohort.commit());
}
assertFutureEquals(null, cohort.preCommit());
assertFutureEquals(null, cohort.commit());
}
final ListenableFuture<Boolean> actual = cohort.canCommit();
final CommitLocalTransactionRequest request =
backendRespondToRequest(CommitLocalTransactionRequest.class, response);
final ListenableFuture<Boolean> actual = cohort.canCommit();
final CommitLocalTransactionRequest request =
backendRespondToRequest(CommitLocalTransactionRequest.class, response);
- Assert.assertEquals(modification, request.getModification());
- assertFutureEquals(true, actual);
+ assertEquals(modification, request.getModification());
+ assertFutureEquals(Boolean.TRUE, actual);
assertFutureEquals(null, cohort.preCommit());
assertFutureEquals(null, cohort.commit());
}
assertFutureEquals(null, cohort.preCommit());
assertFutureEquals(null, cohort.commit());
}
*/
package org.opendaylight.controller.cluster.databroker.actors.dds;
*/
package org.opendaylight.controller.cluster.databroker.actors.dds;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.verify;
import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.CLIENT_ID;
import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.HISTORY_ID;
import static org.mockito.Mockito.verify;
import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.CLIENT_ID;
import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.HISTORY_ID;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Optional;
import org.junit.After;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Optional;
import org.junit.After;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
public void testCanCommit() throws Exception {
final ListenableFuture<Boolean> canCommit = cohort.canCommit();
final ModifyTransactionRequest request = transaction.expectTransactionRequest(ModifyTransactionRequest.class);
public void testCanCommit() throws Exception {
final ListenableFuture<Boolean> canCommit = cohort.canCommit();
final ModifyTransactionRequest request = transaction.expectTransactionRequest(ModifyTransactionRequest.class);
- Assert.assertTrue(request.getPersistenceProtocol().isPresent());
- Assert.assertEquals(PersistenceProtocol.SIMPLE, request.getPersistenceProtocol().get());
+ assertTrue(request.getPersistenceProtocol().isPresent());
+ assertEquals(PersistenceProtocol.SIMPLE, request.getPersistenceProtocol().get());
final RequestSuccess<?, ?> success = new TransactionCommitSuccess(transaction.getTransaction().getIdentifier(),
transaction.getLastReceivedMessage().getSequence());
transaction.replySuccess(success);
final RequestSuccess<?, ?> success = new TransactionCommitSuccess(transaction.getTransaction().getIdentifier(),
transaction.getLastReceivedMessage().getSequence());
transaction.replySuccess(success);
- Assert.assertTrue(getWithTimeout(canCommit));
+ assertEquals(Boolean.TRUE, getWithTimeout(canCommit));
}
@Test
public void testPreCommit() throws Exception {
final ListenableFuture<Void> preCommit = cohort.preCommit();
}
@Test
public void testPreCommit() throws Exception {
final ListenableFuture<Void> preCommit = cohort.preCommit();
- Assert.assertNull(getWithTimeout(preCommit));
+ assertNull(getWithTimeout(preCommit));
}
@Test
public void testAbort() throws Exception {
final ListenableFuture<Void> abort = cohort.abort();
verify(history).onTransactionComplete(transaction.getTransaction().getIdentifier());
}
@Test
public void testAbort() throws Exception {
final ListenableFuture<Void> abort = cohort.abort();
verify(history).onTransactionComplete(transaction.getTransaction().getIdentifier());
- Assert.assertNull(getWithTimeout(abort));
+ assertNull(getWithTimeout(abort));
}
@Test
public void testCommit() throws Exception {
final ListenableFuture<Void> commit = cohort.commit();
verify(history).onTransactionComplete(transaction.getTransaction().getIdentifier());
}
@Test
public void testCommit() throws Exception {
final ListenableFuture<Void> commit = cohort.commit();
verify(history).onTransactionComplete(transaction.getTransaction().getIdentifier());
- Assert.assertNull(getWithTimeout(commit));
+ assertNull(getWithTimeout(commit));
}
private static TransactionTester<?> createTransactionTester(final TestProbe backendProbe,
}
private static TransactionTester<?> createTransactionTester(final TestProbe backendProbe,
*/
package org.opendaylight.controller.cluster.databroker.actors.dds;
*/
package org.opendaylight.controller.cluster.databroker.actors.dds;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
import static org.mockito.Mockito.verify;
import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.TRANSACTION_ID;
import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.getWithTimeout;
import static org.mockito.Mockito.verify;
import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.TRANSACTION_ID;
import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.getWithTimeout;
@Test
public void testCanCommit() throws Exception {
final ListenableFuture<Boolean> canCommit = cohort.canCommit();
@Test
public void testCanCommit() throws Exception {
final ListenableFuture<Boolean> canCommit = cohort.canCommit();
- Assert.assertTrue(getWithTimeout(canCommit));
+ assertEquals(Boolean.TRUE, getWithTimeout(canCommit));
}
@Test
public void testPreCommit() throws Exception {
final ListenableFuture<Void> preCommit = cohort.preCommit();
}
@Test
public void testPreCommit() throws Exception {
final ListenableFuture<Void> preCommit = cohort.preCommit();
- Assert.assertNull(getWithTimeout(preCommit));
+ assertNull(getWithTimeout(preCommit));
}
@Test
public void testAbort() throws Exception {
final ListenableFuture<Void> abort = cohort.abort();
verify(history).onTransactionComplete(TRANSACTION_ID);
}
@Test
public void testAbort() throws Exception {
final ListenableFuture<Void> abort = cohort.abort();
verify(history).onTransactionComplete(TRANSACTION_ID);
- Assert.assertNull(getWithTimeout(abort));
+ assertNull(getWithTimeout(abort));
@Override
@Test
public void testExists() throws Exception {
@Override
@Test
public void testExists() throws Exception {
- assertFutureEquals(true, transaction.exists(PATH_1));
- assertFutureEquals(false, transaction.exists(PATH_3));
+ assertFutureEquals(Boolean.TRUE, transaction.exists(PATH_1));
+ assertFutureEquals(Boolean.FALSE, transaction.exists(PATH_3));
final TransactionTester<LocalReadWriteProxyTransaction> tester = getTester();
final CommitLocalTransactionRequest req = tester.expectTransactionRequest(CommitLocalTransactionRequest.class);
tester.replySuccess(new TransactionCommitSuccess(TRANSACTION_ID, req.getSequence()));
final TransactionTester<LocalReadWriteProxyTransaction> tester = getTester();
final CommitLocalTransactionRequest req = tester.expectTransactionRequest(CommitLocalTransactionRequest.class);
tester.replySuccess(new TransactionCommitSuccess(TRANSACTION_ID, req.getSequence()));
- assertFutureEquals(true, result);
+ assertFutureEquals(Boolean.TRUE, result);
@AfterClass
public static void tearDownClass() {
@AfterClass
public static void tearDownClass() {
- TestKit.shutdownActorSystem(system, Boolean.TRUE);
+ TestKit.shutdownActorSystem(system, true);
Props.create(new DelegatingShardCreator(creator)).withDispatcher(Dispatchers.DefaultDispatcherId()),
"testRecovery");
Props.create(new DelegatingShardCreator(creator)).withDispatcher(Dispatchers.DefaultDispatcherId()),
"testRecovery");
- assertEquals("Recovery complete", true, recoveryComplete.await(5, TimeUnit.SECONDS));
+ assertTrue("Recovery complete", recoveryComplete.await(5, TimeUnit.SECONDS));
// Verify data in the data store.
// Verify data in the data store.
@After
public void actorSystemCleanup() {
for (final ActorSystem system : actorSystems) {
@After
public void actorSystemCleanup() {
for (final ActorSystem system : actorSystems) {
- TestKit.shutdownActorSystem(system, Boolean.TRUE);
+ TestKit.shutdownActorSystem(system, true);
package org.opendaylight.controller.cluster.datastore;
import static org.junit.Assert.assertEquals;
package org.opendaylight.controller.cluster.datastore;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doAnswer;
RegisterDataTreeChangeListener registerMsg = kit.expectMsgClass(timeout,
RegisterDataTreeChangeListener.class);
assertEquals("getPath", path, registerMsg.getPath());
RegisterDataTreeChangeListener registerMsg = kit.expectMsgClass(timeout,
RegisterDataTreeChangeListener.class);
assertEquals("getPath", path, registerMsg.getPath());
- assertEquals("isRegisterOnAllInstances", false, registerMsg.isRegisterOnAllInstances());
+ assertFalse("isRegisterOnAllInstances", registerMsg.isRegisterOnAllInstances());
kit.reply(new RegisterDataTreeNotificationListenerReply(kit.getRef()));
kit.reply(new RegisterDataTreeNotificationListenerReply(kit.getRef()));
RegisterDataTreeChangeListener registerMsg = kit.expectMsgClass(timeout,
RegisterDataTreeChangeListener.class);
assertEquals("getPath", path, registerMsg.getPath());
RegisterDataTreeChangeListener registerMsg = kit.expectMsgClass(timeout,
RegisterDataTreeChangeListener.class);
assertEquals("getPath", path, registerMsg.getPath());
- assertEquals("isRegisterOnAllInstances", true, registerMsg.isRegisterOnAllInstances());
+ assertTrue("isRegisterOnAllInstances", registerMsg.isRegisterOnAllInstances());
package org.opendaylight.controller.cluster.datastore;
import static org.junit.Assert.assertEquals;
package org.opendaylight.controller.cluster.datastore;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.opendaylight.controller.cluster.datastore.DatastoreContext.DEFAULT_HEARTBEAT_INTERVAL_IN_MILLIS;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.opendaylight.controller.cluster.datastore.DatastoreContext.DEFAULT_HEARTBEAT_INTERVAL_IN_MILLIS;
DatastoreContext context = introspector.getContext();
assertEquals(1000, context.getShardBatchedModificationCount());
DatastoreContext context = introspector.getContext();
assertEquals(1000, context.getShardBatchedModificationCount());
- assertEquals(false, context.isTransactionDebugContextEnabled());
+ assertFalse(context.isTransactionDebugContextEnabled());
properties.put("persistent", "false");
boolean updated = introspector.update(properties);
properties.put("persistent", "false");
boolean updated = introspector.update(properties);
- assertEquals("updated", true, updated);
+ assertTrue("updated", updated);
DatastoreContext context = introspector.getContext();
assertEquals(31, context.getShardTransactionIdleTimeout().toMinutes());
DatastoreContext context = introspector.getContext();
assertEquals(31, context.getShardTransactionIdleTimeout().toMinutes());
assertEquals(1111, context.getDataStoreProperties().getMaxDataChangeExecutorQueueSize());
assertEquals(2222, context.getDataStoreProperties().getMaxDataChangeListenerQueueSize());
assertEquals(3333, context.getDataStoreProperties().getMaxDataStoreExecutorQueueSize());
assertEquals(1111, context.getDataStoreProperties().getMaxDataChangeExecutorQueueSize());
assertEquals(2222, context.getDataStoreProperties().getMaxDataChangeListenerQueueSize());
assertEquals(3333, context.getDataStoreProperties().getMaxDataStoreExecutorQueueSize());
- assertEquals(false, context.isPersistent());
+ assertFalse(context.isPersistent());
properties.put("shard-transaction-idle-timeout-in-minutes", "32");
properties.put("operation-timeout-in-seconds", "27");
properties.put("shard-transaction-idle-timeout-in-minutes", "32");
properties.put("operation-timeout-in-seconds", "27");
properties.put("persistent", "true");
updated = introspector.update(properties);
properties.put("persistent", "true");
updated = introspector.update(properties);
- assertEquals("updated", true, updated);
+ assertTrue("updated", updated);
context = introspector.getContext();
assertEquals(32, context.getShardTransactionIdleTimeout().toMinutes());
context = introspector.getContext();
assertEquals(32, context.getShardTransactionIdleTimeout().toMinutes());
assertEquals(1111, context.getDataStoreProperties().getMaxDataChangeExecutorQueueSize());
assertEquals(2222, context.getDataStoreProperties().getMaxDataChangeListenerQueueSize());
assertEquals(4444, context.getDataStoreProperties().getMaxDataStoreExecutorQueueSize());
assertEquals(1111, context.getDataStoreProperties().getMaxDataChangeExecutorQueueSize());
assertEquals(2222, context.getDataStoreProperties().getMaxDataChangeListenerQueueSize());
assertEquals(4444, context.getDataStoreProperties().getMaxDataStoreExecutorQueueSize());
- assertEquals(true, context.isPersistent());
+ assertTrue(context.isPersistent());
updated = introspector.update(null);
updated = introspector.update(null);
- assertEquals("updated", false, updated);
+ assertFalse("updated", updated);
updated = introspector.update(new Hashtable<>());
updated = introspector.update(new Hashtable<>());
- assertEquals("updated", false, updated);
+ assertFalse("updated", updated);
properties.put("unknownProperty", "1"); // bad - invalid property name
final boolean updated = introspector.update(properties);
properties.put("unknownProperty", "1"); // bad - invalid property name
final boolean updated = introspector.update(properties);
- assertEquals("updated", true, updated);
+ assertTrue("updated", updated);
DatastoreContext context = introspector.getContext();
assertEquals(DEFAULT_SHARD_TRANSACTION_IDLE_TIMEOUT, context.getShardTransactionIdleTimeout());
DatastoreContext context = introspector.getContext();
assertEquals(DEFAULT_SHARD_TRANSACTION_IDLE_TIMEOUT, context.getShardTransactionIdleTimeout());
final DatastoreContextIntrospector operIntrospector = INTROSPECTOR_FACTORY.newInstance(OPERATIONAL);
boolean updated = operIntrospector.update(properties);
final DatastoreContextIntrospector operIntrospector = INTROSPECTOR_FACTORY.newInstance(OPERATIONAL);
boolean updated = operIntrospector.update(properties);
- assertEquals("updated", true, updated);
+ assertTrue("updated", updated);
DatastoreContext operContext = operIntrospector.getContext();
assertEquals(33, operContext.getShardTransactionIdleTimeout().toMinutes());
DatastoreContext operContext = operIntrospector.getContext();
assertEquals(33, operContext.getShardTransactionIdleTimeout().toMinutes());
- assertEquals(true, operContext.isPersistent());
+ assertTrue(operContext.isPersistent());
assertEquals(333, operContext.getDataStoreProperties().getMaxDataChangeExecutorPoolSize());
final DatastoreContextIntrospector configIntrospector = INTROSPECTOR_FACTORY.newInstance(CONFIGURATION);
updated = configIntrospector.update(properties);
assertEquals(333, operContext.getDataStoreProperties().getMaxDataChangeExecutorPoolSize());
final DatastoreContextIntrospector configIntrospector = INTROSPECTOR_FACTORY.newInstance(CONFIGURATION);
updated = configIntrospector.update(properties);
- assertEquals("updated", true, updated);
+ assertTrue("updated", updated);
DatastoreContext configContext = configIntrospector.getContext();
assertEquals(44, configContext.getShardTransactionIdleTimeout().toMinutes());
DatastoreContext configContext = configIntrospector.getContext();
assertEquals(44, configContext.getShardTransactionIdleTimeout().toMinutes());
- assertEquals(false, configContext.isPersistent());
+ assertFalse(configContext.isPersistent());
assertEquals(444, configContext.getDataStoreProperties().getMaxDataChangeExecutorPoolSize());
}
assertEquals(444, configContext.getDataStoreProperties().getMaxDataChangeExecutorPoolSize());
}
package org.opendaylight.controller.cluster.datastore;
import static org.junit.Assert.assertEquals;
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.junit.Assert.fail;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
@After
public void tearDown() {
@After
public void tearDown() {
- TestKit.shutdownActorSystem(system, Boolean.TRUE);
+ TestKit.shutdownActorSystem(system, true);
final DOMStoreReadTransaction readTx = dataStore.newReadOnlyTransaction();
Optional<NormalizedNode<?, ?>> optional = readTx.read(carPath).get(5, TimeUnit.SECONDS);
final DOMStoreReadTransaction readTx = dataStore.newReadOnlyTransaction();
Optional<NormalizedNode<?, ?>> optional = readTx.read(carPath).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", car, optional.get());
optional = readTx.read(personPath).get(5, TimeUnit.SECONDS);
assertEquals("Data node", car, optional.get());
optional = readTx.read(personPath).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", person, optional.get());
}
}
assertEquals("Data node", person, optional.get());
}
}
// 3. Read the data from Tx
final Boolean exists = readWriteTx.exists(nodePath).get(5, TimeUnit.SECONDS);
// 3. Read the data from Tx
final Boolean exists = readWriteTx.exists(nodePath).get(5, TimeUnit.SECONDS);
- assertEquals("exists", true, exists);
+ assertEquals("exists", Boolean.TRUE, exists);
Optional<NormalizedNode<?, ?>> optional = readWriteTx.read(nodePath).get(5, TimeUnit.SECONDS);
Optional<NormalizedNode<?, ?>> optional = readWriteTx.read(nodePath).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", nodeToWrite, optional.get());
// 4. Ready the Tx for commit
assertEquals("Data node", nodeToWrite, optional.get());
// 4. Ready the Tx for commit
final DOMStoreReadTransaction readTx = dataStore.newReadOnlyTransaction();
optional = readTx.read(nodePath).get(5, TimeUnit.SECONDS);
final DOMStoreReadTransaction readTx = dataStore.newReadOnlyTransaction();
optional = readTx.read(nodePath).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", nodeToWrite, optional.get());
}
}
assertEquals("Data node", nodeToWrite, optional.get());
}
}
readWriteTx.write(personPath, person);
final Boolean exists = readWriteTx.exists(carPath).get(5, TimeUnit.SECONDS);
readWriteTx.write(personPath, person);
final Boolean exists = readWriteTx.exists(carPath).get(5, TimeUnit.SECONDS);
- assertEquals("exists", true, exists);
+ assertEquals("exists", Boolean.TRUE, exists);
Optional<NormalizedNode<?, ?>> optional = readWriteTx.read(carPath).get(5, TimeUnit.SECONDS);
Optional<NormalizedNode<?, ?>> optional = readWriteTx.read(carPath).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", car, optional.get());
testKit.doCommit(readWriteTx.ready());
assertEquals("Data node", car, optional.get());
testKit.doCommit(readWriteTx.ready());
DOMStoreReadTransaction readTx = dataStore.newReadOnlyTransaction();
optional = readTx.read(carPath).get(5, TimeUnit.SECONDS);
DOMStoreReadTransaction readTx = dataStore.newReadOnlyTransaction();
optional = readTx.read(carPath).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", car, optional.get());
optional = readTx.read(personPath).get(5, TimeUnit.SECONDS);
assertEquals("Data node", car, optional.get());
optional = readTx.read(personPath).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", person, optional.get());
}
}
assertEquals("Data node", person, optional.get());
}
}
final Optional<NormalizedNode<?, ?>> optional = txChain.newReadOnlyTransaction()
.read(CarsModel.CAR_LIST_PATH).get(5, TimeUnit.SECONDS);
final Optional<NormalizedNode<?, ?>> optional = txChain.newReadOnlyTransaction()
.read(CarsModel.CAR_LIST_PATH).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("# cars", numCars, ((Collection<?>) optional.get().getValue()).size());
}
}
assertEquals("# cars", numCars, ((Collection<?>) optional.get().getValue()).size());
}
}
- assertEquals("Tx ready", true, done);
+ assertTrue("Tx ready", done);
// At this point the Tx operations should be waiting for the
// shard to initialize so
// At this point the Tx operations should be waiting for the
// shard to initialize so
final DOMStoreReadTransaction readTx = dataStore.newReadOnlyTransaction();
Optional<NormalizedNode<?, ?>> optional = readTx.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
final DOMStoreReadTransaction readTx = dataStore.newReadOnlyTransaction();
Optional<NormalizedNode<?, ?>> optional = readTx.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
optional = readTx.read(TestModel.OUTER_LIST_PATH).get(5, TimeUnit.SECONDS);
optional = readTx.read(TestModel.OUTER_LIST_PATH).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
optional = readTx.read(listEntryPath).get(5, TimeUnit.SECONDS);
optional = readTx.read(listEntryPath).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", false, optional.isPresent());
+ assertFalse("isPresent", optional.isPresent());
- assertEquals("Tx reads done", true, done);
+ assertTrue("Tx reads done", done);
// At this point the Tx operations should be waiting for the
// shard to initialize so
// At this point the Tx operations should be waiting for the
// shard to initialize so
blockRecoveryLatch.countDown();
// Wait for the reads to complete and verify.
blockRecoveryLatch.countDown();
// Wait for the reads to complete and verify.
- assertEquals("exists", true, txExistsFuture.get().get(5, TimeUnit.SECONDS));
- assertEquals("read", true, txReadFuture.get().get(5, TimeUnit.SECONDS).isPresent());
+ assertEquals("exists", Boolean.TRUE, txExistsFuture.get().get(5, TimeUnit.SECONDS));
+ assertTrue("read", txReadFuture.get().get(5, TimeUnit.SECONDS).isPresent());
- assertEquals("Tx ready", true, done);
+ assertTrue("Tx ready", done);
// Wait for the commit to complete. Since the shard never
// initialized, the Tx should
// Wait for the commit to complete. Since the shard never
// initialized, the Tx should
- assertEquals("Tx read done", true, done);
+ assertTrue("Tx read done", done);
// Wait for the read to complete. Since the shard never
// initialized, the Tx should
// Wait for the read to complete. Since the shard never
// initialized, the Tx should
- assertEquals("Tx ready", true, done);
+ assertTrue("Tx ready", done);
// Wait for the commit to complete. Since no shard
// leader was elected in time, the Tx
// Wait for the commit to complete. Since no shard
// leader was elected in time, the Tx
// Tx is visible after being readied.
DOMStoreReadTransaction readTx = txChain.newReadOnlyTransaction();
Optional<NormalizedNode<?, ?>> optional = readTx.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
// Tx is visible after being readied.
DOMStoreReadTransaction readTx = txChain.newReadOnlyTransaction();
Optional<NormalizedNode<?, ?>> optional = readTx.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", testNode, optional.get());
// 6. Create a new RW Tx from the chain, write more data,
assertEquals("Data node", testNode, optional.get());
// 6. Create a new RW Tx from the chain, write more data,
// verify it is visible.
readTx = txChain.newReadWriteTransaction();
optional = readTx.read(TestModel.OUTER_LIST_PATH).get(5, TimeUnit.SECONDS);
// verify it is visible.
readTx = txChain.newReadWriteTransaction();
optional = readTx.read(TestModel.OUTER_LIST_PATH).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", outerNode, optional.get());
// 8. Wait for the 2 commits to complete and close the
assertEquals("Data node", outerNode, optional.get());
// 8. Wait for the 2 commits to complete and close the
// committed data.
readTx = dataStore.newReadOnlyTransaction();
optional = readTx.read(TestModel.OUTER_LIST_PATH).get(5, TimeUnit.SECONDS);
// committed data.
readTx = dataStore.newReadOnlyTransaction();
optional = readTx.read(TestModel.OUTER_LIST_PATH).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", outerNode, optional.get());
}
}
assertEquals("Data node", outerNode, optional.get());
}
}
readWriteTx.merge(personPath, person);
Optional<NormalizedNode<?, ?>> optional = readWriteTx.read(carPath).get(5, TimeUnit.SECONDS);
readWriteTx.merge(personPath, person);
Optional<NormalizedNode<?, ?>> optional = readWriteTx.read(carPath).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", car, optional.get());
optional = readWriteTx.read(personPath).get(5, TimeUnit.SECONDS);
assertEquals("Data node", car, optional.get());
optional = readWriteTx.read(personPath).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", person, optional.get());
final DOMStoreThreePhaseCommitCohort cohort2 = readWriteTx.ready();
assertEquals("Data node", person, optional.get());
final DOMStoreThreePhaseCommitCohort cohort2 = readWriteTx.ready();
final DOMStoreReadTransaction readTx = dataStore.newReadOnlyTransaction();
optional = readTx.read(carPath).get(5, TimeUnit.SECONDS);
final DOMStoreReadTransaction readTx = dataStore.newReadOnlyTransaction();
optional = readTx.read(carPath).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", false, optional.isPresent());
+ assertFalse("isPresent", optional.isPresent());
optional = readTx.read(personPath).get(5, TimeUnit.SECONDS);
optional = readTx.read(personPath).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", person, optional.get());
}
}
assertEquals("Data node", person, optional.get());
}
}
final Optional<NormalizedNode<?, ?>> optional = txChain.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, CarsModel.CAR_LIST_PATH).get(5, TimeUnit.SECONDS);
final Optional<NormalizedNode<?, ?>> optional = txChain.newReadOnlyTransaction()
.read(LogicalDatastoreType.CONFIGURATION, CarsModel.CAR_LIST_PATH).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("# cars", numCars, ((Collection<?>) optional.get().getValue()).size());
txChain.close();
assertEquals("# cars", numCars, ((Collection<?>) optional.get().getValue()).size());
txChain.close();
final DOMStoreReadWriteTransaction rwTx2 = txChain.newReadWriteTransaction();
final DOMStoreReadWriteTransaction rwTx2 = txChain.newReadWriteTransaction();
- final Optional<NormalizedNode<?, ?>> optional = rwTx2.read(TestModel.TEST_PATH).get(
- 5, TimeUnit.SECONDS);
- assertEquals("isPresent", false, optional.isPresent());
+ final Optional<NormalizedNode<?, ?>> optional = rwTx2.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
+ assertFalse("isPresent", optional.isPresent());
// Ensure the reads succeed.
// Ensure the reads succeed.
- assertEquals("isPresent", true, readFuture1.get(5, TimeUnit.SECONDS).isPresent());
- assertEquals("isPresent", true, readFuture2.get(5, TimeUnit.SECONDS).isPresent());
+ assertTrue("isPresent", readFuture1.get(5, TimeUnit.SECONDS).isPresent());
+ assertTrue("isPresent", readFuture2.get(5, TimeUnit.SECONDS).isPresent());
// Ensure the writes succeed.
DOMStoreThreePhaseCommitCohort cohort2 = writeTx2.ready();
// Ensure the writes succeed.
DOMStoreThreePhaseCommitCohort cohort2 = writeTx2.ready();
testKit.doCommit(cohort1);
testKit.doCommit(cohort2);
testKit.doCommit(cohort1);
testKit.doCommit(cohort2);
- assertEquals("isPresent", true, txChain.newReadOnlyTransaction().read(TestModel.OUTER_LIST_PATH)
+ assertTrue("isPresent", txChain.newReadOnlyTransaction().read(TestModel.OUTER_LIST_PATH)
.get(5, TimeUnit.SECONDS).isPresent());
}
}
.get(5, TimeUnit.SECONDS).isPresent());
}
}
// two reads
Optional<NormalizedNode<?, ?>> optional = readTx.read(CarsModel.BASE_PATH).get(5, TimeUnit.SECONDS);
// two reads
Optional<NormalizedNode<?, ?>> optional = readTx.read(CarsModel.BASE_PATH).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", carsNode, optional.get());
optional = readTx.read(PeopleModel.BASE_PATH).get(5, TimeUnit.SECONDS);
assertEquals("Data node", carsNode, optional.get());
optional = readTx.read(PeopleModel.BASE_PATH).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", peopleNode, optional.get());
}
}
assertEquals("Data node", peopleNode, optional.get());
}
}
package org.opendaylight.controller.cluster.datastore;
import static org.junit.Assert.assertEquals;
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.junit.Assert.fail;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
private static void verifyCars(final DOMStoreReadTransaction readTx, final MapEntryNode... entries)
throws Exception {
final Optional<NormalizedNode<?, ?>> optional = readTx.read(CarsModel.CAR_LIST_PATH).get(5, TimeUnit.SECONDS);
private static void verifyCars(final DOMStoreReadTransaction readTx, final MapEntryNode... entries)
throws Exception {
final Optional<NormalizedNode<?, ?>> optional = readTx.read(CarsModel.CAR_LIST_PATH).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
final CollectionNodeBuilder<MapEntryNode, MapNode> listBuilder = ImmutableNodes.mapNodeBuilder(
CarsModel.CAR_QNAME);
final CollectionNodeBuilder<MapEntryNode, MapNode> listBuilder = ImmutableNodes.mapNodeBuilder(
CarsModel.CAR_QNAME);
private static void verifyNode(final DOMStoreReadTransaction readTx, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> expNode) throws Exception {
final Optional<NormalizedNode<?, ?>> optional = readTx.read(path).get(5, TimeUnit.SECONDS);
private static void verifyNode(final DOMStoreReadTransaction readTx, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> expNode) throws Exception {
final Optional<NormalizedNode<?, ?>> optional = readTx.read(path).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", expNode, optional.get());
}
private static void verifyExists(final DOMStoreReadTransaction readTx, final YangInstanceIdentifier path)
throws Exception {
final Boolean exists = readTx.exists(path).get(5, TimeUnit.SECONDS);
assertEquals("Data node", expNode, optional.get());
}
private static void verifyExists(final DOMStoreReadTransaction readTx, final YangInstanceIdentifier path)
throws Exception {
final Boolean exists = readTx.exists(path).get(5, TimeUnit.SECONDS);
- assertEquals("exists", true, exists);
+ assertEquals("exists", Boolean.TRUE, exists);
Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS);
}
Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS);
}
- TestKit.shutdownActorSystem(leaderSystem, Boolean.TRUE);
- TestKit.shutdownActorSystem(followerSystem, Boolean.TRUE);
+ TestKit.shutdownActorSystem(leaderSystem, true);
+ TestKit.shutdownActorSystem(followerSystem, true);
final ActorSystem newSystem = newActorSystem("reinstated-member2", "Member2");
final ActorSystem newSystem = newActorSystem("reinstated-member2", "Member2");
readWriteTx.merge(personPath, person);
Optional<NormalizedNode<?, ?>> optional = readWriteTx.read(carPath).get(5, TimeUnit.SECONDS);
readWriteTx.merge(personPath, person);
Optional<NormalizedNode<?, ?>> optional = readWriteTx.read(carPath).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", car, optional.get());
optional = readWriteTx.read(personPath).get(5, TimeUnit.SECONDS);
assertEquals("Data node", car, optional.get());
optional = readWriteTx.read(personPath).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", person, optional.get());
final DOMStoreThreePhaseCommitCohort cohort2 = readWriteTx.ready();
assertEquals("Data node", person, optional.get());
final DOMStoreThreePhaseCommitCohort cohort2 = readWriteTx.ready();
verifyCars(readTx, car);
optional = readTx.read(personPath).get(5, TimeUnit.SECONDS);
verifyCars(readTx, car);
optional = readTx.read(personPath).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", false, optional.isPresent());
+ assertFalse("isPresent", optional.isPresent());
final com.google.common.base.Optional<ActorRef> carsFollowerShard =
followerDistributedDataStore.getActorContext().findLocalShard("cars");
final com.google.common.base.Optional<ActorRef> carsFollowerShard =
followerDistributedDataStore.getActorContext().findLocalShard("cars");
- assertEquals("Cars follower shard found", true, carsFollowerShard.isPresent());
+ assertTrue("Cars follower shard found", carsFollowerShard.isPresent());
final DataTree dataTree = new InMemoryDataTreeFactory().create(
DataTreeConfiguration.DEFAULT_OPERATIONAL, SchemaContextHelper.full());
final DataTree dataTree = new InMemoryDataTreeFactory().create(
DataTreeConfiguration.DEFAULT_OPERATIONAL, SchemaContextHelper.full());
final com.google.common.base.Optional<ActorRef> carsFollowerShard =
followerDistributedDataStore.getActorContext().findLocalShard("cars");
final com.google.common.base.Optional<ActorRef> carsFollowerShard =
followerDistributedDataStore.getActorContext().findLocalShard("cars");
- assertEquals("Cars follower shard found", true, carsFollowerShard.isPresent());
+ assertTrue("Cars follower shard found", carsFollowerShard.isPresent());
carsFollowerShard.get().tell(GetShardDataTree.INSTANCE, followerTestKit.getRef());
final DataTree dataTree = followerTestKit.expectMsgClass(DataTree.class);
carsFollowerShard.get().tell(GetShardDataTree.INSTANCE, followerTestKit.getRef());
final DataTree dataTree = followerTestKit.expectMsgClass(DataTree.class);
final Optional<NormalizedNode<?, ?>> readOptional = leaderDistributedDataStore.newReadOnlyTransaction().read(
CarsModel.BASE_PATH).get(5, TimeUnit.SECONDS);
final Optional<NormalizedNode<?, ?>> readOptional = leaderDistributedDataStore.newReadOnlyTransaction().read(
CarsModel.BASE_PATH).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, readOptional.isPresent());
+ assertTrue("isPresent", readOptional.isPresent());
assertEquals("Node", carsNode, readOptional.get());
verifySnapshot(InMemorySnapshotStore.waitForSavedSnapshot(leaderCarShardName, Snapshot.class),
assertEquals("Node", carsNode, readOptional.get());
verifySnapshot(InMemorySnapshotStore.waitForSavedSnapshot(leaderCarShardName, Snapshot.class),
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import akka.actor.ActorRef;
import static org.junit.Assert.fail;
import akka.actor.ActorRef;
DOMStoreReadTransaction readTx = dataStore.newReadOnlyTransaction();
Optional<NormalizedNode<?, ?>> optional = readTx.read(nodePath).get(5, TimeUnit.SECONDS);
DOMStoreReadTransaction readTx = dataStore.newReadOnlyTransaction();
Optional<NormalizedNode<?, ?>> optional = readTx.read(nodePath).get(5, TimeUnit.SECONDS);
- assertEquals("isPresent", true, optional.isPresent());
+ assertTrue("isPresent", optional.isPresent());
assertEquals("Data node", nodeToWrite, optional.get());
}
public void doCommit(final DOMStoreThreePhaseCommitCohort cohort) throws Exception {
Boolean canCommit = cohort.canCommit().get(commitTimeout, TimeUnit.SECONDS);
assertEquals("Data node", nodeToWrite, optional.get());
}
public void doCommit(final DOMStoreThreePhaseCommitCohort cohort) throws Exception {
Boolean canCommit = cohort.canCommit().get(commitTimeout, TimeUnit.SECONDS);
- assertEquals("canCommit", true, canCommit);
+ assertEquals("canCommit", Boolean.TRUE, canCommit);
cohort.preCommit().get(5, TimeUnit.SECONDS);
cohort.commit().get(5, TimeUnit.SECONDS);
}
cohort.preCommit().get(5, TimeUnit.SECONDS);
cohort.commit().get(5, TimeUnit.SECONDS);
}
void doCommit(final ListenableFuture<Boolean> canCommitFuture, final DOMStoreThreePhaseCommitCohort cohort)
throws Exception {
Boolean canCommit = canCommitFuture.get(commitTimeout, TimeUnit.SECONDS);
void doCommit(final ListenableFuture<Boolean> canCommitFuture, final DOMStoreThreePhaseCommitCohort cohort)
throws Exception {
Boolean canCommit = canCommitFuture.get(commitTimeout, TimeUnit.SECONDS);
- assertEquals("canCommit", true, canCommit);
+ assertEquals("canCommit", Boolean.TRUE, canCommit);
cohort.preCommit().get(5, TimeUnit.SECONDS);
cohort.commit().get(5, TimeUnit.SECONDS);
}
cohort.preCommit().get(5, TimeUnit.SECONDS);
cohort.commit().get(5, TimeUnit.SECONDS);
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyBoolean;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyBoolean;
final DataTreeSnapshot snapshot =
shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
Optional<NormalizedNode<?, ?>> optional = snapshot.readNode(carPath);
final DataTreeSnapshot snapshot =
shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
Optional<NormalizedNode<?, ?>> optional = snapshot.readNode(carPath);
- assertEquals("Car node present", true, optional.isPresent());
+ assertTrue("Car node present", optional.isPresent());
assertEquals("Car node", carNode, optional.get());
optional = snapshot.readNode(PeopleModel.BASE_PATH);
assertEquals("Car node", carNode, optional.get());
optional = snapshot.readNode(PeopleModel.BASE_PATH);
- assertEquals("People node present", true, optional.isPresent());
+ assertTrue("People node present", optional.isPresent());
assertEquals("People node", peopleNode, optional.get());
}
assertEquals("People node", peopleNode, optional.get());
}
final DataTreeSnapshot snapshot =
shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
Optional<NormalizedNode<?, ?>> optional = snapshot.readNode(carPath);
final DataTreeSnapshot snapshot =
shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
Optional<NormalizedNode<?, ?>> optional = snapshot.readNode(carPath);
- assertEquals("Car node present", true, optional.isPresent());
+ assertTrue("Car node present", optional.isPresent());
assertEquals("Car node", carNode, optional.get());
}
assertEquals("Car node", carNode, optional.get());
}
inOrder.verify(commitCallback2).onSuccess(any(UnsignedLong.class));
inOrder.verify(commitCallback3).onSuccess(any(UnsignedLong.class));
inOrder.verify(commitCallback2).onSuccess(any(UnsignedLong.class));
inOrder.verify(commitCallback3).onSuccess(any(UnsignedLong.class));
- final DataTreeSnapshot snapshot =
- shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
+ final DataTreeSnapshot snapshot = shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
Optional<NormalizedNode<?, ?>> optional = snapshot.readNode(CarsModel.BASE_PATH);
Optional<NormalizedNode<?, ?>> optional = snapshot.readNode(CarsModel.BASE_PATH);
- assertEquals("Car node present", true, optional.isPresent());
+ assertTrue("Car node present", optional.isPresent());
}
@SuppressWarnings("unchecked")
}
@SuppressWarnings("unchecked")
final DataTreeSnapshot snapshot =
shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
Optional<NormalizedNode<?, ?>> optional = snapshot.readNode(carPath);
final DataTreeSnapshot snapshot =
shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
Optional<NormalizedNode<?, ?>> optional = snapshot.readNode(carPath);
- assertEquals("Car node present", true, optional.isPresent());
+ assertTrue("Car node present", optional.isPresent());
assertEquals("Car node", carNode, optional.get());
}
assertEquals("Car node", carNode, optional.get());
}
final DataTreeSnapshot snapshot =
shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
Optional<NormalizedNode<?, ?>> optional = snapshot.readNode(PeopleModel.BASE_PATH);
final DataTreeSnapshot snapshot =
shardDataTree.newReadOnlyTransaction(nextTransactionId()).getSnapshot();
Optional<NormalizedNode<?, ?>> optional = snapshot.readNode(PeopleModel.BASE_PATH);
- assertEquals("People node present", true, optional.isPresent());
+ assertTrue("People node present", optional.isPresent());
assertEquals("People node", peopleNode, optional.get());
}
assertEquals("People node", peopleNode, optional.get());
}
final Optional<NormalizedNode<?, ?>> optional = snapshot1.readNode(CarsModel.BASE_PATH);
final Optional<NormalizedNode<?, ?>> optional = snapshot1.readNode(CarsModel.BASE_PATH);
- assertEquals(true, optional.isPresent());
+ assertTrue(optional.isPresent());
"testDataTreeChangeListenerNotifiedWhenNotTheLeaderOnRegistration");
final ShardTestKit testKit = new ShardTestKit(getSystem());
"testDataTreeChangeListenerNotifiedWhenNotTheLeaderOnRegistration");
final ShardTestKit testKit = new ShardTestKit(getSystem());
- assertEquals("Got first ElectionTimeout", true, onFirstElectionTimeout.await(5, TimeUnit.SECONDS));
+ assertTrue("Got first ElectionTimeout", onFirstElectionTimeout.await(5, TimeUnit.SECONDS));
shard.tell(new RegisterDataTreeChangeListener(path, dclActor, false), testKit.getRef());
final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"),
shard.tell(new RegisterDataTreeChangeListener(path, dclActor, false), testKit.getRef());
final RegisterDataTreeNotificationListenerReply reply = testKit.expectMsgClass(testKit.duration("5 seconds"),
@Override
void onSuccess(final Object resp) {
@Override
void onSuccess(final Object resp) {
- final CanCommitTransactionReply canCommitReply =
- CanCommitTransactionReply.fromSerializable(resp);
- assertEquals("Can commit", true, canCommitReply.getCanCommit());
+ final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply.fromSerializable(resp);
+ assertTrue("Can commit", canCommitReply.getCanCommit());
final Future<Object> commitFuture = Patterns.ask(shard,
new CommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), timeout);
final Future<Object> commitFuture = Patterns.ask(shard,
new CommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), timeout);
shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), testKit.getRef());
final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), testKit.getRef());
final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
- assertEquals("Can commit", true, canCommitReply.getCanCommit());
+ assertTrue("Can commit", canCommitReply.getCanCommit());
throw new RuntimeException(t);
}
throw new RuntimeException(t);
}
- assertEquals("Commits complete", true, done);
+ assertTrue("Commits complete", done);
// final InOrder inOrder = inOrder(cohort1.getCanCommit(), cohort1.getPreCommit(), cohort1.getCommit(),
// cohort2.getCanCommit(), cohort2.getPreCommit(), cohort2.getCommit(), cohort3.getCanCommit(),
// final InOrder inOrder = inOrder(cohort1.getCanCommit(), cohort1.getPreCommit(), cohort1.getCommit(),
// cohort2.getCanCommit(), cohort2.getPreCommit(), cohort2.getCommit(), cohort3.getCanCommit(),
shard.tell(new CanCommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), testKit.getRef());
final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
shard.tell(new CanCommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), testKit.getRef());
final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
- assertEquals("Can commit", true, canCommitReply.getCanCommit());
+ assertTrue("Can commit", canCommitReply.getCanCommit());
// Send the CommitTransaction message.
// Send the CommitTransaction message.
shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), testKit.getRef());
final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), testKit.getRef());
final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
- assertEquals("Can commit", true, canCommitReply.getCanCommit());
+ assertTrue("Can commit", canCommitReply.getCanCommit());
shard.tell(new CommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), testKit.getRef());
testKit.expectMsgClass(duration, CommitTransactionReply.class);
shard.tell(new CommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), testKit.getRef());
testKit.expectMsgClass(duration, CommitTransactionReply.class);
shard.tell(new CanCommitTransaction(txId, CURRENT_VERSION).toSerializable(), testKit.getRef());
final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(CanCommitTransactionReply.class));
shard.tell(new CanCommitTransaction(txId, CURRENT_VERSION).toSerializable(), testKit.getRef());
final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(CanCommitTransactionReply.class));
- assertEquals("Can commit", true, canCommitReply.getCanCommit());
+ assertTrue("Can commit", canCommitReply.getCanCommit());
// Send the CanCommitTransaction message.
// Send the CanCommitTransaction message.
shard.tell(new CanCommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), testKit.getRef());
final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
shard.tell(new CanCommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), testKit.getRef());
final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
- assertEquals("Can commit", true, canCommitReply.getCanCommit());
+ assertTrue("Can commit", canCommitReply.getCanCommit());
// Send the CanCommitTransaction message.
// Send the CanCommitTransaction message.
shard.tell(new CanCommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), testKit.getRef());
final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
shard.tell(new CanCommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), testKit.getRef());
final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
- assertEquals("Can commit", true, canCommitReply.getCanCommit());
+ assertTrue("Can commit", canCommitReply.getCanCommit());
shard.tell(new CommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), testKit.getRef());
testKit.expectMsgClass(duration, CommitTransactionReply.class);
shard.tell(new CommitTransaction(transactionID, CURRENT_VERSION).toSerializable(), testKit.getRef());
testKit.expectMsgClass(duration, CommitTransactionReply.class);
shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), testKit.getRef());
final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), testKit.getRef());
final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
- assertEquals("Can commit", true, canCommitReply.getCanCommit());
+ assertTrue("Can commit", canCommitReply.getCanCommit());
// Send the CanCommitTransaction message for the 2nd Tx. This
// should get queued and
// Send the CanCommitTransaction message for the 2nd Tx. This
// should get queued and
}
}, getSystem().dispatcher());
}
}, getSystem().dispatcher());
- assertEquals("2nd CanCommit complete", true, latch.await(5, TimeUnit.SECONDS));
+ assertTrue("2nd CanCommit complete", latch.await(5, TimeUnit.SECONDS));
final InOrder inOrder = inOrder(dataTree);
inOrder.verify(dataTree).validate(any(DataTreeModification.class));
final InOrder inOrder = inOrder(dataTree);
inOrder.verify(dataTree).validate(any(DataTreeModification.class));
shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), testKit.getRef());
final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), testKit.getRef());
final CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
- assertEquals("Can commit", true, canCommitReply.getCanCommit());
+ assertTrue("Can commit", canCommitReply.getCanCommit());
// Send the CanCommitTransaction message for the 2nd Tx. This
// should get queued and
// Send the CanCommitTransaction message for the 2nd Tx. This
// should get queued and
}
}, getSystem().dispatcher());
}
}, getSystem().dispatcher());
- assertEquals("2nd CanCommit complete", true, latch.await(5, TimeUnit.SECONDS));
+ assertTrue("2nd CanCommit complete", latch.await(5, TimeUnit.SECONDS));
final InOrder inOrder = inOrder(dataTree);
inOrder.verify(dataTree).validate(any(DataTreeModification.class));
final InOrder inOrder = inOrder(dataTree);
inOrder.verify(dataTree).validate(any(DataTreeModification.class));
shard.tell(new CanCommitTransaction(transactionID2, CURRENT_VERSION).toSerializable(), testKit.getRef());
final CanCommitTransactionReply reply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(CanCommitTransactionReply.class));
shard.tell(new CanCommitTransaction(transactionID2, CURRENT_VERSION).toSerializable(), testKit.getRef());
final CanCommitTransactionReply reply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(CanCommitTransactionReply.class));
- assertEquals("getCanCommit", true, reply.getCanCommit());
+ assertTrue("getCanCommit", reply.getCanCommit());
shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), testKit.getRef());
CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), testKit.getRef());
CanCommitTransactionReply canCommitReply = CanCommitTransactionReply
.fromSerializable(testKit.expectMsgClass(duration, CanCommitTransactionReply.class));
- assertEquals("Can commit", true, canCommitReply.getCanCommit());
+ assertTrue("Can commit", canCommitReply.getCanCommit());
// Send the CanCommitTransaction message for the 2nd Tx. This
// should get queued and
// Send the CanCommitTransaction message for the 2nd Tx. This
// should get queued and
// Wait for the 2nd Tx to complete the canCommit phase.
canCommitReply = (CanCommitTransactionReply) Await.result(canCommitFuture, duration);
// Wait for the 2nd Tx to complete the canCommit phase.
canCommitReply = (CanCommitTransactionReply) Await.result(canCommitFuture, duration);
- assertEquals("Can commit", true, canCommitReply.getCanCommit());
+ assertTrue("Can commit", canCommitReply.getCanCommit());
private static void awaitAndValidateSnapshot(final AtomicReference<CountDownLatch> latch,
final AtomicReference<Object> savedSnapshot, final NormalizedNode<?, ?> expectedRoot)
throws InterruptedException {
private static void awaitAndValidateSnapshot(final AtomicReference<CountDownLatch> latch,
final AtomicReference<Object> savedSnapshot, final NormalizedNode<?, ?> expectedRoot)
throws InterruptedException {
- assertEquals("Snapshot saved", true, latch.get().await(5, TimeUnit.SECONDS));
+ assertTrue("Snapshot saved", latch.get().await(5, TimeUnit.SECONDS));
assertTrue("Invalid saved snapshot " + savedSnapshot.get(), savedSnapshot.get() instanceof Snapshot);
assertTrue("Invalid saved snapshot " + savedSnapshot.get(), savedSnapshot.get() instanceof Snapshot);
final TestActorRef<Shard> shard = actorFactory.createTestActor(newShardProps(), "testOnDatastoreContext");
final TestActorRef<Shard> shard = actorFactory.createTestActor(newShardProps(), "testOnDatastoreContext");
- assertEquals("isRecoveryApplicable", true, shard.underlyingActor().persistence().isRecoveryApplicable());
+ assertTrue("isRecoveryApplicable", shard.underlyingActor().persistence().isRecoveryApplicable());
ShardTestKit.waitUntilLeader(shard);
shard.tell(dataStoreContextBuilder.persistent(false).build(), ActorRef.noSender());
ShardTestKit.waitUntilLeader(shard);
shard.tell(dataStoreContextBuilder.persistent(false).build(), ActorRef.noSender());
- assertEquals("isRecoveryApplicable", false, shard.underlyingActor().persistence().isRecoveryApplicable());
+ assertFalse("isRecoveryApplicable", shard.underlyingActor().persistence().isRecoveryApplicable());
shard.tell(dataStoreContextBuilder.persistent(true).build(), ActorRef.noSender());
shard.tell(dataStoreContextBuilder.persistent(true).build(), ActorRef.noSender());
- assertEquals("isRecoveryApplicable", true, shard.underlyingActor().persistence().isRecoveryApplicable());
+ assertTrue("isRecoveryApplicable", shard.underlyingActor().persistence().isRecoveryApplicable());
ShardLeaderStateChanged leaderStateChanged = MessageCollectorActor.expectFirstMatching(listener,
ShardLeaderStateChanged.class);
ShardLeaderStateChanged leaderStateChanged = MessageCollectorActor.expectFirstMatching(listener,
ShardLeaderStateChanged.class);
- assertEquals("getLocalShardDataTree present", true,
- leaderStateChanged.getLocalShardDataTree().isPresent());
+ assertTrue("getLocalShardDataTree present", leaderStateChanged.getLocalShardDataTree().isPresent());
assertSame("getLocalShardDataTree", shard.underlyingActor().getDataStore().getDataTree(),
leaderStateChanged.getLocalShardDataTree().get());
assertSame("getLocalShardDataTree", shard.underlyingActor().getDataStore().getDataTree(),
leaderStateChanged.getLocalShardDataTree().get());
shard.tell(new RequestVote(10000, "member2", 50, 50), testKit.getRef());
shard.tell(new RequestVote(10000, "member2", 50, 50), testKit.getRef());
- leaderStateChanged = MessageCollectorActor.expectFirstMatching(listener,
- ShardLeaderStateChanged.class);
- assertEquals("getLocalShardDataTree present", false, leaderStateChanged.getLocalShardDataTree().isPresent());
+ leaderStateChanged = MessageCollectorActor.expectFirstMatching(listener, ShardLeaderStateChanged.class);
+ assertFalse("getLocalShardDataTree present", leaderStateChanged.getLocalShardDataTree().isPresent());
shard.underlyingActor().handleNonRaftCommand(new FollowerInitialSyncUpStatus(false,
"member-1-shard-inventory-operational"));
shard.underlyingActor().handleNonRaftCommand(new FollowerInitialSyncUpStatus(false,
"member-1-shard-inventory-operational"));
- assertEquals(false, shard.underlyingActor().getShardMBean().getFollowerInitialSyncStatus());
+ assertFalse(shard.underlyingActor().getShardMBean().getFollowerInitialSyncStatus());
shard.underlyingActor().handleNonRaftCommand(new FollowerInitialSyncUpStatus(true,
"member-1-shard-inventory-operational"));
shard.underlyingActor().handleNonRaftCommand(new FollowerInitialSyncUpStatus(true,
"member-1-shard-inventory-operational"));
- assertEquals(true, shard.underlyingActor().getShardMBean().getFollowerInitialSyncStatus());
+ assertTrue(shard.underlyingActor().getShardMBean().getFollowerInitialSyncStatus());
package org.opendaylight.controller.cluster.datastore;
package org.opendaylight.controller.cluster.datastore;
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
- assertEquals("Tx 2 write should've completed", true, write2Complete.await(5, TimeUnit.SECONDS));
+ assertTrue("Tx 2 write should've completed", write2Complete.await(5, TimeUnit.SECONDS));
if (caughtEx.get() != null) {
throw caughtEx.get();
if (caughtEx.get() != null) {
throw caughtEx.get();
- assertEquals("Tx 2 write should've completed", true, write2Complete.await(5, TimeUnit.SECONDS));
+ assertTrue("Tx 2 write should've completed", write2Complete.await(5, TimeUnit.SECONDS));
if (caughtEx.get() != null) {
throw caughtEx.get();
if (caughtEx.get() != null) {
throw caughtEx.get();
package org.opendaylight.controller.cluster.datastore;
import static org.junit.Assert.assertEquals;
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.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
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);
readOptional = transactionProxy.read(TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
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());
}
assertEquals("Response NormalizedNode", expectedNode, readOptional.get());
}
Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(
TestModel.TEST_PATH).get(5, TimeUnit.SECONDS);
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);
assertEquals("Response NormalizedNode", expectedNode, readOptional.get());
InOrder inOrder = Mockito.inOrder(mockActorContext);
Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).get();
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();
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)
}
@Test(expected = PrimaryNotFoundException.class)
Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).get();
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(
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));
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", 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", 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());
}
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));
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());
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);
assertEquals("Response NormalizedNode", writeNode2, readOptional.get());
transactionProxy.merge(mergePath1, mergeNode1);
transactionProxy.delete(deletePath);
Boolean exists = transactionProxy.exists(TestModel.TEST_PATH).get();
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);
assertEquals("Response NormalizedNode", mergeNode2, readOptional.get());
List<BatchedModifications> batchedModifications = captureBatchedModifications(actorRef);
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();
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import akka.actor.ActorRef;
import akka.testkit.javadsl.TestKit;
import akka.actor.ActorRef;
import akka.testkit.javadsl.TestKit;
assertEquals("Deserialized snapshot type", snapshot.getClass(), deserialized.getClass());
final Optional<NormalizedNode<?, ?>> maybeNode = deserialized.getRootNode();
assertEquals("Deserialized snapshot type", snapshot.getClass(), deserialized.getClass());
final Optional<NormalizedNode<?, ?>> maybeNode = deserialized.getRootNode();
- assertEquals("isPresent", true, maybeNode.isPresent());
+ assertTrue("isPresent", maybeNode.isPresent());
assertEquals("Root node", expectedRoot, maybeNode.get());
}
}
assertEquals("Root node", expectedRoot, maybeNode.get());
}
}
Future<Object> future = Patterns.ask(leaderDistributedDataStore.getActorContext().getShardManager(),
new ChangeShardMembersVotingStatus(ENTITY_OWNERSHIP_SHARD_NAME,
Future<Object> future = Patterns.ask(leaderDistributedDataStore.getActorContext().getShardManager(),
new ChangeShardMembersVotingStatus(ENTITY_OWNERSHIP_SHARD_NAME,
- ImmutableMap.of("member-4", false, "member-5", false)), new Timeout(10, TimeUnit.SECONDS));
+ ImmutableMap.of("member-4", Boolean.FALSE, "member-5", Boolean.FALSE)),
+ new Timeout(10, TimeUnit.SECONDS));
Object response = Await.result(future, FiniteDuration.apply(10, TimeUnit.SECONDS));
if (response instanceof Throwable) {
throw new AssertionError("ChangeShardMembersVotingStatus failed", (Throwable)response);
Object response = Await.result(future, FiniteDuration.apply(10, TimeUnit.SECONDS));
if (response instanceof Throwable) {
throw new AssertionError("ChangeShardMembersVotingStatus failed", (Throwable)response);
future = Patterns.ask(leaderDistributedDataStore.getActorContext().getShardManager(),
new ChangeShardMembersVotingStatus(ENTITY_OWNERSHIP_SHARD_NAME,
future = Patterns.ask(leaderDistributedDataStore.getActorContext().getShardManager(),
new ChangeShardMembersVotingStatus(ENTITY_OWNERSHIP_SHARD_NAME,
- ImmutableMap.of("member-3", false, "member-4", true, "member-5", true)),
+ ImmutableMap.of("member-3", Boolean.FALSE, "member-4", Boolean.TRUE, "member-5", Boolean.TRUE)),
new Timeout(10, TimeUnit.SECONDS));
response = Await.result(future, FiniteDuration.apply(10, TimeUnit.SECONDS));
if (response instanceof Throwable) {
new Timeout(10, TimeUnit.SECONDS));
response = Await.result(future, FiniteDuration.apply(10, TimeUnit.SECONDS));
if (response instanceof Throwable) {
.read(entityPath(entity.getType(), entity.getIdentifier()).node(Candidate.QNAME))
.get(5, TimeUnit.SECONDS);
try {
.read(entityPath(entity.getType(), entity.getIdentifier()).node(Candidate.QNAME))
.get(5, TimeUnit.SECONDS);
try {
- assertEquals("Candidates not found for " + entity, true, possible.isPresent());
+ assertTrue("Candidates not found for " + entity, possible.isPresent());
Collection<String> actual = new ArrayList<>();
for (MapEntryNode candidate: ((MapNode)possible.get()).getValue()) {
actual.add(candidate.getChild(CANDIDATE_NAME_NODE_ID).get().getValue().toString());
Collection<String> actual = new ArrayList<>();
for (MapEntryNode candidate: ((MapNode)possible.get()).getValue()) {
actual.add(candidate.getChild(CANDIDATE_NAME_NODE_ID).get().getValue().toString());
DOMEntity entity2 = new DOMEntity(ENTITY_TYPE, "two");
Optional<EntityOwnershipState> state = service.getOwnershipState(entity2);
DOMEntity entity2 = new DOMEntity(ENTITY_TYPE, "two");
Optional<EntityOwnershipState> state = service.getOwnershipState(entity2);
- assertEquals("getOwnershipState present", false, state.isPresent());
+ assertFalse("getOwnershipState present", state.isPresent());
writeNode(ENTITY_OWNERS_PATH, entityOwnersWithCandidate(ENTITY_TYPE, entity2.getIdentifier(), "member-1"),
shardDataTree);
writeNode(ENTITY_OWNERS_PATH, entityOwnersWithCandidate(ENTITY_TYPE, entity2.getIdentifier(), "member-1"),
shardDataTree);
deleteNode(candidatePath(entityPath(entity2.getType(), entity2.getIdentifier()), "member-1"), shardDataTree);
Optional<EntityOwnershipState> state2 = service.getOwnershipState(entity2);
deleteNode(candidatePath(entityPath(entity2.getType(), entity2.getIdentifier()), "member-1"), shardDataTree);
Optional<EntityOwnershipState> state2 = service.getOwnershipState(entity2);
- assertEquals("getOwnershipState present", false, state2.isPresent());
+ assertFalse("getOwnershipState present", state2.isPresent());
private static void verifyGetOwnershipState(final DistributedEntityOwnershipService service, final DOMEntity entity,
final EntityOwnershipState expState) {
Optional<EntityOwnershipState> state = service.getOwnershipState(entity);
private static void verifyGetOwnershipState(final DistributedEntityOwnershipService service, final DOMEntity entity,
final EntityOwnershipState expState) {
Optional<EntityOwnershipState> state = service.getOwnershipState(entity);
- assertEquals("getOwnershipState present", true, state.isPresent());
+ assertTrue("getOwnershipState present", state.isPresent());
assertEquals("EntityOwnershipState", expState, state.get());
}
assertEquals("EntityOwnershipState", expState, state.get());
}
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
@Test
public void testIsSerializedType() {
@Test
public void testIsSerializedType() {
- assertEquals("isSerializedType", true, AbortTransactionReply.isSerializedType(new AbortTransactionReply()));
- assertEquals("isSerializedType", false, AbortTransactionReply.isSerializedType(new Object()));
+ assertTrue("isSerializedType", AbortTransactionReply.isSerializedType(new AbortTransactionReply()));
+ assertFalse("isSerializedType", AbortTransactionReply.isSerializedType(new Object()));
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
@Test
public void testIsSerializedType() {
@Test
public void testIsSerializedType() {
- assertEquals("isSerializedType", true, AbortTransaction.isSerializedType(new AbortTransaction()));
- assertEquals("isSerializedType", false, AbortTransaction.isSerializedType(new Object()));
+ assertTrue("isSerializedType", AbortTransaction.isSerializedType(new AbortTransaction()));
+ assertFalse("isSerializedType", AbortTransaction.isSerializedType(new Object()));
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import com.google.common.collect.ImmutableSortedSet;
import java.io.Serializable;
import com.google.common.collect.ImmutableSortedSet;
import java.io.Serializable;
batched.addModification(new WriteModification(writePath, writeData));
batched.addModification(new MergeModification(mergePath, mergeData));
batched.addModification(new DeleteModification(deletePath));
batched.addModification(new WriteModification(writePath, writeData));
batched.addModification(new MergeModification(mergePath, mergeData));
batched.addModification(new DeleteModification(deletePath));
- assertEquals("isReady", false, batched.isReady());
+ assertFalse("isReady", batched.isReady());
- assertEquals("isReady", true, batched.isReady());
+ assertTrue("isReady", batched.isReady());
batched.setTotalMessagesSent(5);
BatchedModifications clone = (BatchedModifications) SerializationUtils.clone(
batched.setTotalMessagesSent(5);
BatchedModifications clone = (BatchedModifications) SerializationUtils.clone(
assertEquals("getVersion", DataStoreVersions.CURRENT_VERSION, clone.getVersion());
assertEquals("getTransactionID", tx1, clone.getTransactionId());
assertEquals("getVersion", DataStoreVersions.CURRENT_VERSION, clone.getVersion());
assertEquals("getTransactionID", tx1, clone.getTransactionId());
- assertEquals("isReady", true, clone.isReady());
- assertEquals("isDoCommitOnReady", false, clone.isDoCommitOnReady());
- assertEquals("participatingShardNames present", false, clone.getParticipatingShardNames().isPresent());
+ assertTrue("isReady", clone.isReady());
+ assertFalse("isDoCommitOnReady", clone.isDoCommitOnReady());
+ assertFalse("participatingShardNames present", clone.getParticipatingShardNames().isPresent());
assertEquals("getTotalMessagesSent", 5, clone.getTotalMessagesSent());
assertEquals("getModifications size", 3, clone.getModifications().size());
assertEquals("getTotalMessagesSent", 5, clone.getTotalMessagesSent());
assertEquals("getModifications size", 3, clone.getModifications().size());
final SortedSet<String> shardNames = ImmutableSortedSet.of("one", "two");
batched.setReady(Optional.of(shardNames));
batched.setDoCommitOnReady(true);
final SortedSet<String> shardNames = ImmutableSortedSet.of("one", "two");
batched.setReady(Optional.of(shardNames));
batched.setDoCommitOnReady(true);
- assertEquals("isReady", true, batched.isReady());
+ assertTrue("isReady", batched.isReady());
clone = (BatchedModifications) SerializationUtils.clone((Serializable) batched.toSerializable());
assertEquals("getVersion", DataStoreVersions.CURRENT_VERSION, clone.getVersion());
assertEquals("getTransactionID", tx2, clone.getTransactionId());
clone = (BatchedModifications) SerializationUtils.clone((Serializable) batched.toSerializable());
assertEquals("getVersion", DataStoreVersions.CURRENT_VERSION, clone.getVersion());
assertEquals("getTransactionID", tx2, clone.getTransactionId());
- assertEquals("isReady", true, clone.isReady());
- assertEquals("isDoCommitOnReady", true, clone.isDoCommitOnReady());
- assertEquals("participatingShardNames present", true, clone.getParticipatingShardNames().isPresent());
+ assertTrue("isReady", clone.isReady());
+ assertTrue("isDoCommitOnReady", clone.isDoCommitOnReady());
+ assertTrue("participatingShardNames present", clone.getParticipatingShardNames().isPresent());
assertEquals("participatingShardNames", shardNames, clone.getParticipatingShardNames().get());
assertEquals("getModifications size", 0, clone.getModifications().size());
assertEquals("participatingShardNames", shardNames, clone.getParticipatingShardNames().get());
assertEquals("getModifications size", 0, clone.getModifications().size());
assertEquals("getVersion", DataStoreVersions.CURRENT_VERSION, clone.getVersion());
assertEquals("getTransactionID", tx2, clone.getTransactionId());
assertEquals("getVersion", DataStoreVersions.CURRENT_VERSION, clone.getVersion());
assertEquals("getTransactionID", tx2, clone.getTransactionId());
- assertEquals("isReady", false, clone.isReady());
+ assertFalse("isReady", clone.isReady());
assertEquals("getModifications size", 0, clone.getModifications().size());
// Test pre-Flourine
assertEquals("getModifications size", 0, clone.getModifications().size());
// Test pre-Flourine
assertEquals("getVersion", DataStoreVersions.BORON_VERSION, clone.getVersion());
assertEquals("getTransactionID", tx2, clone.getTransactionId());
assertEquals("getVersion", DataStoreVersions.BORON_VERSION, clone.getVersion());
assertEquals("getTransactionID", tx2, clone.getTransactionId());
- assertEquals("isReady", true, clone.isReady());
- assertEquals("participatingShardNames present", false, clone.getParticipatingShardNames().isPresent());
+ assertTrue("isReady", clone.isReady());
+ assertFalse("participatingShardNames present", clone.getParticipatingShardNames().isPresent());
assertEquals("getModifications size", 1, clone.getModifications().size());
}
assertEquals("getModifications size", 1, clone.getModifications().size());
}
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
@Test
public void testIsSerializedType() {
@Test
public void testIsSerializedType() {
- assertEquals("isSerializedType", true, CanCommitTransactionReply.isSerializedType(
- new CanCommitTransactionReply()));
- assertEquals("isSerializedType", false, CanCommitTransactionReply.isSerializedType(new Object()));
+ assertTrue("isSerializedType", CanCommitTransactionReply.isSerializedType(new CanCommitTransactionReply()));
+ assertFalse("isSerializedType", CanCommitTransactionReply.isSerializedType(new Object()));
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
@Test
public void testIsSerializedType() {
@Test
public void testIsSerializedType() {
- assertEquals("isSerializedType", true, CanCommitTransaction.isSerializedType(new CanCommitTransaction()));
- assertEquals("isSerializedType", false, CanCommitTransaction.isSerializedType(new Object()));
+ assertTrue("isSerializedType", CanCommitTransaction.isSerializedType(new CanCommitTransaction()));
+ assertFalse("isSerializedType", CanCommitTransaction.isSerializedType(new Object()));
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
@Test
public void testIsSerializedType() {
@Test
public void testIsSerializedType() {
- assertEquals("isSerializedType", true, CloseTransactionChain.isSerializedType(new CloseTransactionChain()));
- assertEquals("isSerializedType", false, CloseTransactionChain.isSerializedType(new Object()));
+ assertTrue("isSerializedType", CloseTransactionChain.isSerializedType(new CloseTransactionChain()));
+ assertFalse("isSerializedType", CloseTransactionChain.isSerializedType(new Object()));
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
@Test
public void testIsSerializedType() {
@Test
public void testIsSerializedType() {
- assertEquals("isSerializedType", true, CommitTransactionReply.isSerializedType(new CommitTransactionReply()));
- assertEquals("isSerializedType", false, CommitTransactionReply.isSerializedType(new Object()));
+ assertTrue("isSerializedType", CommitTransactionReply.isSerializedType(new CommitTransactionReply()));
+ assertFalse("isSerializedType", CommitTransactionReply.isSerializedType(new Object()));
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
@Test
public void testIsSerializedType() {
@Test
public void testIsSerializedType() {
- assertEquals("isSerializedType", true, CommitTransaction.isSerializedType(new CommitTransaction()));
- assertEquals("isSerializedType", false, CommitTransaction.isSerializedType(new Object()));
+ assertTrue("isSerializedType", CommitTransaction.isSerializedType(new CommitTransaction()));
+ assertFalse("isSerializedType", CommitTransaction.isSerializedType(new Object()));
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
@Test
public void testIsSerializedType() {
@Test
public void testIsSerializedType() {
- assertEquals("isSerializedType", true, CreateTransactionReply.isSerializedType(new CreateTransactionReply()));
- assertEquals("isSerializedType", false, CreateTransactionReply.isSerializedType(new Object()));
+ assertTrue("isSerializedType", CreateTransactionReply.isSerializedType(new CreateTransactionReply()));
+ assertFalse("isSerializedType", CreateTransactionReply.isSerializedType(new Object()));
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
@Test
public void testIsSerializedType() {
@Test
public void testIsSerializedType() {
- assertEquals("isSerializedType", true, CreateTransaction.isSerializedType(new CreateTransaction()));
- assertEquals("isSerializedType", false, CreateTransaction.isSerializedType(new Object()));
+ assertTrue("isSerializedType", CreateTransaction.isSerializedType(new CreateTransaction()));
+ assertFalse("isSerializedType", CreateTransaction.isSerializedType(new Object()));
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
@Test
public void testIsSerializedType() {
@Test
public void testIsSerializedType() {
- assertEquals("isSerializedType", true, DataExistsReply.isSerializedType(new DataExistsReply()));
- assertEquals("isSerializedType", false, DataExistsReply.isSerializedType(new Object()));
+ assertTrue("isSerializedType", DataExistsReply.isSerializedType(new DataExistsReply()));
+ assertFalse("isSerializedType", DataExistsReply.isSerializedType(new Object()));
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
@Test
public void testIsSerializedType() {
@Test
public void testIsSerializedType() {
- assertEquals("isSerializedType", true, DataExists.isSerializedType(new DataExists()));
- assertEquals("isSerializedType", false, DataExists.isSerializedType(new Object()));
+ assertTrue("isSerializedType", DataExists.isSerializedType(new DataExists()));
+ assertFalse("isSerializedType", DataExists.isSerializedType(new Object()));
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
@Test
public void testIsSerializedType() {
@Test
public void testIsSerializedType() {
- assertEquals("isSerializedType", true, ReadDataReply.isSerializedType(new ReadDataReply()));
- assertEquals("isSerializedType", false, ReadDataReply.isSerializedType(new Object()));
+ assertTrue("isSerializedType", ReadDataReply.isSerializedType(new ReadDataReply()));
+ assertFalse("isSerializedType", ReadDataReply.isSerializedType(new Object()));
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
package org.opendaylight.controller.cluster.datastore.messages;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
import java.io.Serializable;
import org.apache.commons.lang.SerializationUtils;
@Test
public void testIsSerializedType() {
@Test
public void testIsSerializedType() {
- assertEquals("isSerializedType", true, ReadData.isSerializedType(new ReadData()));
- assertEquals("isSerializedType", false, ReadData.isSerializedType(new Object()));
+ assertTrue("isSerializedType", ReadData.isSerializedType(new ReadData()));
+ assertFalse("isSerializedType", ReadData.isSerializedType(new Object()));
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import akka.actor.ExtendedActorSystem;
import akka.testkit.javadsl.TestKit;
import akka.actor.ExtendedActorSystem;
import akka.testkit.javadsl.TestKit;
BatchedModifications batched = (BatchedModifications)deserialized;
assertEquals("getTransactionID", txId, batched.getTransactionId());
assertEquals("getVersion", DataStoreVersions.CURRENT_VERSION, batched.getVersion());
BatchedModifications batched = (BatchedModifications)deserialized;
assertEquals("getTransactionID", txId, batched.getTransactionId());
assertEquals("getVersion", DataStoreVersions.CURRENT_VERSION, batched.getVersion());
- assertEquals("isReady", true, batched.isReady());
- assertEquals("isDoCommitOnReady", true, batched.isDoCommitOnReady());
- assertEquals("participatingShardNames present", true, batched.getParticipatingShardNames().isPresent());
+ assertTrue("isReady", batched.isReady());
+ assertTrue("isDoCommitOnReady", batched.isDoCommitOnReady());
+ assertTrue("participatingShardNames present", batched.getParticipatingShardNames().isPresent());
assertEquals("participatingShardNames", shardNames, batched.getParticipatingShardNames().get());
List<Modification> batchedMods = batched.getModifications();
assertEquals("participatingShardNames", shardNames, batched.getParticipatingShardNames().get());
List<Modification> batchedMods = batched.getModifications();
package org.opendaylight.controller.cluster.datastore.persisted;
import static org.junit.Assert.assertEquals;
package org.opendaylight.controller.cluster.datastore.persisted;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import com.google.common.collect.ImmutableMap;
import java.io.ByteArrayInputStream;
import com.google.common.collect.ImmutableMap;
import java.io.ByteArrayInputStream;
}
Optional<NormalizedNode<?, ?>> actualNode = deserialized.getRootNode();
}
Optional<NormalizedNode<?, ?>> actualNode = deserialized.getRootNode();
- assertEquals("rootNode present", true, actualNode.isPresent());
+ assertTrue("rootNode present", actualNode.isPresent());
assertEquals("rootNode", expectedNode, actualNode.get());
assertEquals("Deserialized type", MetadataShardDataTreeSnapshot.class, deserialized.getClass());
assertEquals("Metadata size", 0, ((MetadataShardDataTreeSnapshot)deserialized).getMetadata().size());
assertEquals("rootNode", expectedNode, actualNode.get());
assertEquals("Deserialized type", MetadataShardDataTreeSnapshot.class, deserialized.getClass());
assertEquals("Metadata size", 0, ((MetadataShardDataTreeSnapshot)deserialized).getMetadata().size());
}
Optional<NormalizedNode<?, ?>> actualNode = deserialized.getRootNode();
}
Optional<NormalizedNode<?, ?>> actualNode = deserialized.getRootNode();
- assertEquals("rootNode present", true, actualNode.isPresent());
+ assertTrue("rootNode present", actualNode.isPresent());
assertEquals("rootNode", expectedNode, actualNode.get());
assertEquals("Deserialized type", MetadataShardDataTreeSnapshot.class, deserialized.getClass());
assertEquals("Metadata", expMetadata, ((MetadataShardDataTreeSnapshot)deserialized).getMetadata());
assertEquals("rootNode", expectedNode, actualNode.get());
assertEquals("Deserialized type", MetadataShardDataTreeSnapshot.class, deserialized.getClass());
assertEquals("Metadata", expMetadata, ((MetadataShardDataTreeSnapshot)deserialized).getMetadata());
package org.opendaylight.controller.cluster.datastore.shardmanager;
import static org.junit.Assert.assertEquals;
package org.opendaylight.controller.cluster.datastore.shardmanager;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
shardManager.tell(new UpdateSchemaContext(TEST_SCHEMA_CONTEXT), kit.getRef());
shardManager.tell(new UpdateSchemaContext(TEST_SCHEMA_CONTEXT), kit.getRef());
- assertEquals("Shard actors created", true, newShardActorLatch.await(5, TimeUnit.SECONDS));
+ assertTrue("Shard actors created", newShardActorLatch.await(5, TimeUnit.SECONDS));
assertEquals("getShardElectionTimeoutFactor", 6,
shardInfoMap.get("default").getValue().getShardElectionTimeoutFactor());
assertEquals("getShardElectionTimeoutFactor", 7,
assertEquals("getShardElectionTimeoutFactor", 6,
shardInfoMap.get("default").getValue().getShardElectionTimeoutFactor());
assertEquals("getShardElectionTimeoutFactor", 7,
public void testByDefaultSyncStatusIsFalse() {
TestShardManager shardManager = newTestShardManager();
public void testByDefaultSyncStatusIsFalse() {
TestShardManager shardManager = newTestShardManager();
- assertEquals(false, shardManager.getMBean().getSyncStatus());
+ assertFalse(shardManager.getMBean().getSyncStatus());
shardManager.onReceiveCommand(new RoleChangeNotification("member-1-shard-default-" + shardMrgIDSuffix,
RaftState.Follower.name(), RaftState.Leader.name()));
shardManager.onReceiveCommand(new RoleChangeNotification("member-1-shard-default-" + shardMrgIDSuffix,
RaftState.Follower.name(), RaftState.Leader.name()));
- assertEquals(true, shardManager.getMBean().getSyncStatus());
+ assertTrue(shardManager.getMBean().getSyncStatus());
shardManager.onReceiveCommand(new RoleChangeNotification(shardId,
RaftState.Follower.name(), RaftState.Candidate.name()));
shardManager.onReceiveCommand(new RoleChangeNotification(shardId,
RaftState.Follower.name(), RaftState.Candidate.name()));
- assertEquals(false, shardManager.getMBean().getSyncStatus());
+ assertFalse(shardManager.getMBean().getSyncStatus());
// Send a FollowerInitialSyncStatus with status = true for the replica whose current state is candidate
shardManager.onReceiveCommand(new FollowerInitialSyncUpStatus(
true, shardId));
// Send a FollowerInitialSyncStatus with status = true for the replica whose current state is candidate
shardManager.onReceiveCommand(new FollowerInitialSyncUpStatus(
true, shardId));
- assertEquals(false, shardManager.getMBean().getSyncStatus());
+ assertFalse(shardManager.getMBean().getSyncStatus());
RaftState.Candidate.name(), RaftState.Follower.name()));
// Initially will be false
RaftState.Candidate.name(), RaftState.Follower.name()));
// Initially will be false
- assertEquals(false, shardManager.getMBean().getSyncStatus());
+ assertFalse(shardManager.getMBean().getSyncStatus());
// Send status true will make sync status true
shardManager.onReceiveCommand(new FollowerInitialSyncUpStatus(true, shardId));
// Send status true will make sync status true
shardManager.onReceiveCommand(new FollowerInitialSyncUpStatus(true, shardId));
- assertEquals(true, shardManager.getMBean().getSyncStatus());
+ assertTrue(shardManager.getMBean().getSyncStatus());
// Send status false will make sync status false
shardManager.onReceiveCommand(new FollowerInitialSyncUpStatus(false, shardId));
// Send status false will make sync status false
shardManager.onReceiveCommand(new FollowerInitialSyncUpStatus(false, shardId));
- assertEquals(false, shardManager.getMBean().getSyncStatus());
+ assertFalse(shardManager.getMBean().getSyncStatus());
}));
// Initially will be false
}));
// Initially will be false
- assertEquals(false, shardManager.getMBean().getSyncStatus());
+ assertFalse(shardManager.getMBean().getSyncStatus());
// Make default shard leader
String defaultShardId = "member-1-shard-default-" + shardMrgIDSuffix;
// Make default shard leader
String defaultShardId = "member-1-shard-default-" + shardMrgIDSuffix;
RaftState.Follower.name(), RaftState.Leader.name()));
// default = Leader, astronauts is unknown so sync status remains false
RaftState.Follower.name(), RaftState.Leader.name()));
// default = Leader, astronauts is unknown so sync status remains false
- assertEquals(false, shardManager.getMBean().getSyncStatus());
+ assertFalse(shardManager.getMBean().getSyncStatus());
// Make astronauts shard leader as well
String astronautsShardId = "member-1-shard-astronauts-" + shardMrgIDSuffix;
// Make astronauts shard leader as well
String astronautsShardId = "member-1-shard-astronauts-" + shardMrgIDSuffix;
RaftState.Follower.name(), RaftState.Leader.name()));
// Now sync status should be true
RaftState.Follower.name(), RaftState.Leader.name()));
// Now sync status should be true
- assertEquals(true, shardManager.getMBean().getSyncStatus());
+ assertTrue(shardManager.getMBean().getSyncStatus());
// Make astronauts a Follower
shardManager.onReceiveCommand(new RoleChangeNotification(astronautsShardId,
RaftState.Leader.name(), RaftState.Follower.name()));
// Sync status is not true
// Make astronauts a Follower
shardManager.onReceiveCommand(new RoleChangeNotification(astronautsShardId,
RaftState.Leader.name(), RaftState.Follower.name()));
// Sync status is not true
- assertEquals(false, shardManager.getMBean().getSyncStatus());
+ assertFalse(shardManager.getMBean().getSyncStatus());
// Make the astronauts follower sync status true
shardManager.onReceiveCommand(new FollowerInitialSyncUpStatus(true, astronautsShardId));
// Sync status is now true
// Make the astronauts follower sync status true
shardManager.onReceiveCommand(new FollowerInitialSyncUpStatus(true, astronautsShardId));
// Sync status is now true
- assertEquals(true, shardManager.getMBean().getSyncStatus());
+ assertTrue(shardManager.getMBean().getSyncStatus());
LOG.info("testWhenMultipleShardsPresentSyncStatusMustBeTrueForAllShards ending");
}
LOG.info("testWhenMultipleShardsPresentSyncStatusMustBeTrueForAllShards ending");
}
kit.expectMsgClass(kit.duration("5 seconds"), LocalShardFound.class);
kit.expectMsgClass(kit.duration("5 seconds"), LocalShardFound.class);
- assertEquals("isRecoveryApplicable", false, shardBuilder.getDatastoreContext().isPersistent());
+ assertFalse("isRecoveryApplicable", shardBuilder.getDatastoreContext().isPersistent());
assertTrue("Epxected ShardPeerAddressResolver", shardBuilder.getDatastoreContext().getShardRaftConfig()
.getPeerAddressResolver() instanceof ShardPeerAddressResolver);
assertEquals("peerMembers", Sets.newHashSet(
assertTrue("Epxected ShardPeerAddressResolver", shardBuilder.getDatastoreContext().getShardRaftConfig()
.getPeerAddressResolver() instanceof ShardPeerAddressResolver);
assertEquals("peerMembers", Sets.newHashSet(
shardManager.tell(new AddShardReplica("model-inventory"), kit.getRef());
Status.Failure resp = kit.expectMsgClass(kit.duration("2 seconds"), Status.Failure.class);
shardManager.tell(new AddShardReplica("model-inventory"), kit.getRef());
Status.Failure resp = kit.expectMsgClass(kit.duration("2 seconds"), Status.Failure.class);
- assertEquals("Failure obtained", true, resp.cause() instanceof IllegalArgumentException);
+ assertTrue("Failure obtained", resp.cause() instanceof IllegalArgumentException);
newReplicaShardManager.tell(new AddShardReplica("astronauts"), kit.getRef());
Status.Failure resp = kit.expectMsgClass(kit.duration("5 seconds"), Status.Failure.class);
newReplicaShardManager.tell(new AddShardReplica("astronauts"), kit.getRef());
Status.Failure resp = kit.expectMsgClass(kit.duration("5 seconds"), Status.Failure.class);
- assertEquals("Failure obtained", true, resp.cause() instanceof RuntimeException);
+ assertTrue("Failure obtained", resp.cause() instanceof RuntimeException);
LOG.info("testAddShardReplicaWithFindPrimaryTimeout ending");
}
LOG.info("testAddShardReplicaWithFindPrimaryTimeout ending");
}
shardManager.tell(new RemoveShardReplica("model-inventory", MEMBER_1), kit.getRef());
Status.Failure resp = kit.expectMsgClass(kit.duration("10 seconds"), Status.Failure.class);
shardManager.tell(new RemoveShardReplica("model-inventory", MEMBER_1), kit.getRef());
Status.Failure resp = kit.expectMsgClass(kit.duration("10 seconds"), Status.Failure.class);
- assertEquals("Failure obtained", true, resp.cause() instanceof PrimaryNotFoundException);
+ assertTrue("Failure obtained", resp.cause() instanceof PrimaryNotFoundException);
MessageCollectorActor.expectFirstMatching(respondActor, ChangeServersVotingStatus.class);
Status.Failure resp = kit.expectMsgClass(kit.duration("5 seconds"), Status.Failure.class);
MessageCollectorActor.expectFirstMatching(respondActor, ChangeServersVotingStatus.class);
Status.Failure resp = kit.expectMsgClass(kit.duration("5 seconds"), Status.Failure.class);
- assertEquals("Failure resposnse", true, resp.cause() instanceof NoShardLeaderException);
+ assertTrue("Failure resposnse", resp.cause() instanceof NoShardLeaderException);
}
public static class TestShardManager extends ShardManager {
}
public static class TestShardManager extends ShardManager {
}
void waitForRecoveryComplete() {
}
void waitForRecoveryComplete() {
- assertEquals("Recovery complete", true,
+ assertTrue("Recovery complete",
Uninterruptibles.awaitUninterruptibly(recoveryComplete, 5, TimeUnit.SECONDS));
}
public void waitForMemberUp() {
Uninterruptibles.awaitUninterruptibly(recoveryComplete, 5, TimeUnit.SECONDS));
}
public void waitForMemberUp() {
- assertEquals("MemberUp received", true,
+ assertTrue("MemberUp received",
Uninterruptibles.awaitUninterruptibly(memberUpReceived, 5, TimeUnit.SECONDS));
memberUpReceived = new CountDownLatch(1);
}
void waitForMemberRemoved() {
Uninterruptibles.awaitUninterruptibly(memberUpReceived, 5, TimeUnit.SECONDS));
memberUpReceived = new CountDownLatch(1);
}
void waitForMemberRemoved() {
- assertEquals("MemberRemoved received", true,
+ assertTrue("MemberRemoved received",
Uninterruptibles.awaitUninterruptibly(memberRemovedReceived, 5, TimeUnit.SECONDS));
memberRemovedReceived = new CountDownLatch(1);
}
void waitForUnreachableMember() {
Uninterruptibles.awaitUninterruptibly(memberRemovedReceived, 5, TimeUnit.SECONDS));
memberRemovedReceived = new CountDownLatch(1);
}
void waitForUnreachableMember() {
- assertEquals("UnreachableMember received", true,
- Uninterruptibles.awaitUninterruptibly(memberUnreachableReceived, 5, TimeUnit.SECONDS
- ));
+ assertTrue("UnreachableMember received",
+ Uninterruptibles.awaitUninterruptibly(memberUnreachableReceived, 5, TimeUnit.SECONDS));
memberUnreachableReceived = new CountDownLatch(1);
}
void waitForReachableMember() {
memberUnreachableReceived = new CountDownLatch(1);
}
void waitForReachableMember() {
- assertEquals("ReachableMember received", true,
+ assertTrue("ReachableMember received",
Uninterruptibles.awaitUninterruptibly(memberReachableReceived, 5, TimeUnit.SECONDS));
memberReachableReceived = new CountDownLatch(1);
}
void verifyFindPrimary() {
Uninterruptibles.awaitUninterruptibly(memberReachableReceived, 5, TimeUnit.SECONDS));
memberReachableReceived = new CountDownLatch(1);
}
void verifyFindPrimary() {
- assertEquals("FindPrimary received", true,
+ assertTrue("FindPrimary received",
Uninterruptibles.awaitUninterruptibly(findPrimaryMessageReceived, 5, TimeUnit.SECONDS));
findPrimaryMessageReceived = new CountDownLatch(1);
}
Uninterruptibles.awaitUninterruptibly(findPrimaryMessageReceived, 5, TimeUnit.SECONDS));
findPrimaryMessageReceived = new CountDownLatch(1);
}
}
void verifySnapshotPersisted(final Set<String> shardList) {
}
void verifySnapshotPersisted(final Set<String> shardList) {
- assertEquals("saveSnapshot invoked", true,
+ assertTrue("saveSnapshot invoked",
Uninterruptibles.awaitUninterruptibly(snapshotPersist, 5, TimeUnit.SECONDS));
assertEquals("Shard Persisted", shardList, Sets.newHashSet(snapshot.getShardList()));
}
Uninterruptibles.awaitUninterruptibly(snapshotPersist, 5, TimeUnit.SECONDS));
assertEquals("Shard Persisted", shardList, Sets.newHashSet(snapshot.getShardList()));
}
ActorContext actorContext = null;
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
ActorContext actorContext = null;
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
- assertEquals(false, actorContext.isPathLocal(null));
- assertEquals(false, actorContext.isPathLocal(""));
+ assertFalse(actorContext.isPathLocal(null));
+ assertFalse(actorContext.isPathLocal(""));
clusterWrapper.setSelfAddress(null);
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
clusterWrapper.setSelfAddress(null);
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
- assertEquals(false, actorContext.isPathLocal(""));
+ assertFalse(actorContext.isPathLocal(""));
// even if the path is in local format, match the primary path (first 3 elements) and return true
clusterWrapper.setSelfAddress(new Address("akka", "test"));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
// even if the path is in local format, match the primary path (first 3 elements) and return true
clusterWrapper.setSelfAddress(new Address("akka", "test"));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
- assertEquals(true, actorContext.isPathLocal("akka://test/user/$a"));
+ assertTrue(actorContext.isPathLocal("akka://test/user/$a"));
clusterWrapper.setSelfAddress(new Address("akka", "test"));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
clusterWrapper.setSelfAddress(new Address("akka", "test"));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
- assertEquals(true, actorContext.isPathLocal("akka://test/user/$a"));
+ assertTrue(actorContext.isPathLocal("akka://test/user/$a"));
clusterWrapper.setSelfAddress(new Address("akka", "test"));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
clusterWrapper.setSelfAddress(new Address("akka", "test"));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
- assertEquals(true, actorContext.isPathLocal("akka://test/user/token2/token3/$a"));
+ assertTrue(actorContext.isPathLocal("akka://test/user/token2/token3/$a"));
// self address of remote format,but Tx path local format.
clusterWrapper.setSelfAddress(new Address("akka", "system", "127.0.0.1", 2550));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
// self address of remote format,but Tx path local format.
clusterWrapper.setSelfAddress(new Address("akka", "system", "127.0.0.1", 2550));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
- assertEquals(true, actorContext.isPathLocal(
- "akka://system/user/shardmanager/shard/transaction"));
+ assertTrue(actorContext.isPathLocal("akka://system/user/shardmanager/shard/transaction"));
// self address of local format,but Tx path remote format.
clusterWrapper.setSelfAddress(new Address("akka", "system"));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
// self address of local format,but Tx path remote format.
clusterWrapper.setSelfAddress(new Address("akka", "system"));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
- assertEquals(false, actorContext.isPathLocal(
- "akka://system@127.0.0.1:2550/user/shardmanager/shard/transaction"));
+ assertFalse(actorContext.isPathLocal("akka://system@127.0.0.1:2550/user/shardmanager/shard/transaction"));
//local path but not same
clusterWrapper.setSelfAddress(new Address("akka", "test"));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
//local path but not same
clusterWrapper.setSelfAddress(new Address("akka", "test"));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
- assertEquals(true, actorContext.isPathLocal("akka://test1/user/$a"));
+ assertTrue(actorContext.isPathLocal("akka://test1/user/$a"));
//ip and port same
clusterWrapper.setSelfAddress(new Address("akka", "system", "127.0.0.1", 2550));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
//ip and port same
clusterWrapper.setSelfAddress(new Address("akka", "system", "127.0.0.1", 2550));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
- assertEquals(true, actorContext.isPathLocal("akka://system@127.0.0.1:2550/"));
+ assertTrue(actorContext.isPathLocal("akka://system@127.0.0.1:2550/"));
// forward-slash missing in address
clusterWrapper.setSelfAddress(new Address("akka", "system", "127.0.0.1", 2550));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
// forward-slash missing in address
clusterWrapper.setSelfAddress(new Address("akka", "system", "127.0.0.1", 2550));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
- assertEquals(false, actorContext.isPathLocal("akka://system@127.0.0.1:2550"));
+ assertFalse(actorContext.isPathLocal("akka://system@127.0.0.1:2550"));
//ips differ
clusterWrapper.setSelfAddress(new Address("akka", "system", "127.0.0.1", 2550));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
//ips differ
clusterWrapper.setSelfAddress(new Address("akka", "system", "127.0.0.1", 2550));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
- assertEquals(false, actorContext.isPathLocal("akka://system@127.1.0.1:2550/"));
+ assertFalse(actorContext.isPathLocal("akka://system@127.1.0.1:2550/"));
//ports differ
clusterWrapper.setSelfAddress(new Address("akka", "system", "127.0.0.1", 2550));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
//ports differ
clusterWrapper.setSelfAddress(new Address("akka", "system", "127.0.0.1", 2550));
actorContext = new ActorContext(getSystem(), null, clusterWrapper, mock(Configuration.class));
- assertEquals(false, actorContext.isPathLocal("akka://system@127.0.0.1:2551/"));
+ assertFalse(actorContext.isPathLocal("akka://system@127.0.0.1:2551/"));
PrimaryShardInfo actual = Await.result(foobar, Duration.apply(5000, TimeUnit.MILLISECONDS));
assertNotNull(actual);
PrimaryShardInfo actual = Await.result(foobar, Duration.apply(5000, TimeUnit.MILLISECONDS));
assertNotNull(actual);
- assertEquals("LocalShardDataTree present", false, actual.getLocalShardDataTree().isPresent());
+ assertFalse("LocalShardDataTree present", actual.getLocalShardDataTree().isPresent());
assertTrue("Unexpected PrimaryShardActor path " + actual.getPrimaryShardActor().path(),
expPrimaryPath.endsWith(actual.getPrimaryShardActor().pathString()));
assertEquals("getPrimaryShardVersion", expPrimaryVersion, actual.getPrimaryShardVersion());
assertTrue("Unexpected PrimaryShardActor path " + actual.getPrimaryShardActor().path(),
expPrimaryPath.endsWith(actual.getPrimaryShardActor().pathString()));
assertEquals("getPrimaryShardVersion", expPrimaryVersion, actual.getPrimaryShardVersion());
PrimaryShardInfo actual = Await.result(foobar, Duration.apply(5000, TimeUnit.MILLISECONDS));
assertNotNull(actual);
PrimaryShardInfo actual = Await.result(foobar, Duration.apply(5000, TimeUnit.MILLISECONDS));
assertNotNull(actual);
- assertEquals("LocalShardDataTree present", true, actual.getLocalShardDataTree().isPresent());
+ assertTrue("LocalShardDataTree present", actual.getLocalShardDataTree().isPresent());
assertSame("LocalShardDataTree", mockDataTree, actual.getLocalShardDataTree().get());
assertTrue("Unexpected PrimaryShardActor path " + actual.getPrimaryShardActor().path(),
expPrimaryPath.endsWith(actual.getPrimaryShardActor().pathString()));
assertSame("LocalShardDataTree", mockDataTree, actual.getLocalShardDataTree().get());
assertTrue("Unexpected PrimaryShardActor path " + actual.getPrimaryShardActor().path(),
expPrimaryPath.endsWith(actual.getPrimaryShardActor().pathString()));
followerOperDatastore.close();
}
followerOperDatastore.close();
}
- TestKit.shutdownActorSystem(leaderSystem, Boolean.TRUE);
- TestKit.shutdownActorSystem(followerSystem, Boolean.TRUE);
+ TestKit.shutdownActorSystem(leaderSystem, true);
+ TestKit.shutdownActorSystem(followerSystem, true);
InMemoryJournal.clear();
InMemorySnapshotStore.clear();
InMemoryJournal.clear();
InMemorySnapshotStore.clear();
Code Review / controller.git / commitdiff