// we cannot rely comfortably that the sleep will indeed sleep for the desired time
// hence getting the actual elapsed time and do a match.
// if the sleep has spilled over, then return the test gracefully
- private long sleepWithElaspsedTimeReturned(long millis) {
+ private static long sleepWithElaspsedTimeReturned(long millis) {
Stopwatch stopwatch = Stopwatch.createStarted();
Uninterruptibles.sleepUninterruptibly(millis, TimeUnit.MILLISECONDS);
stopwatch.stop();
}
}
- private DefaultConfigParamsImpl newFollowerConfigParams() {
+ private static DefaultConfigParamsImpl newFollowerConfigParams() {
DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl();
configParams.setHeartBeatInterval(new FiniteDuration(100, TimeUnit.MILLISECONDS));
configParams.setElectionTimeoutFactor(100000);
expectFirstMatching(leaderActor, AddServer.class);
}
- private void verifyServerConfigurationPayloadEntry(ReplicatedLog log, String... cNew) {
+ private static void verifyServerConfigurationPayloadEntry(ReplicatedLog log, String... cNew) {
ReplicatedLogEntry logEntry = log.get(log.lastIndex());
assertEquals("Last log entry payload class", ServerConfigurationPayload.class, logEntry.getData().getClass());
ServerConfigurationPayload payload = (ServerConfigurationPayload)logEntry.getData();
assertEquals("getNewServerConfig", Sets.newHashSet(cNew), Sets.newHashSet(payload.getNewServerConfig()));
}
- private RaftActorContext newFollowerContext(String id, TestActorRef<? extends UntypedActor> actor) {
+ private static RaftActorContext newFollowerContext(String id, TestActorRef<? extends UntypedActor> actor) {
DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl();
configParams.setHeartBeatInterval(new FiniteDuration(100, TimeUnit.MILLISECONDS));
configParams.setElectionTimeoutFactor(100000);
* Use this method to generate a file with a serialized ReplicatedLogImplEntry instance to be
* used in tests that verify backwards compatible de-serialization.
*/
- private void generateSerializedFile() throws IOException {
+ private static void generateSerializedFile() throws IOException {
String expPayloadData = "This is a test";
int expIndex = 1;
int expTerm = 2;
}
}
- private Snapshot newLithiumSnapshot() {
+ private static Snapshot newLithiumSnapshot() {
byte[] state = {1, 2, 3, 4, 5};
List<ReplicatedLogEntry> entries = new ArrayList<>();
entries.add(new ReplicatedLogImplEntry(6, 2, new MockPayload("payload")));
* Use this method to generate a file with a serialized Snapshot instance to be
* used in tests that verify backwards compatible de-serialization.
*/
- private void generateSerializedFile(Snapshot snapshot, String fileName) throws IOException {
+ private static void generateSerializedFile(Snapshot snapshot, String fileName) throws IOException {
FileOutputStream fos = new FileOutputStream("src/test/resources/" + fileName);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(snapshot);
return context;
}
- private int getElectionTimeoutCount(RaftActorBehavior follower){
+ private static int getElectionTimeoutCount(RaftActorBehavior follower){
if(follower instanceof TestFollower){
return ((TestFollower) follower).getElectionTimeoutCount();
}
}
- private ReplicatedLogEntry newReplicatedLogEntry(long term, long index, String data) {
+ private static ReplicatedLogEntry newReplicatedLogEntry(long term, long index, String data) {
return new MockRaftActorContext.MockReplicatedLogEntry(term, index,
new MockRaftActorContext.MockPayload(data));
}
return bs.substring(start, start + size);
}
- private ByteString toByteString(Map<String, String> state) {
+ private static ByteString toByteString(Map<String, String> state) {
ByteArrayOutputStream b = null;
ObjectOutputStream o = null;
try {
verifyAppendEntries(entries, entries2);
}
- private void verifyAppendEntries(AppendEntries expected, AppendEntries actual) {
+ private static void verifyAppendEntries(AppendEntries expected, AppendEntries actual) {
assertEquals("getLeaderId", expected.getLeaderId(), actual.getLeaderId());
assertEquals("getTerm", expected.getTerm(), actual.getTerm());
assertEquals("getLeaderCommit", expected.getLeaderCommit(), actual.getLeaderCommit());
}
}
- private void verifyReplicatedLogEntry(ReplicatedLogEntry expected, ReplicatedLogEntry actual) {
+ private static void verifyReplicatedLogEntry(ReplicatedLogEntry expected, ReplicatedLogEntry actual) {
assertEquals("getIndex", expected.getIndex(), actual.getIndex());
assertEquals("getTerm", expected.getTerm(), actual.getTerm());
assertEquals("getData", expected.getData().toString(), actual.getData().toString());
}
}
- private Gauge<Integer> getQueueSizeGuage(final MeteredMessageQueue monitoredQueue ){
+ private static Gauge<Integer> getQueueSizeGuage(final MeteredMessageQueue monitoredQueue ){
return new Gauge<Integer>() {
@Override
public Integer getValue() {
public class NormalizedNodePrinter implements NormalizedNodeVisitor {
- private String spaces(int n){
+ private static String spaces(int n){
StringBuilder builder = new StringBuilder();
for(int i=0;i<n;i++){
builder.append(' ');
import static org.junit.Assert.assertTrue;
public class NormalizedNodeToNodeCodecTest {
-
-
-
private SchemaContext schemaContext;
@Before
assertNotNull("Schema context must not be null.", schemaContext);
}
- private YangInstanceIdentifier instanceIdentifierFromString(String s) {
+ private static YangInstanceIdentifier instanceIdentifierFromString(String s) {
return PathUtils.toYangInstanceIdentifier(s);
}
}
- private YangInstanceIdentifier.NodeIdentifier nodeIdentifier(){
+ private static YangInstanceIdentifier.NodeIdentifier nodeIdentifier(){
return new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME);
}
- private YangInstanceIdentifier.AugmentationIdentifier augmentationIdentifier(){
+ private static YangInstanceIdentifier.AugmentationIdentifier augmentationIdentifier(){
Set<QName> childNames = ImmutableSet.of(QNameFactory.create("(urn:opendaylight:flow:table:statistics?revision=2013-12-15)flow-table-statistics"));
return new YangInstanceIdentifier.AugmentationIdentifier(childNames);
}
- private YangInstanceIdentifier.NodeWithValue nodeWithValue(){
+ private static YangInstanceIdentifier.NodeWithValue nodeWithValue(){
return new YangInstanceIdentifier.NodeWithValue(TestModel.TEST_QNAME, Integer.valueOf(100));
}
- private YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifierWithPredicates(){
+ private static YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifierWithPredicates(){
Map<QName, Object> keys = new HashMap<>();
keys.put(TestModel.ID_QNAME, Integer.valueOf(100));
writer.close();
}
- private NormalizedNode<?, ?> createTestContainer() {
+ private static NormalizedNode<?, ?> createTestContainer() {
byte[] bytes1 = {1,2,3};
LeafSetEntryNode<Object> entry1 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
new YangInstanceIdentifier.NodeWithValue(TestModel.BINARY_LEAF_LIST_QNAME, bytes1)).
}
- private int countNodes(NormalizedNode<?,?> normalizedNode, final String namespaceFilter){
+ private static int countNodes(NormalizedNode<?,?> normalizedNode, final String namespaceFilter){
if(normalizedNode == null){
return 0;
}
verify(normalizedNodeContainerBuilder).addChild(any(NormalizedNode.class));
}
- private NormalizedNode<?, ?> createTestContainer() {
+ private static NormalizedNode<?, ?> createTestContainer() {
byte[] bytes1 = {1,2,3};
LeafSetEntryNode<Object> entry1 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
new YangInstanceIdentifier.NodeWithValue(TestModel.BINARY_LEAF_LIST_QNAME, bytes1)).
}
- private void withValue(Object value) {
+ private static void withValue(Object value) {
YangInstanceIdentifier.PathArgument p1 = new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME);
YangInstanceIdentifier.PathArgument p2 =
}
- private void withPredicates(Object value) {
+ private static void withPredicates(Object value) {
YangInstanceIdentifier.PathArgument p1 = new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME);
YangInstanceIdentifier.PathArgument p2 = new YangInstanceIdentifier.NodeIdentifierWithPredicates(
}
}
- private void onFindPrimaryShardFailure(Throwable failure, TransactionProxy parent,
+ private static void onFindPrimaryShardFailure(Throwable failure, TransactionProxy parent,
String shardName, TransactionContextWrapper transactionContextWrapper) {
LOG.debug("Tx {}: Find primary for shard {} failed", parent.getIdentifier(), shardName, failure);
return updated;
}
- private String convertToCamelCase(String inString) {
+ private static String convertToCamelCase(String inString) {
String str = inString.trim();
if(StringUtils.contains(str, '-') || StringUtils.contains(str, ' ')) {
str = inString.replace('-', ' ');
getSender().tell(messageSupplier.get(), getSelf());
}
- private NoShardLeaderException createNoShardLeaderException(ShardIdentifier shardId) {
+ private static NoShardLeaderException createNoShardLeaderException(ShardIdentifier shardId) {
return new NoShardLeaderException(null, shardId.toString());
}
- private NotInitializedException createNotInitializedException(ShardIdentifier shardId) {
+ private static NotInitializedException createNotInitializedException(ShardIdentifier shardId) {
return new NotInitializedException(String.format(
"Found primary shard %s but it's not initialized yet. Please try again later", shardId));
}
return moduleConfigMap;
}
- private void readModulesConfig(final Config modulesConfig, Map<String, ModuleConfig> moduleConfigMap,
+ private static void readModulesConfig(final Config modulesConfig, Map<String, ModuleConfig> moduleConfigMap,
Configuration configuration) {
List<? extends ConfigObject> modulesConfigObjectList = modulesConfig.getObjectList("modules");
return Collections.emptyList();
}
- private YangInstanceIdentifier extractEntityPath(YangInstanceIdentifier candidatePath) {
+ private static YangInstanceIdentifier extractEntityPath(YangInstanceIdentifier candidatePath) {
List<PathArgument> newPathArgs = new ArrayList<>();
for(PathArgument pathArg: candidatePath.getPathArguments()) {
newPathArgs.add(pathArg);
}
}
- private String extractOwner(LeafNode<?> ownerLeaf) {
+ private static String extractOwner(LeafNode<?> ownerLeaf) {
Object value = ownerLeaf.getValue();
return value != null ? value.toString() : null;
}
return -1.0D;
}
- private double calculateNewRateLimit(Timer commitTimer, long commitTimeoutInSeconds) {
+ private static double calculateNewRateLimit(Timer commitTimer, long commitTimeoutInSeconds) {
if(commitTimer == null) {
// This can happen in unit tests.
return 0;
assertFailure(future, null, mockCohort1, mockCohort2, mockCohort3);
}
- private void assertFailure(final CheckedFuture<Void, TransactionCommitFailedException> future,
+ private static void assertFailure(final CheckedFuture<Void, TransactionCommitFailedException> future,
final Exception expCause, final DOMStoreThreePhaseCommitCohort... mockCohorts)
throws Exception {
try {
}};
}
- private AsyncDataChangeListener<YangInstanceIdentifier, NormalizedNode<?, ?>> noOpDataChangeListener(){
+ private static AsyncDataChangeListener<YangInstanceIdentifier, NormalizedNode<?, ?>> noOpDataChangeListener(){
return new AsyncDataChangeListener<YangInstanceIdentifier, NormalizedNode<?, ?>>() {
@Override
public void onDataChanged(final AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change) {
Assert.assertNotSame(context, newContext);
}
- private void verifyCustomSettings(DatastoreContext context) {
+ private static void verifyCustomSettings(DatastoreContext context) {
assertEquals(DEFAULT_SHARD_TRANSACTION_IDLE_TIMEOUT.toMillis() + 1,
context.getShardTransactionIdleTimeout().toMillis());
assertEquals(TimeUnit.MILLISECONDS.toSeconds(DEFAULT_OPERATION_TIMEOUT_IN_MS) + 1,
leaderTestKit.waitUntilLeader(leaderDistributedDataStore.getActorContext(), SHARD_NAMES);
}
- private void verifyCars(DOMStoreReadTransaction readTx, MapEntryNode... entries) throws Exception {
+ private static void verifyCars(DOMStoreReadTransaction readTx, MapEntryNode... entries) throws Exception {
Optional<NormalizedNode<?, ?>> optional = readTx.read(CarsModel.CAR_LIST_PATH).get(5, TimeUnit.SECONDS);
assertEquals("isPresent", true, optional.isPresent());
assertEquals("Car list node", listBuilder.build(), optional.get());
}
- private void verifyNode(DOMStoreReadTransaction readTx, YangInstanceIdentifier path, NormalizedNode<?, ?> expNode)
+ private static void verifyNode(DOMStoreReadTransaction readTx, YangInstanceIdentifier path, NormalizedNode<?, ?> expNode)
throws Exception {
Optional<NormalizedNode<?, ?>> optional = readTx.read(path).get(5, TimeUnit.SECONDS);
assertEquals("isPresent", true, optional.isPresent());
assertEquals("Data node", expNode, optional.get());
}
- private void verifyExists(DOMStoreReadTransaction readTx, YangInstanceIdentifier path) throws Exception {
+ private static void verifyExists(DOMStoreReadTransaction readTx, YangInstanceIdentifier path) throws Exception {
Boolean exists = readTx.exists(path).get(5, TimeUnit.SECONDS);
assertEquals("exists", true, exists);
}
}
}
- private ActorRef findLocalShard(ActorContext actorContext, String shardName) {
+ private static ActorRef findLocalShard(ActorContext actorContext, String shardName) {
ActorRef shard = null;
for(int i = 0; i < 20 * 5 && shard == null; i++) {
Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS);
assertEquals(expected, actual);
}
- private NormalizedNode<?, ?> getCars(ShardDataTree shardDataTree) {
+ private static NormalizedNode<?, ?> getCars(ShardDataTree shardDataTree) {
ReadOnlyShardDataTreeTransaction readOnlyShardDataTreeTransaction = shardDataTree.newReadOnlyTransaction("txn-2", null);
DataTreeSnapshot snapshot1 = readOnlyShardDataTreeTransaction.getSnapshot();
return optional.get();
}
- private DataTreeCandidateTip addCar(ShardDataTree shardDataTree) throws ExecutionException, InterruptedException {
+ private static DataTreeCandidateTip addCar(ShardDataTree shardDataTree) throws ExecutionException, InterruptedException {
return doTransaction(shardDataTree, new DataTreeOperation() {
@Override
public void execute(DataTreeModification snapshot) {
});
}
- private DataTreeCandidateTip removeCar(ShardDataTree shardDataTree) throws ExecutionException, InterruptedException {
+ private static DataTreeCandidateTip removeCar(ShardDataTree shardDataTree) throws ExecutionException, InterruptedException {
return doTransaction(shardDataTree, new DataTreeOperation() {
@Override
public void execute(DataTreeModification snapshot) {
public abstract void execute(DataTreeModification snapshot);
}
- private DataTreeCandidateTip doTransaction(ShardDataTree shardDataTree, DataTreeOperation operation)
+ private static DataTreeCandidateTip doTransaction(ShardDataTree shardDataTree, DataTreeOperation operation)
throws ExecutionException, InterruptedException {
ReadWriteShardDataTreeTransaction transaction = shardDataTree.newReadWriteTransaction("txn-1", null);
DataTreeModification snapshot = transaction.getSnapshot();
return candidate;
}
- private DataTreeCandidateTip applyCandidates(ShardDataTree shardDataTree, List<DataTreeCandidateTip> candidates)
+ private static DataTreeCandidateTip applyCandidates(ShardDataTree shardDataTree, List<DataTreeCandidateTip> candidates)
throws ExecutionException, InterruptedException {
ReadWriteShardDataTreeTransaction transaction = shardDataTree.newReadWriteTransaction("txn-1", null);
DataTreeModification snapshot = transaction.getSnapshot();
Await.result(future, Duration.create(3, TimeUnit.SECONDS));
}
- private NormalizedNodeMessages.Node buildNormalizedNode() {
+ private static NormalizedNodeMessages.Node buildNormalizedNode() {
return NormalizedNodeSerializer
.serialize(Builders.containerBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME)).build());
}
any(ActorSelection.class), isA(requestType), any(Timeout.class));
}
- private void propagateExecutionExceptionCause(ListenableFuture<?> future) throws Throwable {
+ private static void propagateExecutionExceptionCause(ListenableFuture<?> future) throws Throwable {
try {
future.get(5, TimeUnit.SECONDS);
expected, (end-start)), (end - start) <= expected);
}
- private Optional<DataTree> createDataTree(){
+ private static Optional<DataTree> createDataTree(){
DataTree dataTree = mock(DataTree.class);
Optional<DataTree> dataTreeOptional = Optional.of(dataTree);
DataTreeSnapshot dataTreeSnapshot = mock(DataTreeSnapshot.class);
return dataTreeOptional;
}
- private Optional<DataTree> createDataTree(NormalizedNode readResponse){
+ private static Optional<DataTree> createDataTree(NormalizedNode readResponse){
DataTree dataTree = mock(DataTree.class);
Optional<DataTree> dataTreeOptional = Optional.of(dataTree);
DataTreeSnapshot dataTreeSnapshot = mock(DataTreeSnapshot.class);
*/
public class PreLithiumShardTest extends AbstractShardTest {
- private CompositeModificationPayload newLegacyPayload(final Modification... mods) {
+ private static CompositeModificationPayload newLegacyPayload(final Modification... mods) {
MutableCompositeModification compMod = new MutableCompositeModification();
for(Modification mod: mods) {
compMod.addModification(mod);
return new CompositeModificationPayload(compMod.toSerializable());
}
- private CompositeModificationByteStringPayload newLegacyByteStringPayload(final Modification... mods) {
+ private static CompositeModificationByteStringPayload newLegacyByteStringPayload(final Modification... mods) {
MutableCompositeModification compMod = new MutableCompositeModification();
for(Modification mod: mods) {
compMod.addModification(mod);
return new CompositeModificationByteStringPayload(compMod.toSerializable());
}
- private ModificationPayload newModificationPayload(final Modification... mods) throws IOException {
+ private static ModificationPayload newModificationPayload(final Modification... mods) throws IOException {
MutableCompositeModification compMod = new MutableCompositeModification();
for(Modification mod: mods) {
compMod.addModification(mod);
*/
public class PreLithiumTransactionProxyTest extends AbstractTransactionProxyTest {
- private WriteData eqLegacyWriteData(final NormalizedNode<?, ?> nodeToWrite) {
+ private static WriteData eqLegacyWriteData(final NormalizedNode<?, ?> nodeToWrite) {
ArgumentMatcher<WriteData> matcher = new ArgumentMatcher<WriteData>() {
@Override
public boolean matches(Object argument) {
return argThat(matcher);
}
- private MergeData eqLegacyMergeData(final NormalizedNode<?, ?> nodeToWrite) {
+ private static MergeData eqLegacyMergeData(final NormalizedNode<?, ?> nodeToWrite) {
ArgumentMatcher<MergeData> matcher = new ArgumentMatcher<MergeData>() {
@Override
public boolean matches(Object argument) {
return argThat(matcher);
}
- private DeleteData eqLegacyDeleteData(final YangInstanceIdentifier expPath) {
+ private static DeleteData eqLegacyDeleteData(final YangInstanceIdentifier expPath) {
ArgumentMatcher<DeleteData> matcher = new ArgumentMatcher<DeleteData>() {
@Override
public boolean matches(Object argument) {
return argThat(matcher);
}
- private CanCommitTransaction eqCanCommitTransaction(final String transactionID) {
+ private static CanCommitTransaction eqCanCommitTransaction(final String transactionID) {
ArgumentMatcher<CanCommitTransaction> matcher = new ArgumentMatcher<CanCommitTransaction>() {
@Override
public boolean matches(Object argument) {
return argThat(matcher);
}
- private CommitTransaction eqCommitTransaction(final String transactionID) {
+ private static CommitTransaction eqCommitTransaction(final String transactionID) {
ArgumentMatcher<CommitTransaction> matcher = new ArgumentMatcher<CommitTransaction>() {
@Override
public boolean matches(Object argument) {
return argThat(matcher);
}
- private Future<Object> readySerializedTxReply(String path, short version) {
+ private static Future<Object> readySerializedTxReply(String path, short version) {
return Futures.successful(new ReadyTransactionReply(path, version).toSerializable());
}
verify(follower1MockListener, timeout(5000)).ownershipChanged(ownershipChange(ENTITY2, false, false, false));
}
- private void verifyGetOwnershipState(DistributedEntityOwnershipService service, Entity entity,
+ private static void verifyGetOwnershipState(DistributedEntityOwnershipService service, Entity entity,
boolean isOwner, boolean hasOwner) {
Optional<EntityOwnershipState> state = service.getOwnershipState(entity);
assertEquals("getOwnershipState present", true, state.isPresent());
assertEquals("hasOwner", hasOwner, state.get().hasOwner());
}
- private void verifyCandidates(DistributedDataStore dataStore, Entity entity, String... expCandidates) throws Exception {
+ private static void verifyCandidates(DistributedDataStore dataStore, Entity entity, String... expCandidates) throws Exception {
AssertionError lastError = null;
Stopwatch sw = Stopwatch.createStarted();
while(sw.elapsed(TimeUnit.MILLISECONDS) <= 5000) {
throw lastError;
}
- private void verifyOwner(final DistributedDataStore dataStore, Entity entity, String expOwner) throws Exception {
+ private static void verifyOwner(final DistributedDataStore dataStore, Entity entity, String expOwner) {
AbstractEntityOwnershipTest.verifyOwner(expOwner, entity.getType(), entity.getId(),
new Function<YangInstanceIdentifier, NormalizedNode<?,?>>() {
@Override
service.close();
}
- private void verifyGetOwnershipState(DistributedEntityOwnershipService service, Entity entity,
+ private static void verifyGetOwnershipState(DistributedEntityOwnershipService service, Entity entity,
boolean isOwner, boolean hasOwner) {
Optional<EntityOwnershipState> state = service.getOwnershipState(entity);
assertEquals("getOwnershipState present", true, state.isPresent());
});
}
- private void verifyRegisterCandidateLocal(final TestShardPropsCreator shardPropsCreator, Entity entity) {
+ private static void verifyRegisterCandidateLocal(final TestShardPropsCreator shardPropsCreator, Entity entity) {
RegisterCandidateLocal regCandidate = shardPropsCreator.waitForShardMessage();
assertEquals("getEntity", entity, regCandidate.getEntity());
}
- private void verifyEntityOwnershipCandidateRegistration(Entity entity, EntityOwnershipCandidateRegistration reg) {
+ private static void verifyEntityOwnershipCandidateRegistration(Entity entity, EntityOwnershipCandidateRegistration reg) {
assertNotNull("EntityOwnershipCandidateRegistration null", reg);
assertEquals("getInstance", entity, reg.getInstance());
}
verify(listener, never()).ownershipChanged(ownershipChange(entity1));
}
- private void commitModification(TestActorRef<EntityOwnershipShard> shard, NormalizedNode<?, ?> node,
+ private static void commitModification(TestActorRef<EntityOwnershipShard> shard, NormalizedNode<?, ?> node,
JavaTestKit sender) {
BatchedModifications modifications = newBatchedModifications();
modifications.addModification(new MergeModification(ENTITY_OWNERS_PATH, node));
sender.expectMsgClass(CommitTransactionReply.SERIALIZABLE_CLASS);
}
- private BatchedModifications newBatchedModifications() {
+ private static BatchedModifications newBatchedModifications() {
BatchedModifications modifications = new BatchedModifications("tnx", DataStoreVersions.CURRENT_VERSION, "");
modifications.setDoCommitOnReady(true);
modifications.setReady(true);
entityId, candidateName, true);
}
- private void verifyOwner(final TestActorRef<EntityOwnershipShard> shard, String entityType, YangInstanceIdentifier entityId,
- String localMemberName) {
+ private static void verifyOwner(final TestActorRef<EntityOwnershipShard> shard, String entityType,
+ YangInstanceIdentifier entityId, String localMemberName) {
verifyOwner(localMemberName, entityType, entityId, new Function<YangInstanceIdentifier, NormalizedNode<?,?>>() {
@Override
public NormalizedNode<?, ?> apply(YangInstanceIdentifier path) {
SCHEMA_CONTEXT, memberName);
}
- private ShardIdentifier newShardId(String memberName) {
+ private static ShardIdentifier newShardId(String memberName) {
return ShardIdentifier.builder().memberName(memberName).shardName("entity-ownership").
type("operational" + NEXT_SHARD_NUM.getAndIncrement()).build();
}
}};
}
- private <T> T expectFirstMatching(ActorRef actor, Class<T> clazz) {
+ private static <T> T expectFirstMatching(ActorRef actor, Class<T> clazz) {
int count = 5000 / 50;
for(int i = 0; i < count; i++) {
try {
+ @SuppressWarnings("unchecked")
T message = (T) MessageCollectorActor.getFirstMatching(actor, clazz);
if(message != null) {
return message;
Code Review / controller.git / commitdiff