You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by ud...@apache.org on 2018/04/30 21:37:16 UTC
[geode] branch feature/GEODE-5096 updated: GEODE-5096: Reverting
attempt to change tests to use DistributedTestRule
This is an automated email from the ASF dual-hosted git repository.
udo pushed a commit to branch feature/GEODE-5096
in repository https://gitbox.apache.org/repos/asf/geode.git
The following commit(s) were added to refs/heads/feature/GEODE-5096 by this push:
new d75897e GEODE-5096: Reverting attempt to change tests to use DistributedTestRule
d75897e is described below
commit d75897eaf230b72d54fbf6ed9aa39eb9991e43e6
Author: Udo Kohlmeyer <uk...@pivotal.io>
AuthorDate: Mon Apr 30 14:36:48 2018 -0700
GEODE-5096: Reverting attempt to change tests to use DistributedTestRule
---
.../cache/ValidateCacheServerProfileProcessor.java | 45 -------
.../geode/cache/lucene/EvictionDUnitTest.java | 35 +++---
.../geode/cache/lucene/ExpirationDUnitTest.java | 4 +-
.../lucene/LuceneClientSecurityDUnitTest.java | 27 ++---
.../apache/geode/cache/lucene/LuceneDUnitTest.java | 71 +++++------
.../cache/lucene/LuceneIndexCreationDUnitTest.java | 129 ++++++++++----------
.../cache/lucene/LuceneIndexDestroyDUnitTest.java | 116 +++++++++---------
.../cache/lucene/LuceneQueriesAccessorBase.java | 82 +++++--------
.../cache/lucene/LuceneQueriesClientDUnitTest.java | 26 ++--
.../geode/cache/lucene/LuceneQueriesDUnitTest.java | 67 +++++------
.../lucene/LuceneQueriesReindexDUnitTest.java | 78 +++++-------
.../cache/lucene/MixedObjectIndexDUnitTest.java | 34 +++---
.../geode/cache/lucene/PaginationDUnitTest.java | 48 +-------
.../geode/cache/lucene/RebalanceDUnitTest.java | 23 ++--
.../lucene/RebalanceWithRedundancyDUnitTest.java | 38 +++---
...ncyWithRegionCreatedBeforeReindexDUnitTest.java | 131 ++++++++++++++-------
16 files changed, 420 insertions(+), 534 deletions(-)
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/ValidateCacheServerProfileProcessor.java b/geode-core/src/main/java/org/apache/geode/internal/cache/ValidateCacheServerProfileProcessor.java
index 2af38f2..8a67ff5 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/ValidateCacheServerProfileProcessor.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/ValidateCacheServerProfileProcessor.java
@@ -31,7 +31,6 @@ import org.apache.geode.distributed.internal.DistributionAdvisee;
import org.apache.geode.distributed.internal.DistributionAdvisor;
import org.apache.geode.distributed.internal.DistributionAdvisor.Profile;
import org.apache.geode.distributed.internal.DistributionManager;
-import org.apache.geode.distributed.internal.DistributionMessage;
import org.apache.geode.distributed.internal.HighPriorityDistributionMessage;
import org.apache.geode.distributed.internal.MessageWithReply;
import org.apache.geode.distributed.internal.ReplyException;
@@ -152,50 +151,6 @@ public class ValidateCacheServerProfileProcessor {
return Arrays.asList(members);
}
- @Override
- public void process(DistributionMessage msg) {
- try {
- // TODO UDO: Check if something needs to be done here
- ValidateCacheServerProfileReplyMessage validateCacheServerProfileReplyMessage =
- (ValidateCacheServerProfileReplyMessage) msg;
- // if (msg instanceof ProfilesReplyMessage) {
- // ProfilesReplyMessage reply = (ProfilesReplyMessage) msg;
- // if (reply.profiles != null) {
- // Arrays.stream(reply.profiles)
- // .forEach((profile) -> ValidateCacheServerProfileProcessor.this.advisee
- // .getDistributionAdvisor().putProfile(profile));
- // }
- // } else if (msg instanceof ProfileReplyMessage) {
- // ProfileReplyMessage reply = (ProfileReplyMessage) msg;
- // if (reply.profile != null) {
- // if (advisee instanceof LocalRegion && reply.profile instanceof CacheServiceProfile) {
- // LocalRegion localRegion = (LocalRegion) advisee;
- // Map<String, CacheServiceProfile> cacheServiceProfiles =
- // localRegion.getCacheServiceProfiles();
- // CacheServiceProfile
- // cacheServiceProfile =
- // cacheServiceProfiles.get(reply.profile.getId());
- // if (cacheServiceProfile != null) {
- // String result =
- // cacheServiceProfile.checkCompatibility(localRegion.getFullPath(),
- // (CacheServiceProfile) reply.profile);
- // if (result != null) {
- // if (logger.isDebugEnabled()) {
- // logger.debug("{} <replyProfile not set because errorMsg={}", this, result);
- // }
- // ReplyException
- // replyException =
- // new ReplyException(new IllegalStateException(result));
- // reply.setException(replyException);
- // }
- // }
- // }
- // }
- // }
- } finally {
- super.process(msg);
- }
- }
}
public static class ValidateCacheProfileMessage extends HighPriorityDistributionMessage
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/EvictionDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/EvictionDUnitTest.java
index 8aa477f..15bb6d5 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/EvictionDUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/EvictionDUnitTest.java
@@ -18,6 +18,7 @@ import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.INDEX_NAME;
import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.REGION_NAME;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
import java.util.List;
import java.util.concurrent.TimeUnit;
@@ -26,7 +27,6 @@ import java.util.stream.IntStream;
import junitparams.JUnitParamsRunner;
import junitparams.Parameters;
import org.awaitility.Awaitility;
-import org.junit.Before;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.junit.runner.RunWith;
@@ -46,10 +46,10 @@ import org.apache.geode.test.junit.categories.LuceneTest;
@RunWith(JUnitParamsRunner.class)
public class EvictionDUnitTest extends LuceneQueriesAccessorBase {
- private static final float INITIAL_EVICTION_HEAP_PERCENTAGE = 50.9f;
- private static final float EVICTION_HEAP_PERCENTAGE_FAKE_NOTIFICATION = 85.0f;
- private static final int TEST_MAX_MEMORY = 100;
- private static final int MEMORY_USED_FAKE_NOTIFICATION = 90;
+ protected static final float INITIAL_EVICTION_HEAP_PERCENTAGE = 50.9f;
+ protected static final float EVICTION_HEAP_PERCENTAGE_FAKE_NOTIFICATION = 85.0f;
+ protected static final int TEST_MAX_MEMORY = 100;
+ protected static final int MEMORY_USED_FAKE_NOTIFICATION = 90;
protected RegionTestableType[] getPartitionRedundantOverflowEvictionRegionType() {
return new RegionTestableType[] {
@@ -63,13 +63,6 @@ public class EvictionDUnitTest extends LuceneQueriesAccessorBase {
RegionTestableType.PARTITION_PERSISTENT_EVICTION_LOCAL_DESTROY};
}
- @Before
- public void init() {
- dataStore1.invoke(() -> cacheRule.createCache(getDistributedSystemProperties()));
- accessor.invoke(() -> cacheRule.createCache(getDistributedSystemProperties()));
- // dataStore2.invoke(() -> cacheRule.createCache(getDistributedSystemProperties()));
- }
-
@Test
@Parameters(method = "getPartitionRedundantLocalDestroyEvictionRegionType")
public void regionWithEvictionWithLocalDestroyMustNotbeAbleToCreateLuceneIndexes(
@@ -114,16 +107,15 @@ public class EvictionDUnitTest extends LuceneQueriesAccessorBase {
Region region = cache.getRegion(REGION_NAME);
IntStream.range(0, NUM_BUCKETS).forEach(i -> region.put(i, new TestObject("hello world")));
});
-
- accessor.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000));
+ waitForFlushBeforeExecuteTextSearch(accessor, 60000);
dataStore1.invoke(() -> {
try {
getCache().getResourceManager().setEvictionHeapPercentage(INITIAL_EVICTION_HEAP_PERCENTAGE);
- final PartitionedRegion partitionedRegion =
- (PartitionedRegion) getCache().getRegion(REGION_NAME);
+ final PartitionedRegion partitionedRegion = (PartitionedRegion) getRootRegion(REGION_NAME);
raiseFakeNotification();
- Awaitility.await().pollInterval(500, TimeUnit.MILLISECONDS).atMost(120, TimeUnit.SECONDS)
- .until(() -> partitionedRegion.getDiskRegionStats().getNumOverflowOnDisk() > 0);
+ Awaitility.await().atMost(60, TimeUnit.SECONDS).until(() -> {
+ assertTrue(partitionedRegion.getDiskRegionStats().getNumOverflowOnDisk() > 0);
+ });
} finally {
cleanUpAfterFakeNotification();
}
@@ -139,20 +131,21 @@ public class EvictionDUnitTest extends LuceneQueriesAccessorBase {
}
- private void raiseFakeNotification() {
+ protected void raiseFakeNotification() {
((GemFireCacheImpl) getCache()).getHeapEvictor().setTestAbortAfterLoopCount(1);
HeapMemoryMonitor.setTestDisableMemoryUpdates(true);
System.setProperty(DistributionConfig.GEMFIRE_PREFIX + "memoryEventTolerance", "0");
getCache().getResourceManager()
.setEvictionHeapPercentage(EVICTION_HEAP_PERCENTAGE_FAKE_NOTIFICATION);
- HeapMemoryMonitor heapMemoryMonitor = getCache().getInternalResourceManager().getHeapMonitor();
+ HeapMemoryMonitor heapMemoryMonitor =
+ ((GemFireCacheImpl) getCache()).getInternalResourceManager().getHeapMonitor();
heapMemoryMonitor.setTestMaxMemoryBytes(TEST_MAX_MEMORY);
heapMemoryMonitor.updateStateAndSendEvent(MEMORY_USED_FAKE_NOTIFICATION);
}
- private void cleanUpAfterFakeNotification() {
+ protected void cleanUpAfterFakeNotification() {
((GemFireCacheImpl) getCache()).getHeapEvictor().setTestAbortAfterLoopCount(Integer.MAX_VALUE);
HeapMemoryMonitor.setTestDisableMemoryUpdates(false);
System.clearProperty(DistributionConfig.GEMFIRE_PREFIX + "memoryEventTolerance");
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/ExpirationDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/ExpirationDUnitTest.java
index 20b92a0..3e2aab9 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/ExpirationDUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/ExpirationDUnitTest.java
@@ -41,7 +41,7 @@ import org.apache.geode.test.junit.categories.LuceneTest;
@RunWith(JUnitParamsRunner.class)
public class ExpirationDUnitTest extends LuceneQueriesAccessorBase {
- private static final int EXTRA_WAIT_TIME_SEC = 15;
+ protected static final int EXTRA_WAIT_TIME_SEC = 15;
protected RegionTestableType[] getPartitionRegionsWithExpirationSet() {
return new RegionTestableType[] {RegionTestableType.PARTITION_WITH_EXPIRATION_DESTROY,
@@ -68,7 +68,7 @@ public class ExpirationDUnitTest extends LuceneQueriesAccessorBase {
IntStream.range(0, NUM_BUCKETS).forEach(i -> region.put(i, new TestObject("hello world")));
});
- assertTrue(accessor.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
accessor.invoke(() -> Awaitility.await()
.atMost(EXPIRATION_TIMEOUT_SEC + EXTRA_WAIT_TIME_SEC, TimeUnit.SECONDS).until(() -> {
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneClientSecurityDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneClientSecurityDUnitTest.java
index 30ede2a..06cf7c1 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneClientSecurityDUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneClientSecurityDUnitTest.java
@@ -29,8 +29,6 @@ import java.util.concurrent.TimeUnit;
import junitparams.JUnitParamsRunner;
import junitparams.Parameters;
-import org.junit.ClassRule;
-import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.junit.runner.RunWith;
@@ -38,6 +36,7 @@ import org.junit.runner.RunWith;
import org.apache.geode.cache.Cache;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.RegionShortcut;
+import org.apache.geode.cache.client.ClientCache;
import org.apache.geode.cache.client.ClientCacheFactory;
import org.apache.geode.cache.client.ClientRegionShortcut;
import org.apache.geode.cache.client.ServerOperationException;
@@ -46,8 +45,6 @@ import org.apache.geode.distributed.ConfigurationProperties;
import org.apache.geode.security.NotAuthorizedException;
import org.apache.geode.security.SimpleTestSecurityManager;
import org.apache.geode.security.templates.UserPasswordAuthInit;
-import org.apache.geode.test.dunit.rules.ClientCacheRule;
-import org.apache.geode.test.dunit.rules.DistributedTestRule;
import org.apache.geode.test.junit.categories.DistributedTest;
import org.apache.geode.test.junit.categories.LuceneTest;
import org.apache.geode.test.junit.categories.SecurityTest;
@@ -56,19 +53,13 @@ import org.apache.geode.test.junit.categories.SecurityTest;
@RunWith(JUnitParamsRunner.class)
public class LuceneClientSecurityDUnitTest extends LuceneQueriesAccessorBase {
- @ClassRule
- public static DistributedTestRule distributedTestRule = new DistributedTestRule(3);
-
- @Rule
- public ClientCacheRule clientCacheRule = new ClientCacheRule();
-
@Test
@Parameters(method = "getSearchIndexUserNameAndExpectedResponses")
public void verifySearchIndexPermissions(
LuceneCommandsSecurityDUnitTest.UserNameAndExpectedResponse user) {
// Start server
- int serverPort = dataStore1.invoke(this::startCacheServer);
- dataStore1.invoke(this::createRegionIndexAndData);
+ int serverPort = dataStore1.invoke(() -> startCacheServer());
+ dataStore1.invoke(() -> createRegionIndexAndData());
// Start client
accessor.invoke(() -> startClient(user.getUserName(), serverPort));
@@ -91,8 +82,8 @@ public class LuceneClientSecurityDUnitTest extends LuceneQueriesAccessorBase {
props.put(ConfigurationProperties.SERIALIZABLE_OBJECT_FILTER,
"org.apache.geode.cache.lucene.test.TestObject");
props.setProperty(SECURITY_MANAGER, SimpleTestSecurityManager.class.getName());
- cacheRule.createCache(props);
- final CacheServer server = cacheRule.getCache().addCacheServer();
+ final Cache cache = getCache(props);
+ final CacheServer server = cache.addCacheServer();
server.setPort(0);
server.start();
return server.getPort();
@@ -107,14 +98,13 @@ public class LuceneClientSecurityDUnitTest extends LuceneQueriesAccessorBase {
props.setProperty(SECURITY_CLIENT_AUTH_INIT, UserPasswordAuthInit.class.getName());
ClientCacheFactory clientCacheFactory = new ClientCacheFactory(props);
clientCacheFactory.addPoolServer("localhost", serverPort);
- clientCacheRule.createClientCache(clientCacheFactory);
- clientCacheRule.getClientCache().createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY)
- .create(REGION_NAME);
+ ClientCache clientCache = getClientCache(clientCacheFactory);
+ clientCache.createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY).create(REGION_NAME);
}
private void executeTextSearch(boolean expectAuthorizationError, String expectedResponse)
throws LuceneQueryException, InterruptedException {
- LuceneService service = LuceneServiceProvider.get(clientCacheRule.getClientCache());
+ LuceneService service = LuceneServiceProvider.get(getCache());
LuceneQuery<Integer, TestObject> query =
service.createLuceneQueryFactory().create(INDEX_NAME, REGION_NAME, "hello", "field1");
try {
@@ -128,6 +118,7 @@ public class LuceneClientSecurityDUnitTest extends LuceneQueriesAccessorBase {
assertThat(e.getCause()).hasCauseInstanceOf(NotAuthorizedException.class);
}
+
try {
List<LuceneResultStruct<Integer, TestObject>> results = query.findResults();
assertEquals(1, results.size());
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneDUnitTest.java
index 66de6d2..479f884 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneDUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneDUnitTest.java
@@ -16,13 +16,8 @@ package org.apache.geode.cache.lucene;
import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.REGION_NAME;
-import java.io.Serializable;
import java.util.Properties;
-import org.junit.Before;
-import org.junit.ClassRule;
-import org.junit.Rule;
-
import org.apache.geode.cache.Cache;
import org.apache.geode.cache.EvictionAction;
import org.apache.geode.cache.EvictionAttributes;
@@ -34,44 +29,36 @@ import org.apache.geode.cache.Region;
import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.cache.lucene.test.LuceneTestUtilities;
import org.apache.geode.distributed.ConfigurationProperties;
-import org.apache.geode.internal.cache.InternalCache;
import org.apache.geode.test.dunit.Host;
import org.apache.geode.test.dunit.SerializableRunnableIF;
import org.apache.geode.test.dunit.VM;
-import org.apache.geode.test.dunit.rules.CacheRule;
-import org.apache.geode.test.dunit.rules.DistributedTestRule;
+import org.apache.geode.test.dunit.cache.internal.JUnit4CacheTestCase;
-public abstract class LuceneDUnitTest implements Serializable {
- @ClassRule
- public static DistributedTestRule distributedTestRule = new DistributedTestRule(2);
+public abstract class LuceneDUnitTest extends JUnit4CacheTestCase {
+ protected VM dataStore1;
+ protected VM dataStore2;
- @Rule
- public CacheRule cacheRule = new CacheRule();
+ protected static int NUM_BUCKETS = 10;
+ protected static int MAX_ENTRIES_FOR_EVICTION = 20;
+ protected static int EXPIRATION_TIMEOUT_SEC = 5;
- @Before
- public void initialize() {
+ @Override
+ public void postSetUp() throws Exception {
Host host = Host.getHost(0);
dataStore1 = host.getVM(0);
dataStore2 = host.getVM(1);
}
- protected VM dataStore1;
- protected VM dataStore2;
-
- static int NUM_BUCKETS = 10;
- private static int MAX_ENTRIES_FOR_EVICTION = 20;
- static int EXPIRATION_TIMEOUT_SEC = 5;
-
- protected InternalCache getCache() {
- return cacheRule.getCache();
- }
-
protected void initDataStore(SerializableRunnableIF createIndex,
- RegionTestableType regionTestType) throws Exception {
- cacheRule.getOrCreateCache();
+ RegionTestableType regionTestType) throws Exception {
createIndex.run();
regionTestType.createDataStore(getCache(), REGION_NAME);
+ }
+ protected void initAccessor(SerializableRunnableIF createIndex, RegionTestableType regionTestType)
+ throws Exception {
+ createIndex.run();
+ regionTestType.createAccessor(getCache(), REGION_NAME);
}
protected void initDataStore(RegionTestableType regionTestType) throws Exception {
@@ -83,7 +70,7 @@ public abstract class LuceneDUnitTest implements Serializable {
}
protected RegionTestableType[] getListOfRegionTestTypes() {
- return new RegionTestableType[]{RegionTestableType.PARTITION,
+ return new RegionTestableType[] {RegionTestableType.PARTITION,
RegionTestableType.PARTITION_REDUNDANT, RegionTestableType.PARTITION_OVERFLOW_TO_DISK,
RegionTestableType.PARTITION_PERSISTENT, RegionTestableType.FIXED_PARTITION};
}
@@ -92,14 +79,15 @@ public abstract class LuceneDUnitTest implements Serializable {
Object[] parameters = new Object[aValues.length * bValues.length];
for (int i = 0; i < aValues.length; i++) {
for (int j = 0; j < bValues.length; j++) {
- parameters[i * bValues.length + j] = new Object[]{aValues[i], bValues[j]};
+ parameters[i * bValues.length + j] = new Object[] {aValues[i], bValues[j]};
}
}
return parameters;
}
- protected Properties getDistributedSystemProperties() {
- Properties result = new Properties();
+ @Override
+ public Properties getDistributedSystemProperties() {
+ Properties result = super.getDistributedSystemProperties();
result.put(ConfigurationProperties.SERIALIZABLE_OBJECT_FILTER,
"org.apache.geode.cache.lucene.test.TestObject;org.apache.geode.cache.lucene.LuceneQueriesAccessorBase$TestObject"
+ ";org.apache.geode.cache.lucene.LuceneDUnitTest"
@@ -124,16 +112,16 @@ public abstract class LuceneDUnitTest implements Serializable {
EvictionAttributes.createLRUHeapAttributes(null, EvictionAction.OVERFLOW_TO_DISK)),
PARTITION_REDUNDANT_EVICTION_LOCAL_DESTROY(RegionShortcut.PARTITION_PROXY_REDUNDANT,
RegionShortcut.PARTITION_REDUNDANT, EvictionAttributes
- .createLRUEntryAttributes(MAX_ENTRIES_FOR_EVICTION, EvictionAction.LOCAL_DESTROY)),
+ .createLRUEntryAttributes(MAX_ENTRIES_FOR_EVICTION, EvictionAction.LOCAL_DESTROY)),
PARTITION_REDUNDANT_PERSISTENT_EVICTION_LOCAL_DESTROY(RegionShortcut.PARTITION_PROXY_REDUNDANT,
RegionShortcut.PARTITION_REDUNDANT_PERSISTENT, EvictionAttributes
- .createLRUEntryAttributes(MAX_ENTRIES_FOR_EVICTION, EvictionAction.LOCAL_DESTROY)),
+ .createLRUEntryAttributes(MAX_ENTRIES_FOR_EVICTION, EvictionAction.LOCAL_DESTROY)),
PARTITION_EVICTION_LOCAL_DESTROY(RegionShortcut.PARTITION_PROXY, RegionShortcut.PARTITION,
EvictionAttributes.createLRUEntryAttributes(MAX_ENTRIES_FOR_EVICTION,
EvictionAction.LOCAL_DESTROY)),
PARTITION_PERSISTENT_EVICTION_LOCAL_DESTROY(RegionShortcut.PARTITION_PROXY,
RegionShortcut.PARTITION_PERSISTENT, EvictionAttributes
- .createLRUEntryAttributes(MAX_ENTRIES_FOR_EVICTION, EvictionAction.LOCAL_DESTROY)),
+ .createLRUEntryAttributes(MAX_ENTRIES_FOR_EVICTION, EvictionAction.LOCAL_DESTROY)),
PARTITION_REDUNDANT_WITH_EXPIRATION_DESTROY(RegionShortcut.PARTITION_PROXY_REDUNDANT,
RegionShortcut.PARTITION_REDUNDANT, EXPIRATION_TIMEOUT_SEC, ExpirationAction.DESTROY),
PARTITION_WITH_EXPIRATION_DESTROY(RegionShortcut.PARTITION_PROXY, RegionShortcut.PARTITION,
@@ -155,20 +143,19 @@ public abstract class LuceneDUnitTest implements Serializable {
}
RegionTestableType(RegionShortcut clientRegionShortcut, RegionShortcut serverRegionShortcut,
- EvictionAttributes evictionAttributes) {
+ EvictionAttributes evictionAttributes) {
this(clientRegionShortcut, serverRegionShortcut, evictionAttributes, null, NUM_BUCKETS);
}
RegionTestableType(RegionShortcut clientRegionShortcut, RegionShortcut serverRegionShortcut,
- int timeout, ExpirationAction expirationAction) {
+ int timeout, ExpirationAction expirationAction) {
this(clientRegionShortcut, serverRegionShortcut, null,
new ExpirationAttributes(timeout, expirationAction), NUM_BUCKETS);
}
RegionTestableType(RegionShortcut clientRegionShortcut, RegionShortcut serverRegionShortcut,
- EvictionAttributes evictionAttributes,
- ExpirationAttributes expirationAttributes,
- int numBuckets) {
+ EvictionAttributes evictionAttributes, ExpirationAttributes expirationAttributes,
+ int numBuckets) {
this.clientRegionShortcut = clientRegionShortcut;
this.serverRegionShortcut = serverRegionShortcut;
this.evictionAttributes = evictionAttributes;
@@ -217,8 +204,8 @@ public abstract class LuceneDUnitTest implements Serializable {
}
}
- private static PartitionAttributes getPartitionAttributes(final boolean isAccessor,
- final int numBuckets) {
+ protected static PartitionAttributes getPartitionAttributes(final boolean isAccessor,
+ final int numBuckets) {
PartitionAttributesFactory factory = new PartitionAttributesFactory();
if (isAccessor) {
factory.setLocalMaxMemory(0);
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneIndexCreationDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneIndexCreationDUnitTest.java
index 0a40a95..7f178ff 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneIndexCreationDUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneIndexCreationDUnitTest.java
@@ -43,7 +43,6 @@ import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.core.KeywordAnalyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.hamcrest.Matchers;
-import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
@@ -77,7 +76,7 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
}
protected Object[] parametersForIndexAndRegions() {
- Object[] indexCreations = new Object[]{getFieldsIndexWithOneField(),
+ Object[] indexCreations = new Object[] {getFieldsIndexWithOneField(),
getFieldsIndexWithTwoFields(), get2FieldsIndexes(), getAnalyzersIndexWithOneField(),
getAnalyzersIndexWithTwoFields(), getAnalyzersIndexWithNullField1()};
RegionTestableType[] regionTestTypes = getListOfRegionTestTypes();
@@ -87,7 +86,7 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
@Test
@Parameters(method = "parametersForMultipleIndexCreates")
public void verifyThatIndexObjectsAreListedWhenPresentInTheSystem(int numberOfIndexes,
- RegionTestableType regionType) {
+ RegionTestableType regionType) {
SerializableRunnableIF createIndex = getMultipleIndexes(numberOfIndexes);
dataStore1.invoke(() -> initDataStore(createIndex, regionType));
dataStore1.invoke(() -> verifyIndexList(numberOfIndexes));
@@ -99,7 +98,7 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
@Test
@Parameters(method = "parametersForMultipleIndexCreates")
public void verifyThatIndexObjectIsRetrievedWhenPresentInTheSystem(int numberOfIndexes,
- RegionTestableType regionType) {
+ RegionTestableType regionType) {
SerializableRunnableIF createIndex = getMultipleIndexes(numberOfIndexes);
dataStore1.invoke(() -> initDataStore(createIndex, regionType));
dataStore1.invoke(() -> verifyIndexes(numberOfIndexes));
@@ -117,13 +116,11 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
@Test
public void verifyNullIsReturnedWhenGetIndexIsCalledAndNoIndexesArePresent() {
dataStore1.invoke(() -> {
- cacheRule.createCache();
LuceneService luceneService = LuceneServiceProvider.get(getCache());
assertNull(luceneService.getIndex(INDEX_NAME, REGION_NAME));
});
dataStore2.invoke(() -> {
- cacheRule.createCache();
LuceneService luceneService = LuceneServiceProvider.get(getCache());
assertNull(luceneService.getIndex(INDEX_NAME, REGION_NAME));
});
@@ -236,8 +233,7 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
dataStore1.invoke(() -> initDataStore(createIndex1, regionType));
SerializableRunnableIF createIndex2 = () -> {
- /* Do nothing */
- };
+ /* Do nothing */};
dataStore2.invoke(() -> initDataStore(createIndex2, regionType,
CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_INDEXES_1));
}
@@ -261,7 +257,9 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
@Test
@Parameters({"PARTITION"})
public void verifyMemberWithoutIndexCreatedFirstFails(RegionTestableType regionType) {
- dataStore1.invoke(() -> initDataStore(() -> {}, regionType));
+ SerializableRunnableIF createIndex1 = () -> {
+ /* Do nothing */};
+ dataStore1.invoke(() -> initDataStore(createIndex1, regionType));
SerializableRunnableIF createIndex2 = getFieldsIndexWithOneField();
dataStore2.invoke(() -> initDataStore(createIndex2, regionType,
@@ -271,7 +269,7 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
@Test
@Parameters(method = "parametersForIndexAndRegions")
public void verifySameIndexesSucceeds(SerializableRunnableIF createIndex,
- RegionTestableType regionType) {
+ RegionTestableType regionType) {
dataStore1.invoke(() -> initDataStore(createIndex, regionType));
dataStore2.invoke(() -> initDataStore(createIndex, regionType));
}
@@ -281,17 +279,17 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
public void creatingIndexAfterRegionAndStartingUpSecondMemberSucceeds(
RegionTestableType regionType) {
dataStore1.invoke(() -> {
- cacheRule.createCache(getDistributedSystemProperties());
regionType.createDataStore(getCache(), REGION_NAME);
createIndexAfterRegion("field1");
});
dataStore2.invoke(() -> {
- cacheRule.createCache(getDistributedSystemProperties());
createIndexAfterRegion("field1");
regionType.createDataStore(getCache(), REGION_NAME);
});
- dataStore1.invoke(this::putEntryAndQuery);
+ dataStore1.invoke(() -> {
+ putEntryAndQuery();
+ });
}
@Test()
@@ -299,38 +297,40 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
public void creatingIndexAfterRegionAndStartingUpSecondMemberWithoutIndexFails(
RegionTestableType regionType) {
dataStore1.invoke(() -> {
- cacheRule.createCache(getDistributedSystemProperties());
regionType.createDataStore(getCache(), REGION_NAME);
createIndexAfterRegion("field1");
});
expectedException.expectCause(Matchers.instanceOf(IllegalStateException.class));
dataStore2.invoke(() -> {
- cacheRule.createCache(getDistributedSystemProperties());
regionType.createDataStore(getCache(), REGION_NAME);
createIndexAfterRegion("field1");
});
- dataStore1.invoke(this::putEntryAndQuery);
+ dataStore1.invoke(() -> {
+ putEntryAndQuery();
+ });
}
@Test
@Parameters({"PARTITION", "PARTITION_REDUNDANT"})
public void creatingIndexAfterRegionInTwoMembersSucceed(RegionTestableType regionType)
- throws InterruptedException {
+ throws Exception {
dataStore1.invoke(() -> {
- cacheRule.createCache(getDistributedSystemProperties());
regionType.createDataStore(getCache(), REGION_NAME);
});
dataStore2.invoke(() -> {
- cacheRule.createCache(getDistributedSystemProperties());
regionType.createDataStore(getCache(), REGION_NAME);
});
- AsyncInvocation createIndex1 = dataStore1.invokeAsync(() -> createIndexAfterRegion("field1"));
+ AsyncInvocation createIndex1 = dataStore1.invokeAsync(() -> {
+ createIndexAfterRegion("field1");
+ });
- AsyncInvocation createIndex2 = dataStore2.invokeAsync(() -> createIndexAfterRegion("field1"));
+ AsyncInvocation createIndex2 = dataStore2.invokeAsync(() -> {
+ createIndexAfterRegion("field1");
+ });
createIndex1.join();
createIndex2.join();
@@ -338,7 +338,9 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
createIndex1.checkException();
createIndex2.checkException();
- dataStore1.invoke(this::putEntryAndQuery);
+ dataStore1.invoke(() -> {
+ putEntryAndQuery();
+ });
}
@Test
@@ -377,18 +379,24 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
}
protected Object[] getXmlAndExceptionMessages() {
- return new Object[]{
- new Object[]{"verifyDifferentFieldsFails", CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_FIELDS},
- new Object[]{"verifyDifferentFieldAnalyzerSizesFails1",
+ return new Object[] {
+ new Object[] {"verifyDifferentFieldsFails", CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_FIELDS},
+ new Object[] {"verifyDifferentFieldAnalyzerSizesFails1",
CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_FIELDS_2},
- new Object[]{"verifyDifferentFieldAnalyzerSizesFails2",
+ new Object[] {"verifyDifferentFieldAnalyzerSizesFails2",
CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_FIELDS},
- new Object[]{"verifyDifferentFieldAnalyzersFails1",
+ new Object[] {"verifyDifferentFieldAnalyzersFails1",
CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_ANALYZERS_2},
- new Object[]{"verifyDifferentIndexNamesFails", CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_NAMES},
- new Object[]{"verifyDifferentIndexesFails1",
+ // Currently setting a null analyzer is not a valid xml configuration: <lucene:field
+ // name="field2" analyzer="null"/>
+ // new Object[] { "verifyDifferentFieldAnalyzersFails2",
+ // CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_ANALYZERS_1 },
+ // new Object[] { "verifyDifferentFieldAnalyzersFails3",
+ // CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_ANALYZERS_2 },
+ new Object[] {"verifyDifferentIndexNamesFails", CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_NAMES},
+ new Object[] {"verifyDifferentIndexesFails1",
CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_INDEXES_1},
- new Object[]{"verifyDifferentIndexesFails2",
+ new Object[] {"verifyDifferentIndexesFails2",
CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_INDEXES_2}};
}
@@ -412,7 +420,6 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
dataStore2.invoke(() -> initDataStore(createIndex2, regionType));
}
- @Test
@Parameters("PARTITION")
public void verifyDifferentSerializerShouldFail(RegionTestableType regionType) {
SerializableRunnableIF createIndex1 = getIndexWithDefaultSerializer();
@@ -444,7 +451,7 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
// Attempt to create a Cache in dataStore2 with a PR defining 20 buckets. This will fail.
String exceptionMessage =
LocalizedStrings.PartitionedRegion_THE_TOTAL_NUMBER_OF_BUCKETS_FOUND_IN_PARTITIONATTRIBUTES_0_IS_INCOMPATIBLE_WITH_THE_TOTAL_NUMBER_OF_BUCKETS_USED_BY_OTHER_DISTRIBUTED_MEMBERS_SET_THE_NUMBER_OF_BUCKETS_TO_1
- .toLocalizedString(NUM_BUCKETS * 2, NUM_BUCKETS);
+ .toLocalizedString(new Object[] {NUM_BUCKETS * 2, NUM_BUCKETS});
dataStore2.invoke(() -> initDataStore(createIndex,
RegionTestableType.PARTITION_WITH_DOUBLE_BUCKETS, exceptionMessage));
@@ -461,7 +468,7 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
dataStore2.invoke(() -> verifyAsyncEventQueues(2));
}
- private String getXmlFileForTest(String testName) {
+ protected String getXmlFileForTest(String testName) {
return TestUtil.getResourcePath(getClass(),
getClassSimpleName() + "." + testName + ".cache.xml");
}
@@ -471,8 +478,7 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
}
protected void initDataStore(SerializableRunnableIF createIndex, RegionTestableType regionType,
- String message) throws Exception {
- cacheRule.createCache();
+ String message) throws Exception {
createIndex.run();
try {
regionType.createDataStore(getCache(), REGION_NAME);
@@ -482,14 +488,12 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
}
}
- private void initCache(String cacheXmlFileName) throws FileNotFoundException {
- cacheRule.createCache();
+ protected void initCache(String cacheXmlFileName) throws FileNotFoundException {
getCache().loadCacheXml(new FileInputStream(cacheXmlFileName));
}
- private void initCache(String cacheXmlFileName, String message) throws FileNotFoundException {
+ protected void initCache(String cacheXmlFileName, String message) throws FileNotFoundException {
try {
- cacheRule.createCache();
getCache().loadCacheXml(new FileInputStream(cacheXmlFileName));
fail("Should not have been able to create cache");
} catch (IllegalStateException e) {
@@ -497,14 +501,14 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
}
}
- private SerializableRunnableIF getFieldsIndexWithOneField() {
+ protected SerializableRunnableIF getFieldsIndexWithOneField() {
return () -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
luceneService.createIndexFactory().addField("field1").create(INDEX_NAME, REGION_NAME);
};
}
- private SerializableRunnableIF getFieldsIndexWithTwoFields() {
+ protected SerializableRunnableIF getFieldsIndexWithTwoFields() {
return () -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
luceneService.createIndexFactory().addField("field1").addField("field2").create(INDEX_NAME,
@@ -512,7 +516,7 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
};
}
- private SerializableRunnableIF get2FieldsIndexes() {
+ protected SerializableRunnableIF get2FieldsIndexes() {
return () -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
luceneService.createIndexFactory().addField("field1").create(INDEX_NAME + "_1", REGION_NAME);
@@ -520,7 +524,7 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
};
}
- private SerializableRunnableIF getMultipleIndexes(final int numberOfIndexes) {
+ protected SerializableRunnableIF getMultipleIndexes(final int numberOfIndexes) {
return () -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
for (int count = 1; count <= numberOfIndexes; count++) {
@@ -530,13 +534,13 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
};
}
- private void verifyIndexList(final int expectedSize) {
+ protected void verifyIndexList(final int expectedSize) {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
Collection<LuceneIndex> indexList = luceneService.getAllIndexes();
assertEquals(expectedSize, indexList.size());
}
- private void verifyIndexes(final int numberOfIndexes) {
+ protected void verifyIndexes(final int numberOfIndexes) {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
for (int count = 1; count <= numberOfIndexes; count++) {
assertEquals(INDEX_NAME + "_" + count,
@@ -544,7 +548,7 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
}
}
- private SerializableRunnableIF getAnalyzersIndexWithNullField1() {
+ protected SerializableRunnableIF getAnalyzersIndexWithNullField1() {
return () -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
Map<String, Analyzer> analyzers = new HashMap<>();
@@ -554,7 +558,7 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
};
}
- private SerializableRunnableIF getAnalyzersIndexWithNullField2() {
+ protected SerializableRunnableIF getAnalyzersIndexWithNullField2() {
return () -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
Map<String, Analyzer> analyzers = new HashMap<>();
@@ -564,7 +568,7 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
};
}
- private SerializableRunnableIF getAnalyzersIndexWithOneField(
+ protected SerializableRunnableIF getAnalyzersIndexWithOneField(
Class<? extends Analyzer> analyzerClass) {
return () -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
@@ -574,7 +578,7 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
};
}
- private SerializableRunnableIF getAnalyzersIndexWithOneField() {
+ protected SerializableRunnableIF getAnalyzersIndexWithOneField() {
return () -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
Map<String, Analyzer> analyzers = new HashMap<>();
@@ -583,7 +587,7 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
};
}
- private SerializableRunnableIF getAnalyzersIndexWithTwoFields() {
+ protected SerializableRunnableIF getAnalyzersIndexWithTwoFields() {
return () -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
Map<String, Analyzer> analyzers = new HashMap<>();
@@ -593,7 +597,7 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
};
}
- private SerializableRunnableIF getAnalyzersIndexWithTwoFields2() {
+ protected SerializableRunnableIF getAnalyzersIndexWithTwoFields2() {
return () -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
Map<String, Analyzer> analyzers = new HashMap<>();
@@ -603,42 +607,43 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
};
}
- private SerializableRunnableIF getIndexWithDummySerializer() {
+ protected SerializableRunnableIF getIndexWithDummySerializer() {
return () -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
- luceneService.createIndexFactory().setFields("field1", "field2")
+ luceneService.createIndexFactory().setFields(new String[] {"field1", "field2"})
.setLuceneSerializer(new DummyLuceneSerializer()).create(INDEX_NAME, REGION_NAME);
};
}
- private SerializableRunnableIF getIndexWithDefaultSerializer() {
+ protected SerializableRunnableIF getIndexWithDefaultSerializer() {
return () -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
- luceneService.createIndexFactory().setFields("field1", "field2").create(INDEX_NAME,
- REGION_NAME);
+ luceneService.createIndexFactory().setFields(new String[] {"field1", "field2"})
+ .create(INDEX_NAME, REGION_NAME);
};
}
- private SerializableRunnableIF getHeterogeneousLuceneSerializerCreationProfile() {
+ protected SerializableRunnableIF getHeterogeneousLuceneSerializerCreationProfile() {
return () -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
- luceneService.createIndexFactory().setFields("field1", "field2")
+ luceneService.createIndexFactory().setFields(new String[] {"field1", "field2"})
.setLuceneSerializer(new HeterogeneousLuceneSerializer()).create(INDEX_NAME, REGION_NAME);
};
}
- protected void initDataStore(RegionTestableType regionTestType) {
+ protected void initDataStore(RegionTestableType regionTestType) throws Exception {
regionTestType.createDataStore(getCache(), REGION_NAME);
}
- private void verifyAsyncEventQueues(final int expectedSize) {
+ protected void verifyAsyncEventQueues(final int expectedSize) {
assertEquals(expectedSize, getCache().getAsyncEventQueues(false).size());
}
private void createIndexAfterRegion(String... fields) {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
- ((LuceneIndexFactoryImpl) luceneService.createIndexFactory())
- .setFields(fields).create(INDEX_NAME, REGION_NAME, true);
+ LuceneIndexFactoryImpl indexFactory =
+ (LuceneIndexFactoryImpl) luceneService.createIndexFactory();
+ indexFactory.setFields(fields).create(INDEX_NAME, REGION_NAME, true);
}
private void putEntryAndQuery() throws InterruptedException, LuceneQueryException {
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneIndexDestroyDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneIndexDestroyDUnitTest.java
index 920b21c..83541a0 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneIndexDestroyDUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneIndexDestroyDUnitTest.java
@@ -30,8 +30,6 @@ import java.util.concurrent.TimeUnit;
import junitparams.JUnitParamsRunner;
import junitparams.Parameters;
import org.awaitility.Awaitility;
-import org.junit.Before;
-import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.junit.runner.RunWith;
@@ -51,7 +49,6 @@ import org.apache.geode.test.dunit.IgnoredException;
import org.apache.geode.test.dunit.SerializableRunnableIF;
import org.apache.geode.test.dunit.ThreadUtils;
import org.apache.geode.test.dunit.VM;
-import org.apache.geode.test.dunit.rules.DistributedDiskDirRule;
import org.apache.geode.test.junit.categories.DistributedTest;
import org.apache.geode.test.junit.categories.LuceneTest;
@@ -60,26 +57,23 @@ import org.apache.geode.test.junit.categories.LuceneTest;
public class LuceneIndexDestroyDUnitTest extends LuceneDUnitTest {
private static final String INDEX1_NAME = INDEX_NAME + "1";
+
private static final String INDEX2_NAME = INDEX_NAME + "2";
+
private static volatile boolean STOP_PUTS = false;
+
private static volatile boolean STOP_QUERIES = false;
+
private static int NUM_PUTS_COMPLETED = 0;
+
private static int NUM_QUERIES_COMPLETED = 0;
- protected VM accessor;
- @Rule
- public DistributedDiskDirRule distributedDiskDirRule = new DistributedDiskDirRule();
+ protected VM accessor;
- @Before
+ @Override
public void postSetUp() throws Exception {
- accessor = Host.getHost(0).getVM(2);
- accessor.invoke(() -> cacheRule.createCache(getDistributedSystemProperties()));
- }
-
- protected void initAccessor(SerializableRunnableIF createIndex, RegionTestableType regionTestType)
- throws Exception {
- createIndex.run();
- regionTestType.createAccessor(getCache(), REGION_NAME);
+ super.postSetUp();
+ accessor = Host.getHost(0).getVM(3);
}
private Object[] parametersForIndexDestroys() {
@@ -96,8 +90,8 @@ public class LuceneIndexDestroyDUnitTest extends LuceneDUnitTest {
dataStore2.invoke(() -> initDataStore(createIndex(), regionType));
// Verify index created
- dataStore1.invoke(this::verifyIndexCreated);
- dataStore2.invoke(this::verifyIndexCreated);
+ dataStore1.invoke(() -> verifyIndexCreated());
+ dataStore2.invoke(() -> verifyIndexCreated());
// Attempt to destroy data region (should fail)
if (destroyDataRegion) {
@@ -105,11 +99,11 @@ public class LuceneIndexDestroyDUnitTest extends LuceneDUnitTest {
}
// Destroy index (only needs to be done on one member)
- dataStore1.invoke(this::destroyIndex);
+ dataStore1.invoke(() -> destroyIndex());
// Verify index destroyed
- dataStore1.invoke((SerializableRunnableIF) this::verifyIndexDestroyed);
- dataStore2.invoke((SerializableRunnableIF) this::verifyIndexDestroyed);
+ dataStore1.invoke(() -> verifyIndexDestroyed());
+ dataStore2.invoke(() -> verifyIndexDestroyed());
// Attempt to destroy data region (should succeed)
if (destroyDataRegion) {
@@ -125,8 +119,8 @@ public class LuceneIndexDestroyDUnitTest extends LuceneDUnitTest {
dataStore2.invoke(() -> initDataStore(createIndexes(), regionType));
// Verify indexes created
- dataStore1.invoke(this::verifyIndexesCreated);
- dataStore2.invoke(this::verifyIndexesCreated);
+ dataStore1.invoke(() -> verifyIndexesCreated());
+ dataStore2.invoke(() -> verifyIndexesCreated());
// Attempt to destroy data region (should fail)
if (destroyDataRegion) {
@@ -134,11 +128,11 @@ public class LuceneIndexDestroyDUnitTest extends LuceneDUnitTest {
}
// Destroy indexes (only needs to be done on one member)
- dataStore1.invoke(this::destroyIndexes);
+ dataStore1.invoke(() -> destroyIndexes());
// Verify indexes destroyed
- dataStore1.invoke(this::verifyIndexesDestroyed);
- dataStore2.invoke(this::verifyIndexesDestroyed);
+ dataStore1.invoke(() -> verifyIndexesDestroyed());
+ dataStore2.invoke(() -> verifyIndexesDestroyed());
// Attempt to destroy data region (should succeed)
if (destroyDataRegion) {
@@ -158,24 +152,24 @@ public class LuceneIndexDestroyDUnitTest extends LuceneDUnitTest {
dataStore2.invoke(() -> initDataStore(createIndex(), regionType));
// Verify index created
- dataStore1.invoke(this::verifyIndexCreated);
- dataStore2.invoke(this::verifyIndexCreated);
+ dataStore1.invoke(() -> verifyIndexCreated());
+ dataStore2.invoke(() -> verifyIndexCreated());
// Start puts
- AsyncInvocation putter = dataStore1.invokeAsync(this::doPutsUntilStopped);
+ AsyncInvocation putter = dataStore1.invokeAsync(() -> doPutsUntilStopped());
// Wait until puts have started
- dataStore1.invoke(this::waitUntilPutsHaveStarted);
+ dataStore1.invoke(() -> waitUntilPutsHaveStarted());
// Destroy index (only needs to be done on one member)
- dataStore1.invoke(this::destroyIndex);
+ dataStore1.invoke(() -> destroyIndex());
// Verify index destroyed
- dataStore1.invoke((SerializableRunnableIF) this::verifyIndexDestroyed);
- dataStore2.invoke((SerializableRunnableIF) this::verifyIndexDestroyed);
+ dataStore1.invoke(() -> verifyIndexDestroyed());
+ dataStore2.invoke(() -> verifyIndexDestroyed());
// End puts
- dataStore1.invoke(LuceneIndexDestroyDUnitTest::stopPuts);
+ dataStore1.invoke(() -> stopPuts());
// Wait for the putter to complete and verify no exception has occurred
ThreadUtils.join(putter, 60 * 1000);
@@ -184,7 +178,7 @@ public class LuceneIndexDestroyDUnitTest extends LuceneDUnitTest {
}
// Verify region size
- dataStore1.invoke(this::verifyRegionSize);
+ dataStore1.invoke(() -> verifyRegionSize());
}
@Test
@@ -199,24 +193,24 @@ public class LuceneIndexDestroyDUnitTest extends LuceneDUnitTest {
dataStore2.invoke(() -> initDataStore(createIndexes(), regionType));
// Verify indexes created
- dataStore1.invoke(this::verifyIndexesCreated);
- dataStore2.invoke(this::verifyIndexesCreated);
+ dataStore1.invoke(() -> verifyIndexesCreated());
+ dataStore2.invoke(() -> verifyIndexesCreated());
// Start puts
- AsyncInvocation putter = dataStore1.invokeAsync(this::doPutsUntilStopped);
+ AsyncInvocation putter = dataStore1.invokeAsync(() -> doPutsUntilStopped());
// Wait until puts have started
- dataStore1.invoke(this::waitUntilPutsHaveStarted);
+ dataStore1.invoke(() -> waitUntilPutsHaveStarted());
// Destroy indexes (only needs to be done on one member)
- dataStore1.invoke(this::destroyIndexes);
+ dataStore1.invoke(() -> destroyIndexes());
// Verify indexes destroyed
- dataStore1.invoke(this::verifyIndexesDestroyed);
- dataStore2.invoke(this::verifyIndexesDestroyed);
+ dataStore1.invoke(() -> verifyIndexesDestroyed());
+ dataStore2.invoke(() -> verifyIndexesDestroyed());
// End puts
- dataStore1.invoke(LuceneIndexDestroyDUnitTest::stopPuts);
+ dataStore1.invoke(() -> stopPuts());
// Wait for the putter to complete and verify no unexpected exception has occurred
ThreadUtils.join(putter, 60 * 1000);
@@ -225,7 +219,7 @@ public class LuceneIndexDestroyDUnitTest extends LuceneDUnitTest {
}
// Verify region size
- dataStore1.invoke(this::verifyRegionSize);
+ dataStore1.invoke(() -> verifyRegionSize());
}
@Test
@@ -239,9 +233,9 @@ public class LuceneIndexDestroyDUnitTest extends LuceneDUnitTest {
accessor.invoke(() -> initAccessor(createIndex, regionType));
// Verify index created
- dataStore1.invoke(this::verifyIndexCreated);
- dataStore2.invoke(this::verifyIndexCreated);
- accessor.invoke(this::verifyIndexCreated);
+ dataStore1.invoke(() -> verifyIndexCreated());
+ dataStore2.invoke(() -> verifyIndexCreated());
+ accessor.invoke(() -> verifyIndexCreated());
// Do puts
int numPuts = 100;
@@ -255,15 +249,15 @@ public class LuceneIndexDestroyDUnitTest extends LuceneDUnitTest {
.invokeAsync(() -> doQueriesUntilException(INDEX_NAME, "field1Value", "field1", numPuts));
// Wait until queries have started
- accessor.invoke(this::waitUntilQueriesHaveStarted);
+ accessor.invoke(() -> waitUntilQueriesHaveStarted());
// Destroy index (only needs to be done on one member)
- accessor.invoke(this::destroyIndex);
+ accessor.invoke(() -> destroyIndex());
// Verify index destroyed
- dataStore1.invoke((SerializableRunnableIF) this::verifyIndexDestroyed);
- dataStore2.invoke((SerializableRunnableIF) this::verifyIndexDestroyed);
- accessor.invoke((SerializableRunnableIF) this::verifyIndexDestroyed);
+ dataStore1.invoke(() -> verifyIndexDestroyed());
+ dataStore2.invoke(() -> verifyIndexDestroyed());
+ accessor.invoke(() -> verifyIndexDestroyed());
// Wait for the querier to complete and verify no exception has occurred
ThreadUtils.join(querier, 60 * 1000);
@@ -283,8 +277,8 @@ public class LuceneIndexDestroyDUnitTest extends LuceneDUnitTest {
accessor.invoke(() -> initAccessor(createIndexes, regionType));
// Verify indexes created
- dataStore1.invoke(this::verifyIndexesCreated);
- dataStore2.invoke(this::verifyIndexesCreated);
+ dataStore1.invoke(() -> verifyIndexesCreated());
+ dataStore2.invoke(() -> verifyIndexesCreated());
accessor.invoke(() -> verifyIndexesCreated());
// Do puts
@@ -436,9 +430,9 @@ public class LuceneIndexDestroyDUnitTest extends LuceneDUnitTest {
accessor.invoke(() -> initAccessor(createIndex, regionType));
// Verify index created
- dataStore1.invoke(this::verifyIndexCreated);
- dataStore2.invoke(this::verifyIndexCreated);
- accessor.invoke(this::verifyIndexCreated);
+ dataStore1.invoke(() -> verifyIndexCreated());
+ dataStore2.invoke(() -> verifyIndexCreated());
+ accessor.invoke(() -> verifyIndexCreated());
// Do puts to cause IndexRepositories to be created
int numPuts = 1000;
@@ -454,11 +448,11 @@ public class LuceneIndexDestroyDUnitTest extends LuceneDUnitTest {
accessor.invoke(() -> exportData(regionType));
// Destroy indexes (only needs to be done on one member)
- dataStore1.invoke(this::destroyIndexes);
+ dataStore1.invoke(() -> destroyIndexes());
// Verify indexes destroyed
- dataStore1.invoke(this::verifyIndexesDestroyed);
- dataStore2.invoke(this::verifyIndexesDestroyed);
+ dataStore1.invoke(() -> verifyIndexesDestroyed());
+ dataStore2.invoke(() -> verifyIndexesDestroyed());
// Destroy data region
dataStore1.invoke(() -> destroyDataRegion(true));
@@ -684,7 +678,7 @@ public class LuceneIndexDestroyDUnitTest extends LuceneDUnitTest {
private void exportData(RegionTestableType regionType) throws Exception {
Region region = getCache().getRegion(REGION_NAME);
RegionSnapshotService service = region.getSnapshotService();
- service.save(getSnapshotFile(distributedDiskDirRule.getDiskDirFor(VM.getVM(0)), regionType),
+ service.save(getSnapshotFile(getDiskDirs()[0], regionType),
SnapshotOptions.SnapshotFormat.GEMFIRE);
}
@@ -693,7 +687,7 @@ public class LuceneIndexDestroyDUnitTest extends LuceneDUnitTest {
RegionSnapshotService service = region.getSnapshotService();
SnapshotOptions options = service.createOptions();
options.invokeCallbacks(true);
- service.load(getSnapshotFile(distributedDiskDirRule.getDiskDirFor(VM.getVM(0)), regionType),
+ service.load(getSnapshotFile(getDiskDirs()[0], regionType),
SnapshotOptions.SnapshotFormat.GEMFIRE, options);
assertEquals(expectedRegionSize, region.size());
}
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesAccessorBase.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesAccessorBase.java
index 59d2a8f..c7ac4a7 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesAccessorBase.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesAccessorBase.java
@@ -33,12 +33,8 @@ import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
-import org.junit.Before;
-import org.junit.ClassRule;
-
import org.apache.geode.DataSerializable;
import org.apache.geode.cache.Cache;
-import org.apache.geode.cache.GemFireCache;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.control.RebalanceOperation;
import org.apache.geode.cache.control.RebalanceResults;
@@ -53,48 +49,37 @@ import org.apache.geode.internal.cache.PartitionedRegion;
import org.apache.geode.internal.cache.partitioned.BecomePrimaryBucketMessage;
import org.apache.geode.internal.cache.partitioned.BecomePrimaryBucketMessage.BecomePrimaryBucketResponse;
import org.apache.geode.test.dunit.Host;
-import org.apache.geode.test.dunit.SerializableRunnableIF;
import org.apache.geode.test.dunit.VM;
-import org.apache.geode.test.dunit.rules.DistributedTestRule;
public class LuceneQueriesAccessorBase extends LuceneDUnitTest {
- @ClassRule
- public static DistributedTestRule distributedTestRule = new DistributedTestRule(3);
-
protected VM accessor;
- @Before
+ @Override
public void postSetUp() throws Exception {
- accessor = Host.getHost(0).getVM(2);
+ super.postSetUp();
+ accessor = Host.getHost(0).getVM(3);
}
- protected void initAccessor(SerializableRunnableIF createIndex, RegionTestableType regionTestType)
- throws Exception {
- createIndex.run();
- regionTestType.createAccessor((Cache) getAccessorCache(), REGION_NAME);
- }
-
- protected void putDataInRegion() {
- final Cache cache = (Cache) getAccessorCache();
- Region<Object, Object> region = cache.getRegion(REGION_NAME);
- region.put(1, new TestObject("hello world"));
- region.put(113, new TestObject("hi world"));
- region.put(2, new TestObject("goodbye world"));
+ protected void putDataInRegion(VM vm) {
+ vm.invoke(() -> {
+ final Cache cache = getCache();
+ Region<Object, Object> region = cache.getRegion(REGION_NAME);
+ region.put(1, new TestObject("hello world"));
+ region.put(113, new TestObject("hi world"));
+ region.put(2, new TestObject("goodbye world"));
+ });
}
- protected boolean waitForFlushBeforeExecuteTextSearch(int timeoutInMillis)
- throws InterruptedException {
- return waitForFlushBeforeExecuteTextSearch(getCache(), timeoutInMillis);
- }
+ protected boolean waitForFlushBeforeExecuteTextSearch(VM vm, int ms) {
+ return vm.invoke(() -> {
+ Cache cache = getCache();
- protected boolean waitForFlushBeforeExecuteTextSearch(Cache cache, int timeoutInMillis)
- throws InterruptedException {
- LuceneService service = LuceneServiceProvider.get(cache);
- LuceneIndexImpl index = (LuceneIndexImpl) service.getIndex(INDEX_NAME, REGION_NAME);
+ LuceneService service = LuceneServiceProvider.get(cache);
+ LuceneIndexImpl index = (LuceneIndexImpl) service.getIndex(INDEX_NAME, REGION_NAME);
- return service.waitUntilFlushed(INDEX_NAME, REGION_NAME, timeoutInMillis,
- TimeUnit.MILLISECONDS);
+ return service.waitUntilFlushed(INDEX_NAME, REGION_NAME, ms, TimeUnit.MILLISECONDS);
+ });
}
protected void executeTextSearch(VM vm) {
@@ -145,7 +130,7 @@ public class LuceneQueriesAccessorBase extends LuceneDUnitTest {
query = service.createLuceneQueryFactory().setLimit(1000).setPageSize(1000).create(INDEX_NAME,
REGION_NAME, queryString, defaultField);
try {
- query.findKeys();
+ Collection<?> results = query.findKeys();
fail("Query " + defaultField + ":" + queryString + " should not have succeeded");
} catch (Exception e) {
assertEquals(expctedExceptionClass, e.getClass());
@@ -201,10 +186,12 @@ public class LuceneQueriesAccessorBase extends LuceneDUnitTest {
assertTrue(response.waitForResponse());
}
- protected void removeCallback() {
- IndexRepositorySpy.remove();
- InitialImageOperation.resetAllGIITestHooks();
- LuceneIndexFactorySpy.remove();
+ protected void removeCallback(VM vm) {
+ vm.invoke(() -> {
+ IndexRepositorySpy.remove();
+ InitialImageOperation.resetAllGIITestHooks();
+ LuceneIndexFactorySpy.remove();
+ });
}
protected void rebalanceRegion(VM vm) {
@@ -215,10 +202,6 @@ public class LuceneQueriesAccessorBase extends LuceneDUnitTest {
});
}
- protected GemFireCache getAccessorCache() {
- return cacheRule.getCache();
- }
-
protected static class TestObject implements DataSerializable {
private static final long serialVersionUID = 1L;
private String text;
@@ -239,23 +222,18 @@ public class LuceneQueriesAccessorBase extends LuceneDUnitTest {
@Override
public boolean equals(Object obj) {
- if (this == obj) {
+ if (this == obj)
return true;
- }
- if (obj == null) {
+ if (obj == null)
return false;
- }
- if (getClass() != obj.getClass()) {
+ if (getClass() != obj.getClass())
return false;
- }
TestObject other = (TestObject) obj;
if (text == null) {
- if (other.text != null) {
+ if (other.text != null)
return false;
- }
- } else if (!text.equals(other.text)) {
+ } else if (!text.equals(other.text))
return false;
- }
return true;
}
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesClientDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesClientDUnitTest.java
index cb0d490..6464471 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesClientDUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesClientDUnitTest.java
@@ -17,19 +17,16 @@ package org.apache.geode.cache.lucene;
import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.REGION_NAME;
import junitparams.JUnitParamsRunner;
-import org.junit.Before;
-import org.junit.Rule;
import org.junit.experimental.categories.Category;
import org.junit.runner.RunWith;
import org.apache.geode.cache.Cache;
-import org.apache.geode.cache.GemFireCache;
+import org.apache.geode.cache.client.ClientCache;
import org.apache.geode.cache.client.ClientCacheFactory;
import org.apache.geode.cache.client.ClientRegionShortcut;
import org.apache.geode.cache.server.CacheServer;
import org.apache.geode.test.dunit.SerializableCallableIF;
import org.apache.geode.test.dunit.SerializableRunnableIF;
-import org.apache.geode.test.dunit.rules.ClientCacheRule;
import org.apache.geode.test.junit.categories.DistributedTest;
import org.apache.geode.test.junit.categories.LuceneTest;
@@ -37,20 +34,11 @@ import org.apache.geode.test.junit.categories.LuceneTest;
@RunWith(JUnitParamsRunner.class)
public class LuceneQueriesClientDUnitTest extends LuceneQueriesDUnitTest {
- @Rule
- public ClientCacheRule clientCacheRule = new ClientCacheRule();
-
@Override
- protected GemFireCache getAccessorCache() {
- return clientCacheRule.getClientCache();
- }
-
- @Before
- public void init() {
- dataStore1.invoke(() -> cacheRule.createCache(getDistributedSystemProperties()));
- dataStore2.invoke(() -> cacheRule.createCache(getDistributedSystemProperties()));
+ public void postSetUp() throws Exception {
+ super.postSetUp();
SerializableCallableIF<Integer> launchServer = () -> {
- final Cache cache = cacheRule.getCache();
+ final Cache cache = getCache();
final CacheServer server = cache.addCacheServer();
server.setPort(0);
server.start();
@@ -58,13 +46,13 @@ public class LuceneQueriesClientDUnitTest extends LuceneQueriesDUnitTest {
};
final int port1 = dataStore1.invoke(launchServer);
final int port2 = dataStore2.invoke(launchServer);
+
accessor.invoke(() -> {
ClientCacheFactory clientCacheFactory = new ClientCacheFactory();
clientCacheFactory.addPoolServer("localhost", port1);
clientCacheFactory.addPoolServer("localhost", port2);
- clientCacheRule.createClientCache(clientCacheFactory);
- clientCacheRule.getClientCache().createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY)
- .create(REGION_NAME);
+ ClientCache clientCache = getClientCache(clientCacheFactory);
+ clientCache.createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY).create(REGION_NAME);
});
}
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesDUnitTest.java
index d4168c3..42813b2 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesDUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesDUnitTest.java
@@ -28,7 +28,6 @@ import junitparams.JUnitParamsRunner;
import junitparams.Parameters;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.TermQuery;
-import org.junit.Before;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.junit.runner.RunWith;
@@ -47,15 +46,13 @@ import org.apache.geode.test.junit.categories.LuceneTest;
/**
* This test class is intended to contain basic integration tests of the lucene query class that
* should be executed against a number of different regions types and topologies.
+ *
*/
@Category({DistributedTest.class, LuceneTest.class})
@RunWith(JUnitParamsRunner.class)
public class LuceneQueriesDUnitTest extends LuceneQueriesAccessorBase {
- @Before
- public void init() {
- accessor.invoke(() -> cacheRule.createCache(getDistributedSystemProperties()));
- }
+ private static final long serialVersionUID = 1L;
protected SerializableRunnable createIndex = new SerializableRunnable("createIndex") {
public void run() {
@@ -77,13 +74,12 @@ public class LuceneQueriesDUnitTest extends LuceneQueriesAccessorBase {
public void transactionWithLuceneQueriesShouldThrowException(RegionTestableType regionTestType)
throws Exception {
createRegionAndIndexForAllDataStores(regionTestType, createIndex);
- accessor.invoke(this::putDataInRegion);
- assertTrue(accessor
- .invoke(() -> waitForFlushBeforeExecuteTextSearch((Cache) getAccessorCache(), 60000)));
- assertTrue(dataStore1.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ putDataInRegion(accessor);
+ assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
accessor.invoke(() -> {
- Cache cache = (Cache) getAccessorCache();
+ Cache cache = getCache();
try {
LuceneService service = LuceneServiceProvider.get(cache);
LuceneQuery<Integer, TestObject> query;
@@ -108,10 +104,9 @@ public class LuceneQueriesDUnitTest extends LuceneQueriesAccessorBase {
public void returnCorrectResultsFromStringQueryWithDefaultAnalyzer(
RegionTestableType regionTestType) throws Exception {
createRegionAndIndexForAllDataStores(regionTestType, createIndex);
- accessor.invoke(this::putDataInRegion);
- assertTrue(accessor
- .invoke(() -> waitForFlushBeforeExecuteTextSearch((Cache) getAccessorCache(), 60000)));
- assertTrue(dataStore1.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ putDataInRegion(accessor);
+ assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
executeTextSearch(accessor);
}
@@ -120,10 +115,9 @@ public class LuceneQueriesDUnitTest extends LuceneQueriesAccessorBase {
public void defaultFieldShouldPropogateCorrectlyThroughFunction(RegionTestableType regionTestType)
throws Exception {
createRegionAndIndexForAllDataStores(regionTestType, createIndex);
- accessor.invoke(this::putDataInRegion);
- assertTrue(accessor
- .invoke(() -> waitForFlushBeforeExecuteTextSearch((Cache) getAccessorCache(), 60000)));
- assertTrue(dataStore1.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ putDataInRegion(accessor);
+ assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
executeTextSearch(accessor, "world", "text", 3);
executeTextSearch(accessor, "world", "noEntriesMapped", 0);
}
@@ -133,17 +127,18 @@ public class LuceneQueriesDUnitTest extends LuceneQueriesAccessorBase {
public void canQueryWithCustomLuceneQueryObject(RegionTestableType regionTestType)
throws Exception {
createRegionAndIndexForAllDataStores(regionTestType, createIndex);
- accessor.invoke(this::putDataInRegion);
- assertTrue(accessor
- .invoke(() -> waitForFlushBeforeExecuteTextSearch((Cache) getAccessorCache(), 60000)));
- assertTrue(dataStore1.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ putDataInRegion(accessor);
+ assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
// Execute a query with a custom lucene query object
accessor.invoke(() -> {
- Cache cache = (Cache) getAccessorCache();
+ Cache cache = getCache();
LuceneService service = LuceneServiceProvider.get(cache);
- LuceneQuery query = service.createLuceneQueryFactory().create(INDEX_NAME, REGION_NAME,
- index -> new TermQuery(new Term("text", "world")));
+ LuceneQuery query =
+ service.createLuceneQueryFactory().create(INDEX_NAME, REGION_NAME, index -> {
+ return new TermQuery(new Term("text", "world"));
+ });
final PageableLuceneQueryResults results = query.findPages();
assertEquals(3, results.size());
});
@@ -156,13 +151,11 @@ public class LuceneQueriesDUnitTest extends LuceneQueriesAccessorBase {
createRegionAndIndexForAllDataStores(regionTestType, createIndex);
dataStore1.invoke(() -> LuceneTestUtilities.pauseSender(getCache()));
dataStore2.invoke(() -> LuceneTestUtilities.pauseSender(getCache()));
- accessor.invoke(this::putDataInRegion);
- assertFalse(accessor
- .invoke(() -> waitForFlushBeforeExecuteTextSearch((Cache) getAccessorCache(), 200)));
+ putDataInRegion(accessor);
+ assertFalse(waitForFlushBeforeExecuteTextSearch(accessor, 200));
dataStore1.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
dataStore2.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
- assertTrue(accessor
- .invoke(() -> waitForFlushBeforeExecuteTextSearch((Cache) getAccessorCache(), 60000)));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
executeTextSearch(accessor, "world", "text", 3);
executeTextSearch(accessor, "world", "noEntriesMapped", 0);
}
@@ -171,10 +164,9 @@ public class LuceneQueriesDUnitTest extends LuceneQueriesAccessorBase {
@Parameters(method = "getListOfRegionTestTypes")
public void verifyWildcardQueriesSucceed(RegionTestableType regionTestType) throws Exception {
createRegionAndIndexForAllDataStores(regionTestType, createIndex);
- accessor.invoke(this::putDataInRegion);
- assertTrue(accessor
- .invoke(() -> waitForFlushBeforeExecuteTextSearch((Cache) getAccessorCache(), 60000)));
- assertTrue(dataStore1.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ putDataInRegion(accessor);
+ assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
executeTextSearch(accessor, "*", "*", 3);
executeTextSearch(accessor, "*:*", "text", 3);
executeTextSearch(accessor, "*:*", "XXX", 3);
@@ -185,10 +177,9 @@ public class LuceneQueriesDUnitTest extends LuceneQueriesAccessorBase {
@Parameters(method = "getListOfRegionTestTypes")
public void verifySpaceQueriesFail(RegionTestableType regionTestType) throws Exception {
createRegionAndIndexForAllDataStores(regionTestType, createIndex);
- accessor.invoke(this::putDataInRegion);
- assertTrue(accessor
- .invoke(() -> waitForFlushBeforeExecuteTextSearch((Cache) getAccessorCache(), 60000)));
- assertTrue(dataStore1.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ putDataInRegion(accessor);
+ assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
executeTextSearchWithExpectedException(accessor, " ", "*", LuceneQueryException.class);
executeTextSearchWithExpectedException(accessor, " ", "text", LuceneQueryException.class);
executeTextSearchWithExpectedException(accessor, " ", "XXX", LuceneQueryException.class);
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesReindexDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesReindexDUnitTest.java
index e4f8e93..e25ca9a 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesReindexDUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesReindexDUnitTest.java
@@ -39,6 +39,8 @@ import org.apache.geode.test.junit.categories.LuceneTest;
@RunWith(JUnitParamsRunner.class)
public class LuceneQueriesReindexDUnitTest extends LuceneQueriesAccessorBase {
+ private static final long serialVersionUID = 1L;
+
private void destroyIndex() {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
luceneService.destroyIndex(INDEX_NAME, REGION_NAME);
@@ -49,41 +51,7 @@ public class LuceneQueriesReindexDUnitTest extends LuceneQueriesAccessorBase {
LuceneIndexFactoryImpl indexFactory =
(LuceneIndexFactoryImpl) luceneService.createIndexFactory().addField("text");
indexFactory.create(INDEX_NAME, REGION_NAME, true);
- }
-
- @Test
- @Parameters(method = "getListOfRegionTestTypes")
- public void dropAndRecreateIndex2(RegionTestableType regionTestType) throws Exception {
- dataStore1.invoke(() -> initDataStore(regionTestType));
- dataStore2.invoke(() -> initDataStore(regionTestType));
- accessor.invoke(() -> initAccessor(regionTestType));
-
- accessor.invoke(this::putDataInRegion);
-
- // re-index stored data
- AsyncInvocation ai1 = dataStore1.invokeAsync(() -> {
- LuceneService luceneService = LuceneServiceProvider.get(getCache());
- LuceneIndexFactoryImpl indexFactory =
- (LuceneIndexFactoryImpl) luceneService.createIndexFactory().addField("text");
- indexFactory.create(INDEX_NAME, REGION_NAME, true);
- });
-
- AsyncInvocation ai2 = dataStore2.invokeAsync(() -> {
- LuceneService luceneService = LuceneServiceProvider.get(getCache());
- LuceneIndexFactoryImpl indexFactory =
- (LuceneIndexFactoryImpl) luceneService.createIndexFactory().addField("text2");
- indexFactory.create(INDEX_NAME, REGION_NAME, true);
- });
-
- ai1.join();
- ai2.join();
-
- ai1.checkException();
- ai2.checkException();
-
- assertTrue(accessor.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
- executeTextSearch(accessor);
- }
+ };
@Test
@Parameters(method = "getListOfRegionTestTypes")
@@ -96,17 +64,21 @@ public class LuceneQueriesReindexDUnitTest extends LuceneQueriesAccessorBase {
dataStore2.invoke(() -> initDataStore(createIndex, regionTestType));
accessor.invoke(() -> initAccessor(createIndex, regionTestType));
- accessor.invoke(this::putDataInRegion);
- assertTrue(accessor.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
- assertTrue(dataStore1.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ putDataInRegion(accessor);
+ assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
executeTextSearch(accessor);
- dataStore1.invoke(this::destroyIndex);
+ dataStore1.invoke(() -> destroyIndex());
// re-index stored data
- AsyncInvocation ai1 = dataStore1.invokeAsync(this::recreateIndex);
+ AsyncInvocation ai1 = dataStore1.invokeAsync(() -> {
+ recreateIndex();
+ });
- AsyncInvocation ai2 = dataStore2.invokeAsync(this::recreateIndex);
+ AsyncInvocation ai2 = dataStore2.invokeAsync(() -> {
+ recreateIndex();
+ });
ai1.join();
ai2.join();
@@ -114,37 +86,45 @@ public class LuceneQueriesReindexDUnitTest extends LuceneQueriesAccessorBase {
ai1.checkException();
ai2.checkException();
- assertTrue(accessor.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ waitForFlushBeforeExecuteTextSearch(accessor, 60000);
executeTextSearch(accessor);
}
@Test
@Parameters(method = "getListOfRegionTestTypes")
public void reindexThenQuery(RegionTestableType regionTestType) throws Exception {
+ SerializableRunnableIF createIndex = () -> {
+ LuceneService luceneService = LuceneServiceProvider.get(getCache());
+ LuceneIndexFactoryImpl indexFactory =
+ (LuceneIndexFactoryImpl) luceneService.createIndexFactory().addField("text");
+ indexFactory.create(INDEX_NAME, REGION_NAME, true);
+ };
+
// Create dataRegion prior to index
dataStore1.invoke(() -> initDataStore(regionTestType));
dataStore2.invoke(() -> initDataStore(regionTestType));
accessor.invoke(() -> initAccessor(regionTestType));
// populate region
- accessor.invoke(this::putDataInRegion);
+ putDataInRegion(accessor);
// re-index stored data
- AsyncInvocation ai1 = dataStore1.invokeAsync(this::recreateIndex);
+ AsyncInvocation ai1 = dataStore1.invokeAsync(() -> {
+ recreateIndex();
+ });
// re-index stored data
- AsyncInvocation ai2 = dataStore2.invokeAsync(this::recreateIndex);
-
- AsyncInvocation ai3 = accessor.invokeAsync(this::recreateIndex);
+ AsyncInvocation ai2 = dataStore2.invokeAsync(() -> {
+ recreateIndex();
+ });
ai1.join();
ai2.join();
- ai3.join();
ai1.checkException();
ai2.checkException();
- assertTrue(accessor.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ waitForFlushBeforeExecuteTextSearch(accessor, 60000);
executeTextSearch(accessor);
}
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/MixedObjectIndexDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/MixedObjectIndexDUnitTest.java
index 9c12bd6..af16c21 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/MixedObjectIndexDUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/MixedObjectIndexDUnitTest.java
@@ -79,7 +79,7 @@ public class MixedObjectIndexDUnitTest extends LuceneQueriesAccessorBase {
.forEach(i -> region.put(i, new TestObjectWithSameFieldName("hello world 2")));
});
- assertTrue(accessor.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ waitForFlushBeforeExecuteTextSearch(accessor, 60000);
accessor.invoke(() -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
@@ -112,10 +112,17 @@ public class MixedObjectIndexDUnitTest extends LuceneQueriesAccessorBase {
accessor.invoke(() -> initDataStore(createIndexOnTextAndDataField, regionTestableType));
- accessor.invoke(this::insertDataIntoRegions);
+ accessor.invoke(() -> {
+ Region region = getCache().getRegion(REGION_NAME);
+ IntStream.range(0, NUM_BUCKETS).forEach(i -> region.put(i, new TestObject("hello world")));
+ IntStream.range(NUM_BUCKETS, 2 * NUM_BUCKETS)
+ .forEach(i -> region.put(i, new TestObjectWithSameFieldName("hello world")));
+ IntStream.range(2 * NUM_BUCKETS, 3 * NUM_BUCKETS)
+ .forEach(i -> region.put(i, new TestObjectWithNoCommonField("hello world")));
+ });
- assertTrue(accessor.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ waitForFlushBeforeExecuteTextSearch(accessor, 60000);
accessor.invoke(() -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
@@ -133,14 +140,6 @@ public class MixedObjectIndexDUnitTest extends LuceneQueriesAccessorBase {
});
}
- private void insertDataIntoRegions() {
- Region region = getCache().getRegion(REGION_NAME);
- IntStream.range(0, NUM_BUCKETS).forEach(i -> region.put(i, new TestObject("hello world")));
- IntStream.range(NUM_BUCKETS, 2 * NUM_BUCKETS)
- .forEach(i -> region.put(i, new TestObjectWithSameFieldName("hello world")));
- IntStream.range(2 * NUM_BUCKETS, 3 * NUM_BUCKETS)
- .forEach(i -> region.put(i, new TestObjectWithNoCommonField("hello world")));
- }
@Test
@@ -155,9 +154,16 @@ public class MixedObjectIndexDUnitTest extends LuceneQueriesAccessorBase {
accessor.invoke(() -> initDataStore(createIndexOnTextField, regionTestableType));
- accessor.invoke(this::insertDataIntoRegions);
+ accessor.invoke(() -> {
+ Region region = getCache().getRegion(REGION_NAME);
+ IntStream.range(0, NUM_BUCKETS).forEach(i -> region.put(i, new TestObject("hello world")));
+ IntStream.range(NUM_BUCKETS, 2 * NUM_BUCKETS)
+ .forEach(i -> region.put(i, new TestObjectWithSameFieldName("hello world")));
+ IntStream.range(2 * NUM_BUCKETS, 3 * NUM_BUCKETS)
+ .forEach(i -> region.put(i, new TestObjectWithNoCommonField("hello world")));
+ });
- assertTrue(accessor.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ waitForFlushBeforeExecuteTextSearch(accessor, 60000);
accessor.invoke(() -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
@@ -191,7 +197,7 @@ public class MixedObjectIndexDUnitTest extends LuceneQueriesAccessorBase {
new TestObjectSameFieldNameButDifferentDataTypeFloat(new Float(999.1f))));
});
- assertTrue(accessor.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
accessor.invoke(() -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/PaginationDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/PaginationDUnitTest.java
index 9a4219a..94850ae 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/PaginationDUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/PaginationDUnitTest.java
@@ -33,12 +33,8 @@ import org.junit.experimental.categories.Category;
import org.junit.runner.RunWith;
import org.apache.geode.cache.Cache;
-import org.apache.geode.cache.CacheTransactionManager;
import org.apache.geode.cache.PartitionedRegionStorageException;
import org.apache.geode.cache.Region;
-import org.apache.geode.cache.client.PoolManager;
-import org.apache.geode.internal.cache.GemFireCacheImpl;
-import org.apache.geode.internal.cache.InternalCache;
import org.apache.geode.test.dunit.Assert;
import org.apache.geode.test.dunit.SerializableRunnableIF;
import org.apache.geode.test.junit.categories.DistributedTest;
@@ -47,8 +43,8 @@ import org.apache.geode.test.junit.categories.LuceneTest;
@Category({DistributedTest.class, LuceneTest.class})
@RunWith(JUnitParamsRunner.class)
public class PaginationDUnitTest extends LuceneQueriesAccessorBase {
- private static final int PAGE_SIZE = 2;
- private static final int FLUSH_WAIT_TIME_MS = 60000;
+ protected static final int PAGE_SIZE = 2;
+ protected static final int FLUSH_WAIT_TIME_MS = 60000;
@Override
protected RegionTestableType[] getListOfRegionTestTypes() {
@@ -72,12 +68,13 @@ public class PaginationDUnitTest extends LuceneQueriesAccessorBase {
luceneService.createIndexFactory().setFields("text").create(INDEX_NAME, REGION_NAME);
};
+
dataStore1.invoke(() -> initDataStore(createIndex, regionTestType));
accessor.invoke(() -> initAccessor(createIndex, regionTestType));
putEntryInEachBucket();
- assertTrue(dataStore1.invoke(() -> waitForFlushBeforeExecuteTextSearch(FLUSH_WAIT_TIME_MS)));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, FLUSH_WAIT_TIME_MS));
accessor.invoke(() -> {
Cache cache = getCache();
@@ -111,13 +108,14 @@ public class PaginationDUnitTest extends LuceneQueriesAccessorBase {
luceneService.createIndexFactory().setFields("text").create(INDEX_NAME, REGION_NAME);
};
+
dataStore1.invoke(() -> initDataStore(createIndex, regionTestType));
dataStore2.invoke(() -> initDataStore(createIndex, regionTestType));
accessor.invoke(() -> initAccessor(createIndex, regionTestType));
putEntryInEachBucket();
- assertTrue(dataStore1.invoke(() -> waitForFlushBeforeExecuteTextSearch(FLUSH_WAIT_TIME_MS)));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, FLUSH_WAIT_TIME_MS));
accessor.invoke(() -> {
List<LuceneResultStruct<Integer, TestObject>> combinedResult = new ArrayList<>();
@@ -154,38 +152,4 @@ public class PaginationDUnitTest extends LuceneQueriesAccessorBase {
}
}
- protected final void closeCache() {
- // Workaround for the fact that some classes are now extending
- // CacheTestCase but not using it properly.
- InternalCache cache = getCache();
- if (cache == null) {
- cache = GemFireCacheImpl.getInstance();
- }
- try {
- if (cache != null) {
- try {
- if (!cache.isClosed()) {
- if (cache instanceof GemFireCacheImpl) {
- CacheTransactionManager transactionManager =
- ((GemFireCacheImpl) cache).getTxManager();
- if (transactionManager != null) {
- if (transactionManager.exists()) {
- try {
- transactionManager.rollback();
- } catch (Exception ignore) {
-
- }
- }
- }
- }
- cache.close();
- }
- } finally {
- }
- } // cache != null
- } finally {
- PoolManager.close(false);
- }
- }
-
}
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceDUnitTest.java
index c231d16..db71787 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceDUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceDUnitTest.java
@@ -27,6 +27,7 @@ import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.junit.runner.RunWith;
+import org.apache.geode.cache.Cache;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.lucene.test.LuceneTestUtilities;
import org.apache.geode.distributed.DistributedMember;
@@ -43,12 +44,13 @@ import org.apache.geode.test.junit.categories.LuceneTest;
@RunWith(JUnitParamsRunner.class)
public class RebalanceDUnitTest extends LuceneQueriesAccessorBase {
- private static int NUM_BUCKETS = 10;
+ protected static int NUM_BUCKETS = 10;
+
@After
public void cleanupRebalanceCallback() {
- dataStore1.invoke(this::removeCallback);
- dataStore2.invoke(this::removeCallback);
+ removeCallback(dataStore1);
+ removeCallback(dataStore2);
}
protected RegionTestableType[] getListOfRegionTestTypes() {
@@ -56,6 +58,7 @@ public class RebalanceDUnitTest extends LuceneQueriesAccessorBase {
RegionTestableType.PARTITION_OVERFLOW_TO_DISK};
}
+
@Test
@Parameters(method = "getListOfRegionTestTypes")
public void returnCorrectResultsWhenRebalanceHappensOnIndexUpdate(
@@ -116,9 +119,8 @@ public class RebalanceDUnitTest extends LuceneQueriesAccessorBase {
putEntryInEachBucket();
dataStore2.invoke(() -> initDataStore(createIndex, regionTestType));
-
- assertTrue(accessor.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
- assertTrue(dataStore1.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
rebalanceRegion(dataStore2);
@@ -143,8 +145,8 @@ public class RebalanceDUnitTest extends LuceneQueriesAccessorBase {
rebalanceRegion(dataStore2);
dataStore1.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
- assertTrue(accessor.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
- assertTrue(dataStore1.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
executeTextSearch(accessor, "world", "text", NUM_BUCKETS);
}
@@ -163,7 +165,7 @@ public class RebalanceDUnitTest extends LuceneQueriesAccessorBase {
dataStore2.invoke(() -> initDataStore(createIndex, regionTestType));
dataStore1.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
- assertTrue(dataStore1.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
// dataStore3.invoke(() -> initDataStore(create, regionType));
executeTextSearch(accessor, "world", "text", NUM_BUCKETS);
@@ -172,7 +174,8 @@ public class RebalanceDUnitTest extends LuceneQueriesAccessorBase {
// Duplicated for now, try to abstract this out...
protected void putEntryInEachBucket() {
accessor.invoke(() -> {
- Region<Object, Object> region = getCache().getRegion(REGION_NAME);
+ final Cache cache = getCache();
+ Region<Object, Object> region = cache.getRegion(REGION_NAME);
IntStream.range(0, NUM_BUCKETS).forEach(i -> region.put(i, new TestObject("hello world")));
});
}
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceWithRedundancyDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceWithRedundancyDUnitTest.java
index 3b183df..2b68f99 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceWithRedundancyDUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceWithRedundancyDUnitTest.java
@@ -53,8 +53,8 @@ public class RebalanceWithRedundancyDUnitTest extends LuceneQueriesAccessorBase
@After
public void cleanupRebalanceCallback() {
- dataStore1.invoke(this::removeCallback);
- dataStore2.invoke(this::removeCallback);
+ removeCallback(dataStore1);
+ removeCallback(dataStore2);
}
@Override
@@ -92,16 +92,14 @@ public class RebalanceWithRedundancyDUnitTest extends LuceneQueriesAccessorBase
spy.beforeWriteIndexRepository(doAfterN(key -> getCache().close(), 2));
});
- dataStore1.invoke(() -> {
- getCache().getLogger().info("<ExpectedException action=add>"
- + CacheClosedException.class.getName() + "</ExpectedException>");
- });
+ final String expectedExceptions = CacheClosedException.class.getName();
+ dataStore1.invoke(addExceptionTag1(expectedExceptions));
putEntriesAndValidateResultsWithRedundancy(regionTestType);
// Wait until the cache is closed in datastore1
- dataStore1
- .invoke(() -> Awaitility.await().atMost(60, TimeUnit.SECONDS).until(getCache()::isClosed));
+ dataStore1.invoke(
+ () -> Awaitility.await().atMost(60, TimeUnit.SECONDS).until(basicGetCache()::isClosed));
}
@Test
@@ -110,14 +108,15 @@ public class RebalanceWithRedundancyDUnitTest extends LuceneQueriesAccessorBase
RegionTestableType regionTestType) throws InterruptedException {
final DistributedMember member2 =
dataStore2.invoke(() -> getCache().getDistributedSystem().getDistributedMember());
- dataStore1.invoke(
- () -> IndexRegionSpy.beforeWrite(getCache(), doAfterN(key -> getCache().close(), 100)));
+ dataStore1.invoke(() -> {
+ IndexRegionSpy.beforeWrite(getCache(), doAfterN(key -> getCache().close(), 100));
+ });
putEntriesAndValidateResultsWithRedundancy(regionTestType);
// Wait until the cache is closed in datastore1
- dataStore1
- .invoke(() -> Awaitility.await().atMost(60, TimeUnit.SECONDS).until(getCache()::isClosed));
+ dataStore1.invoke(
+ () -> Awaitility.await().atMost(60, TimeUnit.SECONDS).until(basicGetCache()::isClosed));
}
@Test
@@ -151,22 +150,23 @@ public class RebalanceWithRedundancyDUnitTest extends LuceneQueriesAccessorBase
@Override
public void run() {
dataStore1.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
- assertTrue(dataStore1.invoke(() -> waitForFlushBeforeExecuteTextSearch(30000)));
+ waitForFlushBeforeExecuteTextSearch(dataStore1, 30000);
((TestResourceObserver) InternalResourceManager.getResourceObserver())
.recoveryFinished();
}
});
});
+
dataStore2.invoke(() -> {
initDataStore(createIndex, regionTestType);
((TestResourceObserver) InternalResourceManager.getResourceObserver()).await();
});
- assertTrue(dataStore1.invoke(() -> waitForFlushBeforeExecuteTextSearch(30000)));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 30000));
dataStore1.invoke(() -> getCache().close());
- assertTrue(dataStore2.invoke(() -> waitForFlushBeforeExecuteTextSearch(30000)));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore2, 30000));
executeTextSearch(accessor, "world", "text", NUM_BUCKETS);
}
@@ -186,11 +186,11 @@ public class RebalanceWithRedundancyDUnitTest extends LuceneQueriesAccessorBase
putEntryInEachBucket();
- dataStore1.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
- dataStore2.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
- accessor.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
+ dataStore1.invoke(() -> LuceneTestUtilities.resumeSender(basicGetCache()));
+ dataStore2.invoke(() -> LuceneTestUtilities.resumeSender(basicGetCache()));
+ accessor.invoke(() -> LuceneTestUtilities.resumeSender(basicGetCache()));
- assertTrue(dataStore2.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore2, 60000));
executeTextSearch(accessor, "world", "text", NUM_BUCKETS);
}
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceWithRedundancyWithRegionCreatedBeforeReindexDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceWithRedundancyWithRegionCreatedBeforeReindexDUnitTest.java
index a599373..7b1f361 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceWithRedundancyWithRegionCreatedBeforeReindexDUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceWithRedundancyWithRegionCreatedBeforeReindexDUnitTest.java
@@ -26,7 +26,6 @@ import junitparams.Parameters;
import org.apache.logging.log4j.Logger;
import org.awaitility.Awaitility;
import org.junit.After;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.experimental.categories.Category;
@@ -59,11 +58,11 @@ public class RebalanceWithRedundancyWithRegionCreatedBeforeReindexDUnitTest
private static final Logger logger = LogService.getLogger();
- private VM dataStore3;
- private VM dataStore4;
+ protected VM dataStore3;
+ protected VM dataStore4;
- @After
public void postSetUp() throws Exception {
+ super.postSetUp();
dataStore3 = Host.getHost(0).getVM(2);
dataStore4 = Host.getHost(0).getVM(3);
}
@@ -114,7 +113,7 @@ public class RebalanceWithRedundancyWithRegionCreatedBeforeReindexDUnitTest
RebalanceResults rebalanceResults = null;
RebalanceOperation rebalanceOp = factory.start();
rebalanceResults = rebalanceOp.getResults();
- Awaitility.await().atMost(60, TimeUnit.SECONDS).until(rebalanceOp::isDone);
+ Awaitility.await().atMost(60, TimeUnit.SECONDS).until(() -> rebalanceOp.isDone());
logger.info("Rebalance completed: "
+ RebalanceResultsToString(rebalanceResults, "Rebalance completed"));
}
@@ -171,7 +170,7 @@ public class RebalanceWithRedundancyWithRegionCreatedBeforeReindexDUnitTest
createIndexAndRebalance(regionTestType, createIndex, true);
- Assert.assertTrue(dataStore3.invoke(() -> waitForFlushBeforeExecuteTextSearch(60000)));
+ waitForFlushBeforeExecuteTextSearch(dataStore3, 60000);
executeTextSearch(dataStore3, "world", "text", NUM_BUCKETS);
}
@@ -197,36 +196,40 @@ public class RebalanceWithRedundancyWithRegionCreatedBeforeReindexDUnitTest
if (results == null) {
return "null";
}
- StringBuilder aStr = new StringBuilder();
- aStr.append("Rebalance results (").append(title).append(") totalTime: ")
- .append(results.getTotalTime()).append("\n");
+ StringBuffer aStr = new StringBuffer();
+ aStr.append("Rebalance results (" + title + ") totalTime: "
+ + valueToString(results.getTotalTime()) + "\n");
// bucketCreates
- aStr.append("totalBucketCreatesCompleted: ").append(results.getTotalBucketCreatesCompleted());
- aStr.append(" totalBucketCreateBytes: ").append(results.getTotalBucketCreateBytes());
- aStr.append(" totalBucketCreateTime: ").append(results.getTotalBucketCreateTime()).append("\n");
+ aStr.append(
+ "totalBucketCreatesCompleted: " + valueToString(results.getTotalBucketCreatesCompleted()));
+ aStr.append(" totalBucketCreateBytes: " + valueToString(results.getTotalBucketCreateBytes()));
+ aStr.append(
+ " totalBucketCreateTime: " + valueToString(results.getTotalBucketCreateTime()) + "\n");
// bucketTransfers
- aStr.append("totalBucketTransfersCompleted: ")
- .append(results.getTotalBucketTransfersCompleted());
- aStr.append(" totalBucketTransferBytes: ").append(results.getTotalBucketTransferBytes());
- aStr.append(" totalBucketTransferTime: ").append(results.getTotalBucketTransferTime())
- .append("\n");
+ aStr.append("totalBucketTransfersCompleted: "
+ + valueToString(results.getTotalBucketTransfersCompleted()));
+ aStr.append(
+ " totalBucketTransferBytes: " + valueToString(results.getTotalBucketTransferBytes()));
+ aStr.append(
+ " totalBucketTransferTime: " + valueToString(results.getTotalBucketTransferTime()) + "\n");
// primaryTransfers
- aStr.append("totalPrimaryTransfersCompleted: ")
- .append(results.getTotalPrimaryTransfersCompleted());
- aStr.append(" totalPrimaryTransferTime: ").append(results.getTotalPrimaryTransferTime())
- .append("\n");
+ aStr.append("totalPrimaryTransfersCompleted: "
+ + valueToString(results.getTotalPrimaryTransfersCompleted()));
+ aStr.append(" totalPrimaryTransferTime: " + valueToString(results.getTotalPrimaryTransferTime())
+ + "\n");
// PartitionRebalanceDetails (per region)
Set<PartitionRebalanceInfo> prdSet = results.getPartitionRebalanceDetails();
for (PartitionRebalanceInfo prd : prdSet) {
aStr.append(partitionRebalanceDetailsToString(prd));
}
- aStr.append("total time (ms): ").append(results.getTotalTime());
+ aStr.append("total time (ms): " + valueToString(results.getTotalTime()));
- return aStr.toString();
+ String returnStr = aStr.toString();
+ return returnStr;
}
private static String partitionRebalanceDetailsToString(PartitionRebalanceInfo details) {
@@ -234,23 +237,25 @@ public class RebalanceWithRedundancyWithRegionCreatedBeforeReindexDUnitTest
return "null\n";
}
- StringBuilder aStr = new StringBuilder();
- aStr.append("PartitionedRegionDetails for region named ").append(getRegionName(details))
- .append(" time: ").append(details.getTime()).append("\n");
+ StringBuffer aStr = new StringBuffer();
+ aStr.append("PartitionedRegionDetails for region named " + getRegionName(details) + " time: "
+ + valueToString(details.getTime()) + "\n");
// bucketCreates
- aStr.append("bucketCreatesCompleted: ").append(details.getBucketCreatesCompleted());
- aStr.append(" bucketCreateBytes: ").append(details.getBucketCreateBytes());
- aStr.append(" bucketCreateTime: ").append(details.getBucketCreateTime()).append("\n");
+ aStr.append("bucketCreatesCompleted: " + valueToString(details.getBucketCreatesCompleted()));
+ aStr.append(" bucketCreateBytes: " + valueToString(details.getBucketCreateBytes()));
+ aStr.append(" bucketCreateTime: " + valueToString(details.getBucketCreateTime()) + "\n");
// bucketTransfers
- aStr.append("bucketTransfersCompleted: ").append(details.getBucketTransfersCompleted());
- aStr.append(" bucketTransferBytes: ").append(details.getBucketTransferBytes());
- aStr.append(" bucketTransferTime: ").append(details.getBucketTransferTime()).append("\n");
+ aStr.append(
+ "bucketTransfersCompleted: " + valueToString(details.getBucketTransfersCompleted()));
+ aStr.append(" bucketTransferBytes: " + valueToString(details.getBucketTransferBytes()));
+ aStr.append(" bucketTransferTime: " + valueToString(details.getBucketTransferTime()) + "\n");
// primaryTransfers
- aStr.append("PrimaryTransfersCompleted: ").append(details.getPrimaryTransfersCompleted());
- aStr.append(" PrimaryTransferTime: ").append(details.getPrimaryTransferTime()).append("\n");
+ aStr.append(
+ "PrimaryTransfersCompleted: " + valueToString(details.getPrimaryTransfersCompleted()));
+ aStr.append(" PrimaryTransferTime: " + valueToString(details.getPrimaryTransferTime()) + "\n");
// PartitionMemberDetails (before)
aStr.append("PartitionedMemberDetails (before)\n");
@@ -269,20 +274,66 @@ public class RebalanceWithRedundancyWithRegionCreatedBeforeReindexDUnitTest
return aStr.toString();
}
+ public static String partitionedRegionDetailsToString(PartitionRegionInfo prd) {
+
+ if (prd == null) {
+ return "null\n";
+ }
+
+ StringBuffer aStr = new StringBuffer();
+
+ aStr.append("PartitionedRegionDetails for region named " + getRegionName(prd) + "\n");
+ aStr.append(" configuredBucketCount: " + valueToString(prd.getConfiguredBucketCount()) + "\n");
+ aStr.append(" createdBucketCount: " + valueToString(prd.getCreatedBucketCount()) + "\n");
+ aStr.append(
+ " lowRedundancyBucketCount: " + valueToString(prd.getLowRedundancyBucketCount()) + "\n");
+ aStr.append(
+ " configuredRedundantCopies: " + valueToString(prd.getConfiguredRedundantCopies()) + "\n");
+ aStr.append(" actualRedundantCopies: " + valueToString(prd.getActualRedundantCopies()) + "\n");
+
+ // memberDetails
+ Set<PartitionMemberInfo> pmd = prd.getPartitionMemberInfo();
+ for (PartitionMemberInfo memberDetails : pmd) {
+ aStr.append(partitionMemberDetailsToString(memberDetails));
+ }
+
+ // colocatedWithDetails
+ String colocatedWith = prd.getColocatedWith();
+ aStr.append(" colocatedWith: " + colocatedWith + "\n");
+
+ String returnStr = aStr.toString();
+ return returnStr;
+ }
+
private static String partitionMemberDetailsToString(PartitionMemberInfo pmd) {
- StringBuilder aStr = new StringBuilder();
+ StringBuffer aStr = new StringBuffer();
long localMaxMemory = pmd.getConfiguredMaxMemory();
long size = pmd.getSize();
- aStr.append(" Member Details for: ").append(pmd.getDistributedMember()).append("\n");
- aStr.append(" configuredMaxMemory: ").append(localMaxMemory);
+ aStr.append(" Member Details for: " + pmd.getDistributedMember() + "\n");
+ aStr.append(" configuredMaxMemory: " + valueToString(localMaxMemory));
double inUse = (double) size / localMaxMemory;
double heapUtilization = inUse * 100;
- aStr.append(" size: ").append(size).append(" (").append(heapUtilization).append("%)");
- aStr.append(" bucketCount: ").append(pmd.getBucketCount());
- aStr.append(" primaryCount: ").append(pmd.getPrimaryCount()).append("\n");
+ aStr.append(" size: " + size + " (" + valueToString(heapUtilization) + "%)");
+ aStr.append(" bucketCount: " + valueToString(pmd.getBucketCount()));
+ aStr.append(" primaryCount: " + valueToString(pmd.getPrimaryCount()) + "\n");
return aStr.toString();
}
+ /**
+ * Convert the given long to a String; if it is negative then flag it in the string
+ */
+ private static String valueToString(long value) {
+ String returnStr = "" + value;
+ return returnStr;
+ }
+
+ /**
+ * Convert the given double to a String; if it is negative then flag it in the string
+ */
+ private static String valueToString(double value) {
+ String returnStr = "" + value;
+ return returnStr;
+ }
public static String getRegionName(PartitionRegionInfo prd) {
return prd.getRegionPath().substring(1);
--
To stop receiving notification emails like this one, please contact
udo@apache.org.