You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by jb...@apache.org on 2019/07/30 16:52:44 UTC
[geode] branch develop updated: GEODE-7008: Function execution by
id uses correct bucket filter. (#3835)
This is an automated email from the ASF dual-hosted git repository.
jbarrett pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/geode.git
The following commit(s) were added to refs/heads/develop by this push:
new 845513d GEODE-7008: Function execution by id uses correct bucket filter. (#3835)
845513d is described below
commit 845513d57eef11da91b05e45e9311e690527eaf6
Author: Jacob Barrett <jb...@pivotal.io>
AuthorDate: Tue Jul 30 09:52:31 2019 -0700
GEODE-7008: Function execution by id uses correct bucket filter. (#3835)
* Modifies tests to execute by both object and id.
* Cleanup most warnings in tests.
---
.../ClientServerFunctionExecutionDUnitTest.java | 317 ++--
.../execute/FunctionServiceStatsDUnitTest.java | 1617 +++++++++-----------
...lientServerFunctionExecutionNoAckDUnitTest.java | 45 +-
...ientServerRegionFunctionExecutionDUnitTest.java | 621 ++++----
...erRegionFunctionExecutionFailoverDUnitTest.java | 204 ++-
...egionFunctionExecutionNoSingleHopDUnitTest.java | 586 +++----
...ctionExecutionSelectorNoSingleHopDUnitTest.java | 576 +++----
...rRegionFunctionExecutionSingleHopDUnitTest.java | 564 +++----
.../cache/execute/PRClientServerTestBase.java | 385 ++---
.../execute/SingleHopGetAllPutAllDUnitTest.java | 2 +-
.../cache/client/internal/ServerRegionProxy.java | 27 +-
11 files changed, 2215 insertions(+), 2729 deletions(-)
diff --git a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/ClientServerFunctionExecutionDUnitTest.java b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/ClientServerFunctionExecutionDUnitTest.java
index d76a63d..fbe7de6 100755
--- a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/ClientServerFunctionExecutionDUnitTest.java
+++ b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/ClientServerFunctionExecutionDUnitTest.java
@@ -14,7 +14,6 @@
*/
package org.apache.geode.internal.cache.execute;
-import static org.apache.geode.test.dunit.LogWriterUtils.getLogWriter;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
@@ -29,8 +28,12 @@ import java.util.Iterator;
import java.util.List;
import java.util.Properties;
+import org.apache.logging.log4j.Logger;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.UseParametersRunnerFactory;
import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.DataPolicy;
@@ -47,35 +50,41 @@ import org.apache.geode.cache.execute.FunctionAdapter;
import org.apache.geode.cache.execute.FunctionContext;
import org.apache.geode.cache.execute.FunctionService;
import org.apache.geode.cache.execute.ResultCollector;
+import org.apache.geode.cache.execute.ResultSender;
import org.apache.geode.distributed.ConfigurationProperties;
import org.apache.geode.distributed.DistributedSystem;
import org.apache.geode.internal.cache.functions.TestFunction;
import org.apache.geode.internal.cache.tier.sockets.CacheServerTestUtil;
+import org.apache.geode.internal.logging.LogService;
import org.apache.geode.test.awaitility.GeodeAwaitility;
import org.apache.geode.test.dunit.Assert;
import org.apache.geode.test.dunit.IgnoredException;
-import org.apache.geode.test.dunit.LogWriterUtils;
-import org.apache.geode.test.dunit.NetworkUtils;
+import org.apache.geode.test.dunit.SerializableRunnableIF;
import org.apache.geode.test.dunit.WaitCriterion;
import org.apache.geode.test.junit.categories.ClientServerTest;
import org.apache.geode.test.junit.categories.FunctionServiceTest;
+import org.apache.geode.test.junit.runners.CategoryWithParameterizedRunnerFactory;
@Category({ClientServerTest.class, FunctionServiceTest.class})
+@RunWith(Parameterized.class)
+@UseParametersRunnerFactory(CategoryWithParameterizedRunnerFactory.class)
public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBase {
+ private static final Logger logger = LogService.getLogger();
+
private static final String TEST_FUNCTION1 = TestFunction.TEST_FUNCTION1;
- Boolean isByName = null;
+ private Boolean isByName = null;
Function function = null;
- Boolean toRegister = null;
- static final String retryRegionName = "RetryDataRegion";
- static Region metaDataRegion;
+ private Boolean toRegister = null;
+ private static final String retryRegionName = "RetryDataRegion";
+ private static Region metaDataRegion;
public ClientServerFunctionExecutionDUnitTest() {
super();
}
@Override
- protected final void postSetUpPRClientServerTestBase() throws Exception {
+ protected final void postSetUpPRClientServerTestBase() {
IgnoredException.addIgnoredException("java.net.ConnectException");
}
@@ -88,23 +97,23 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
}
@Test
- public void test_Bug_43126_Function_Not_Registered() throws InterruptedException {
+ public void throwsExceptionWhenFunctionNotRegisteredOnServer() {
createScenario();
try {
- client.invoke(() -> ClientServerFunctionExecutionDUnitTest.executeRegisteredFunction());
+ client.invoke(ClientServerFunctionExecutionDUnitTest::executeRegisteredFunction);
} catch (Exception e) {
- assertEquals(true, (e.getCause() instanceof ServerOperationException));
+ assertTrue((e.getCause() instanceof ServerOperationException));
assertTrue(
e.getCause().getMessage().contains("The function is not registered for function id"));
}
}
@Test
- public void test_Bug43126() throws InterruptedException {
+ public void noExceptionWhenFunctionRegisteredOnServer() {
createScenario();
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION1);
registerFunctionAtServer(function);
- client.invoke(() -> ClientServerFunctionExecutionDUnitTest.executeRegisteredFunction());
+ client.invoke(ClientServerFunctionExecutionDUnitTest::executeRegisteredFunction);
}
/*
@@ -118,9 +127,9 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
function = new TestFunction(true, TEST_FUNCTION1);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
- toRegister = new Boolean(true);
- LogWriterUtils.getLogWriter().info(
+ isByName = Boolean.TRUE;
+ toRegister = Boolean.TRUE;
+ logger.info(
"ClientServerFFunctionExecutionDUnitTest#testServerSingleKeyExecution_byName : Starting test");
client.invoke(() -> ClientServerFunctionExecutionDUnitTest.serverExecution(isByName, function,
toRegister));
@@ -137,9 +146,9 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
function = new TestFunction(true, TestFunction.TEST_FUNCTION_SEND_EXCEPTION);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
- toRegister = new Boolean(true);
- LogWriterUtils.getLogWriter().info(
+ isByName = Boolean.TRUE;
+ toRegister = Boolean.TRUE;
+ logger.info(
"ClientServerFFunctionExecutionDUnitTest#testServerSingleKeyExecution_byName : Starting test");
client.invoke(() -> ClientServerFunctionExecutionDUnitTest
.serverExecution_SendException(isByName, function, toRegister));
@@ -158,9 +167,9 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
function = new TestFunction(true, TestFunction.TEST_FUNCTION_NO_LASTRESULT);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
- toRegister = new Boolean(true);
- LogWriterUtils.getLogWriter().info(
+ isByName = Boolean.TRUE;
+ toRegister = Boolean.TRUE;
+ logger.info(
"ClientServerFFunctionExecutionDUnitTest#testServerSingleKeyExecution_byName : Starting test");
client.invoke(() -> ClientServerFunctionExecutionDUnitTest
.serverExecution_NoLastResult(isByName, function, toRegister));
@@ -176,9 +185,9 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
function = new TestFunction(true, TEST_FUNCTION1);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
- toRegister = new Boolean(false);
- LogWriterUtils.getLogWriter().info(
+ isByName = Boolean.TRUE;
+ toRegister = Boolean.FALSE;
+ logger.info(
"ClientServerFFunctionExecutionDUnitTest#testServerSingleKeyExecution_byName : Starting test");
client.invoke(() -> ClientServerFunctionExecutionDUnitTest.serverExecution(isByName, function,
toRegister));
@@ -192,10 +201,10 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
@Test
public void testServerExecution_byInlineFunction() {
createScenario();
- LogWriterUtils.getLogWriter().info(
+ logger.info(
"ClientServerFunctionExecutionDUnitTest#testServerSingleKeyExecution_byName : Starting test");
- client.invoke(() -> ClientServerFunctionExecutionDUnitTest.serverExecution_Inline());
- client.invoke(() -> ClientServerFunctionExecutionDUnitTest.allServerExecution_Inline());
+ client.invoke(ClientServerFunctionExecutionDUnitTest::serverExecution_Inline);
+ client.invoke(ClientServerFunctionExecutionDUnitTest::allServerExecution_Inline);
}
@@ -205,10 +214,10 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
@Test
public void testServerExecution_byInlineFunction_InvalidAttrbiutes() {
createScenario();
- LogWriterUtils.getLogWriter().info(
+ logger.info(
"ClientServerFunctionExecutionDUnitTest#testServerSingleKeyExecution_byName : Starting test");
client.invoke(
- () -> ClientServerFunctionExecutionDUnitTest.serverExecution_Inline_InvalidAttributes());
+ ClientServerFunctionExecutionDUnitTest::serverExecution_Inline_InvalidAttributes);
}
/*
@@ -217,14 +226,18 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
@Test
public void testBug40714() {
createScenario();
- LogWriterUtils.getLogWriter()
+ logger
.info("ClientServerFunctionExecutionDUnitTest#testBug40714 : Starting test");
- server1.invoke(() -> ClientServerFunctionExecutionDUnitTest.registerFunction());
- server1.invoke(() -> ClientServerFunctionExecutionDUnitTest.registerFunction());
- server1.invoke(() -> ClientServerFunctionExecutionDUnitTest.registerFunction());
- client.invoke(() -> ClientServerFunctionExecutionDUnitTest.registerFunction());
- client.invoke(() -> ClientServerFunctionExecutionDUnitTest.FunctionExecution_Inline_Bug40714());
+ server1.invoke(
+ (SerializableRunnableIF) ClientServerFunctionExecutionDUnitTest::registerFunction);
+ server1.invoke(
+ (SerializableRunnableIF) ClientServerFunctionExecutionDUnitTest::registerFunction);
+ server1.invoke(
+ (SerializableRunnableIF) ClientServerFunctionExecutionDUnitTest::registerFunction);
+ client
+ .invoke((SerializableRunnableIF) ClientServerFunctionExecutionDUnitTest::registerFunction);
+ client.invoke(ClientServerFunctionExecutionDUnitTest::FunctionExecution_Inline_Bug40714);
}
@@ -232,10 +245,12 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
FunctionService.registerFunction(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
} else if (context.getArguments() instanceof Boolean) {
- context.getResultSender().lastResult(Boolean.FALSE);
+ resultSender.lastResult(Boolean.FALSE);
}
}
@@ -251,17 +266,19 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
});
}
- public static void FunctionExecution_Inline_Bug40714() {
+ private static void FunctionExecution_Inline_Bug40714() {
DistributedSystem.setThreadsSocketPolicy(false);
Execution member = FunctionService.onServers(pool);
try {
ResultCollector rs = member.setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
} else if (context.getArguments() instanceof Boolean) {
- context.getResultSender().lastResult(Boolean.TRUE);
+ resultSender.lastResult(Boolean.TRUE);
}
}
@@ -283,7 +300,7 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operation.");
}
}
@@ -297,9 +314,9 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
function = new TestFunction(true, TestFunction.TEST_FUNCTION_SOCKET_TIMEOUT);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
- toRegister = new Boolean(true);
- LogWriterUtils.getLogWriter().info(
+ isByName = Boolean.TRUE;
+ toRegister = Boolean.TRUE;
+ logger.info(
"ClientServerFFunctionExecutionDUnitTest#testServerSingleKeyExecution_byName : Starting test");
client.invoke(() -> ClientServerFunctionExecutionDUnitTest.serverExecution(isByName, function,
toRegister));
@@ -313,9 +330,9 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
function = new TestFunction(true, TestFunction.TEST_FUNCTION_SOCKET_TIMEOUT);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
- toRegister = new Boolean(false);
- LogWriterUtils.getLogWriter().info(
+ isByName = Boolean.TRUE;
+ toRegister = Boolean.FALSE;
+ logger.info(
"ClientServerFFunctionExecutionDUnitTest#testServerSingleKeyExecution_byName : Starting test");
client.invoke(() -> ClientServerFunctionExecutionDUnitTest.serverExecution(isByName, function,
toRegister));
@@ -330,21 +347,20 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
*/
@SuppressWarnings("rawtypes")
@Test
- public void testOnServerFailoverWithOneServerDownHA() throws InterruptedException {
+ public void testOnServerFailoverWithOneServerDownHA() {
// The test code appears to trigger this because the first
// call to the function disconnects from the DS but does not call
// last result;
IgnoredException.addIgnoredException("did not send last result");
createScenario();
- server1.invoke(() -> ClientServerFunctionExecutionDUnitTest.createReplicatedRegion());
+ server1.invoke(ClientServerFunctionExecutionDUnitTest::createReplicatedRegion);
- server2.invoke(() -> ClientServerFunctionExecutionDUnitTest.createReplicatedRegion());
+ server2.invoke(ClientServerFunctionExecutionDUnitTest::createReplicatedRegion);
- server3.invoke(() -> ClientServerFunctionExecutionDUnitTest.createReplicatedRegion());
+ server3.invoke(ClientServerFunctionExecutionDUnitTest::createReplicatedRegion);
- client.invoke(() -> ClientServerFunctionExecutionDUnitTest
- .createProxyRegion(NetworkUtils.getServerHostName(server1.getHost())));
+ client.invoke(ClientServerFunctionExecutionDUnitTest::createProxyRegion);
function = new TestFunction(true, TestFunction.TEST_FUNCTION_HA_SERVER);
registerFunctionAtServer(function);
@@ -352,13 +368,13 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
client.invoke(() -> ClientServerFunctionExecutionDUnitTest
.serverExecutionHAOneServerDown(Boolean.FALSE, function, Boolean.FALSE));
- client.invoke(() -> ClientServerFunctionExecutionDUnitTest.verifyMetaData(new Integer(1),
- new Integer(1)));
+ client.invoke(() -> ClientServerFunctionExecutionDUnitTest.verifyMetaData(1,
+ 1));
}
@SuppressWarnings("rawtypes")
@Test
- public void testOnServerFailoverWithTwoServerDownHA() throws InterruptedException {
+ public void testOnServerFailoverWithTwoServerDownHA() {
// The test code appears to trigger this because the first
// call to the function disconnects from the DS but does not call
// last result;
@@ -366,14 +382,13 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
IgnoredException.addIgnoredException("did not send last result");
createScenario();
- server1.invoke(() -> ClientServerFunctionExecutionDUnitTest.createReplicatedRegion());
+ server1.invoke(ClientServerFunctionExecutionDUnitTest::createReplicatedRegion);
- server2.invoke(() -> ClientServerFunctionExecutionDUnitTest.createReplicatedRegion());
+ server2.invoke(ClientServerFunctionExecutionDUnitTest::createReplicatedRegion);
- server3.invoke(() -> ClientServerFunctionExecutionDUnitTest.createReplicatedRegion());
+ server3.invoke(ClientServerFunctionExecutionDUnitTest::createReplicatedRegion);
- client.invoke(() -> ClientServerFunctionExecutionDUnitTest
- .createProxyRegion(NetworkUtils.getServerHostName(server1.getHost())));
+ client.invoke(ClientServerFunctionExecutionDUnitTest::createProxyRegion);
function = new TestFunction(true, TestFunction.TEST_FUNCTION_HA_SERVER);
registerFunctionAtServer(function);
@@ -381,8 +396,8 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
client.invoke(() -> ClientServerFunctionExecutionDUnitTest
.serverExecutionHATwoServerDown(Boolean.FALSE, function, Boolean.FALSE));
- client.invoke(() -> ClientServerFunctionExecutionDUnitTest.verifyMetaData(new Integer(2),
- new Integer(0)));
+ client.invoke(() -> ClientServerFunctionExecutionDUnitTest.verifyMetaData(2,
+ 0));
}
@@ -391,28 +406,27 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
* shouldn't failover to other available server
*/
@Test
- public void testOnServerFailoverNonHA() throws InterruptedException {
+ public void testOnServerFailoverNonHA() {
// The test code appears to trigger this because the first
// call to the function disconnects from the DS but does not call
// last result;
IgnoredException.addIgnoredException("did not send last result");
createScenario();
- server1.invoke(() -> ClientServerFunctionExecutionDUnitTest.createReplicatedRegion());
+ server1.invoke(ClientServerFunctionExecutionDUnitTest::createReplicatedRegion);
- server2.invoke(() -> ClientServerFunctionExecutionDUnitTest.createReplicatedRegion());
+ server2.invoke(ClientServerFunctionExecutionDUnitTest::createReplicatedRegion);
- server3.invoke(() -> ClientServerFunctionExecutionDUnitTest.createReplicatedRegion());
+ server3.invoke(ClientServerFunctionExecutionDUnitTest::createReplicatedRegion);
- client.invoke(() -> ClientServerFunctionExecutionDUnitTest
- .createProxyRegion(NetworkUtils.getServerHostName(server1.getHost())));
+ client.invoke(ClientServerFunctionExecutionDUnitTest::createProxyRegion);
function = new TestFunction(true, TestFunction.TEST_FUNCTION_NONHA_SERVER);
registerFunctionAtServer(function);
client.invoke(() -> ClientServerFunctionExecutionDUnitTest.serverExecutionNonHA(Boolean.FALSE,
function, Boolean.FALSE));
- client.invoke(() -> ClientServerFunctionExecutionDUnitTest.verifyMetaData(new Integer(1),
- new Integer(0)));
+ client.invoke(() -> ClientServerFunctionExecutionDUnitTest.verifyMetaData(1,
+ 0));
}
@@ -443,8 +457,7 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
server3.invoke(ClientServerFunctionExecutionDUnitTest::createReplicatedRegion);
client.invoke(() -> {
- ClientServerFunctionExecutionDUnitTest
- .createProxyRegion(NetworkUtils.getServerHostName(server1.getHost()));
+ ClientServerFunctionExecutionDUnitTest.createProxyRegion();
assertThatThrownBy(() -> HijackedFunctionService.onRegion(metaDataRegion).execute(function))
.isInstanceOf(IllegalStateException.class)
.hasMessageMatching("Could not find a pool named (.*)");
@@ -470,16 +483,16 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
}
private void createScenario() {
- LogWriterUtils.getLogWriter()
+ logger
.info("ClientServerFFunctionExecutionDUnitTest#createScenario : creating scenario");
createClientServerScenarionWithoutRegion();
}
- public static void serverExecution(Boolean isByName, Function function, Boolean toRegister) {
+ private static void serverExecution(Boolean isByName, Function function, Boolean toRegister) {
DistributedSystem.setThreadsSocketPolicy(false);
- if (toRegister.booleanValue()) {
+ if (toRegister) {
FunctionService.registerFunction(function);
}
Execution member = FunctionService.onServer(pool);
@@ -490,32 +503,32 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operation");
}
try {
- final HashSet testKeysSet = new HashSet();
+ final HashSet<String> testKeysSet = new HashSet<>();
for (int i = 0; i < 20; i++) {
testKeysSet.add("execKey-" + i);
}
ResultCollector rs = execute(member, testKeysSet, function, isByName);
- List resultList = (List) ((List) rs.getResult());
+ List resultList = (List) rs.getResult();
for (int i = 0; i < 20; i++) {
- assertEquals(true, ((List) (resultList.get(0))).contains("execKey-" + i));
+ assertTrue(((List) (resultList.get(0))).contains("execKey-" + i));
}
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operations");
}
}
- public static void executeRegisteredFunction() {
+ private static void executeRegisteredFunction() {
DistributedSystem.setThreadsSocketPolicy(false);
Execution member = FunctionService.onServer(pool);
@@ -529,12 +542,12 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
}
- public static void serverExecution_SendException(Boolean isByName, Function function,
+ private static void serverExecution_SendException(Boolean isByName, Function function,
Boolean toRegister) {
DistributedSystem.setThreadsSocketPolicy(false);
- if (toRegister.booleanValue()) {
+ if (toRegister) {
FunctionService.registerFunction(function);
}
Execution member = FunctionService.onServer(pool);
@@ -545,12 +558,12 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operation");
}
try {
- final HashSet testKeysSet = new HashSet();
+ final HashSet<String> testKeysSet = new HashSet<>();
for (int i = 0; i < 20; i++) {
testKeysSet.add("execKey-" + i);
}
@@ -571,16 +584,16 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operations");
}
}
- public static void createReplicatedRegion() {
+ private static void createReplicatedRegion() {
metaDataRegion = cache.createRegionFactory(RegionShortcut.REPLICATE).create(retryRegionName);
}
- public static void createProxyRegion(String hostName) {
+ public static void createProxyRegion() {
CacheServerTestUtil.disableShufflingOfEndpoints();
AttributesFactory factory = new AttributesFactory();
factory.setScope(Scope.LOCAL);
@@ -591,7 +604,7 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
assertNotNull(metaDataRegion);
}
- public static void verifyMetaData(Integer arg1, Integer arg2) {
+ private static void verifyMetaData(Integer arg1, Integer arg2) {
try {
if (arg1 == 0) {
assertNull(metaDataRegion.get("stopped"));
@@ -610,20 +623,19 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
}
}
- public static void verifyDeadAndLiveServers(final Integer expectedDeadServers,
- final Integer expectedLiveServers) {
+ public static void verifyDeadAndLiveServers(final Integer expectedLiveServers) {
WaitCriterion wc = new WaitCriterion() {
String excuse;
@Override
public boolean done() {
int sz = pool.getConnectedServerCount();
- getLogWriter().info("Checking for the Live Servers : Expected : "
- + expectedLiveServers + " Available :" + sz);
- if (sz == expectedLiveServers.intValue()) {
+ logger.info("Checking for the Live Servers : Expected : " + expectedLiveServers
+ + " Available :" + sz);
+ if (sz == expectedLiveServers) {
return true;
}
- excuse = "Expected " + expectedLiveServers.intValue() + " but found " + sz;
+ excuse = "Expected " + expectedLiveServers + " but found " + sz;
return false;
}
@@ -635,72 +647,72 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
GeodeAwaitility.await().untilAsserted(wc);
}
- public static Object serverExecutionHAOneServerDown(Boolean isByName, Function function,
+ private static Object serverExecutionHAOneServerDown(Boolean isByName, Function function,
Boolean toRegister) {
DistributedSystem.setThreadsSocketPolicy(false);
- if (toRegister.booleanValue()) {
+ if (toRegister) {
FunctionService.registerFunction(function);
}
Execution member = FunctionService.onServer(pool);
ResultCollector rs = null;
try {
- ArrayList<String> args = new ArrayList<String>();
+ ArrayList<String> args = new ArrayList<>();
args.add(retryRegionName);
args.add("serverExecutionHAOneServerDown");
rs = execute(member, args, function, isByName);
assertEquals(retryRegionName, ((List) rs.getResult()).get(0));
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operation");
}
return rs.getResult();
}
- public static void serverExecutionHATwoServerDown(Boolean isByName, Function function,
+ private static void serverExecutionHATwoServerDown(Boolean isByName, Function function,
Boolean toRegister) {
DistributedSystem.setThreadsSocketPolicy(false);
- if (toRegister.booleanValue()) {
+ if (toRegister) {
FunctionService.registerFunction(function);
}
Execution member = FunctionService.onServer(pool);
try {
- ArrayList<String> args = new ArrayList<String>();
+ ArrayList<String> args = new ArrayList<>();
args.add(retryRegionName);
args.add("serverExecutionHATwoServerDown");
- ResultCollector rs = execute(member, args, function, isByName);
+ execute(member, args, function, isByName);
fail("Expected ServerConnectivityException not thrown!");
} catch (Exception ex) {
if (!(ex instanceof ServerConnectivityException)) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operation");
}
}
}
- public static Object serverExecutionNonHA(Boolean isByName, Function function,
+ private static Object serverExecutionNonHA(Boolean isByName, Function function,
Boolean toRegister) {
DistributedSystem.setThreadsSocketPolicy(false);
- if (toRegister.booleanValue()) {
+ if (toRegister) {
FunctionService.registerFunction(function);
}
Execution member = FunctionService.onServer(pool);
try {
- ArrayList<String> args = new ArrayList<String>();
+ ArrayList<String> args = new ArrayList<>();
args.add(retryRegionName);
args.add("serverExecutionNonHA");
- ResultCollector rs = execute(member, args, function, isByName);
+ execute(member, args, function, isByName);
fail("Expected ServerConnectivityException not thrown!");
} catch (Exception ex) {
if (!(ex instanceof ServerConnectivityException)) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operation");
}
}
@@ -708,19 +720,20 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
}
@SuppressWarnings("rawtypes")
- public static void serverFunctionExecution_FunctionInvocationTargetException(Boolean isByName,
- Function function, Boolean toRegister) {
+ private static void serverFunctionExecution_FunctionInvocationTargetException(Boolean isByName,
+ Function function,
+ Boolean toRegister) {
DistributedSystem.setThreadsSocketPolicy(false);
- if (toRegister.booleanValue()) {
+ if (toRegister) {
FunctionService.registerFunction(function);
}
Execution member = FunctionService.onServer(pool);
try {
ResultCollector rs = execute(member, Boolean.TRUE, function, isByName);
ArrayList list = (ArrayList) rs.getResult();
- assertTrue("Value of send result of the executed function : " + list.get(0)
- + "does not match the expected value : " + 1, ((Integer) list.get(0)) == 1);
+ assertEquals("Value of send result of the executed function : " + list.get(0)
+ + "does not match the expected value : " + 1, 1, (int) ((Integer) list.get(0)));
assertTrue("Value of last result of the executed function : " + list.get(0)
+ "is not equal or more than expected value : " + 5, ((Integer) list.get(1)) >= 5);
} catch (Exception ex) {
@@ -729,12 +742,12 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
}
}
- public static void serverExecution_NoLastResult(Boolean isByName, Function function,
+ private static void serverExecution_NoLastResult(Boolean isByName, Function function,
Boolean toRegister) {
DistributedSystem.setThreadsSocketPolicy(false);
- if (toRegister.booleanValue()) {
+ if (toRegister) {
FunctionService.registerFunction(function);
}
Execution member = FunctionService.onServer(pool);
@@ -750,7 +763,7 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
}
- public static void serverExecution_Inline() {
+ private static void serverExecution_Inline() {
DistributedSystem.setThreadsSocketPolicy(false);
Execution member = FunctionService.onServer(pool);
@@ -759,10 +772,12 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
ResultCollector rs = member.setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
} else if (context.getArguments() instanceof Boolean) {
- context.getResultSender().lastResult(Boolean.TRUE);
+ resultSender.lastResult(Boolean.TRUE);
}
}
@@ -780,24 +795,26 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operation nn TRUE");
}
}
- public static void serverExecution_Inline_InvalidAttributes() {
+ private static void serverExecution_Inline_InvalidAttributes() {
DistributedSystem.setThreadsSocketPolicy(false);
Execution member = FunctionService.onServer(pool);
try {
- ResultCollector rs = member.setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
+ member.setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
} else if (context.getArguments() instanceof Boolean) {
- context.getResultSender().lastResult(Boolean.TRUE);
+ resultSender.lastResult(Boolean.TRUE);
}
}
@@ -820,17 +837,17 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
fail("Should have failed with Invalid attributes.");
} catch (Exception ex) {
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
assertTrue(
ex.getMessage().contains("For Functions with isHA true, hasResult must also be true."));
}
}
- public static void allServerExecution(Boolean isByName, Function function, Boolean toRegister) {
+ private static void allServerExecution(Boolean isByName, Function function, Boolean toRegister) {
DistributedSystem.setThreadsSocketPolicy(false);
- if (toRegister.booleanValue()) {
+ if (toRegister) {
FunctionService.registerFunction(function);
} else {
FunctionService.unregisterFunction(function.getId());
@@ -847,13 +864,13 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operation");
}
try {
- final HashSet testKeysSet = new HashSet();
+ final HashSet<String> testKeysSet = new HashSet<>();
for (int i = 0; i < 20; i++) {
testKeysSet.add("execKey-" + i);
}
@@ -864,23 +881,23 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 20; k++) {
- assertEquals(true, (((List) (resultList).get(j)).contains("execKey-" + k)));
+ assertTrue((((List) (resultList).get(j)).contains("execKey-" + k)));
}
}
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operation");
}
}
- public static void allServerExecution_SendException(Boolean isByName, Function function,
+ private static void allServerExecution_SendException(Boolean isByName, Function function,
Boolean toRegister) {
DistributedSystem.setThreadsSocketPolicy(false);
- if (toRegister.booleanValue()) {
+ if (toRegister) {
FunctionService.registerFunction(function);
} else {
FunctionService.unregisterFunction(function.getId());
@@ -897,12 +914,12 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operation");
}
try {
- final HashSet testKeysSet = new HashSet();
+ final HashSet<String> testKeysSet = new HashSet<>();
for (int i = 0; i < 20; i++) {
testKeysSet.add("execKey-" + i);
}
@@ -922,17 +939,17 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operation");
}
}
- public static void allServerExecution_NoLastResult(Boolean isByName, Function function,
+ private static void allServerExecution_NoLastResult(Boolean isByName, Function function,
Boolean toRegister) {
DistributedSystem.setThreadsSocketPolicy(false);
- if (toRegister.booleanValue()) {
+ if (toRegister) {
FunctionService.registerFunction(function);
} else {
FunctionService.unregisterFunction(function.getId());
@@ -941,24 +958,26 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
Execution member = FunctionService.onServers(pool);
try {
ResultCollector rs = execute(member, Boolean.TRUE, function, isByName);
- List resultList = (List) rs.getResult();
+ rs.getResult();
fail("Expected FunctionException : Function did not send last result");
} catch (Exception ex) {
assertTrue(ex.getMessage().contains("did not send last result"));
}
}
- public static void allServerExecution_Inline() {
+ private static void allServerExecution_Inline() {
DistributedSystem.setThreadsSocketPolicy(false);
Execution member = FunctionService.onServers(pool);
try {
ResultCollector rs = member.setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
} else if (context.getArguments() instanceof Boolean) {
- context.getResultSender().lastResult(Boolean.TRUE);
+ resultSender.lastResult(Boolean.TRUE);
}
}
@@ -979,17 +998,17 @@ public class ClientServerFunctionExecutionDUnitTest extends PRClientServerTestBa
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operation asdfasdfa ");
}
}
private static ResultCollector execute(Execution member, Serializable args, Function function,
- Boolean isByName) throws Exception {
- if (isByName.booleanValue()) {// by name
- LogWriterUtils.getLogWriter().info("The function name to execute : " + function.getId());
+ Boolean isByName) {
+ if (isByName) {// by name
+ logger.info("The function name to execute : " + function.getId());
Execution me = member.setArguments(args);
- LogWriterUtils.getLogWriter().info("The args passed : " + args);
+ logger.info("The args passed : " + args);
return me.execute(function.getId());
} else { // By Instance
return member.setArguments(args).execute(function);
diff --git a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/FunctionServiceStatsDUnitTest.java b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/FunctionServiceStatsDUnitTest.java
index 702ce57..5dd8479 100644
--- a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/FunctionServiceStatsDUnitTest.java
+++ b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/FunctionServiceStatsDUnitTest.java
@@ -20,17 +20,20 @@ import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import static org.junit.runners.Parameterized.UseParametersRunnerFactory;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
-import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import java.util.Set;
+import org.apache.logging.log4j.Logger;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.CacheFactory;
@@ -44,9 +47,9 @@ import org.apache.geode.cache.execute.Execution;
import org.apache.geode.cache.execute.Function;
import org.apache.geode.cache.execute.FunctionAdapter;
import org.apache.geode.cache.execute.FunctionContext;
-import org.apache.geode.cache.execute.FunctionException;
import org.apache.geode.cache.execute.FunctionService;
import org.apache.geode.cache.execute.ResultCollector;
+import org.apache.geode.cache.execute.ResultSender;
import org.apache.geode.cache.server.CacheServer;
import org.apache.geode.distributed.ConfigurationProperties;
import org.apache.geode.distributed.DistributedMember;
@@ -58,13 +61,15 @@ import org.apache.geode.internal.cache.PartitionedRegion;
import org.apache.geode.internal.cache.PartitionedRegionTestHelper;
import org.apache.geode.internal.cache.functions.TestFunction;
import org.apache.geode.internal.cache.tier.sockets.CacheServerTestUtil;
+import org.apache.geode.internal.logging.LogService;
import org.apache.geode.test.dunit.Assert;
import org.apache.geode.test.dunit.Host;
-import org.apache.geode.test.dunit.LogWriterUtils;
-import org.apache.geode.test.dunit.SerializableCallable;
+import org.apache.geode.test.dunit.SerializableCallableIF;
+import org.apache.geode.test.dunit.SerializableRunnableIF;
import org.apache.geode.test.dunit.VM;
import org.apache.geode.test.dunit.Wait;
import org.apache.geode.test.junit.categories.FunctionServiceTest;
+import org.apache.geode.test.junit.runners.CategoryWithParameterizedRunnerFactory;
/**
* This is DUnite Test to test the Function Execution stats under various scenarios like
@@ -72,92 +77,74 @@ import org.apache.geode.test.junit.categories.FunctionServiceTest;
* Execution
*/
@Category({FunctionServiceTest.class})
+@RunWith(Parameterized.class)
+@UseParametersRunnerFactory(CategoryWithParameterizedRunnerFactory.class)
public class FunctionServiceStatsDUnitTest extends PRClientServerTestBase {
- static Boolean isByName = null;
+ private static final Logger logger = LogService.getLogger();
static InternalDistributedSystem ds = null;
- static int noOfExecutionCalls_Aggregate = 0;
- static int noOfExecutionsCompleted_Aggregate = 0;
- static int resultReceived_Aggregate = 0;
- static int noOfExecutionExceptions_Aggregate = 0;
-
- static int noOfExecutionCalls_TESTFUNCTION1 = 0;
- static int noOfExecutionsCompleted_TESTFUNCTION1 = 0;
- static int resultReceived_TESTFUNCTION1 = 0;
- static int noOfExecutionExceptions_TESTFUNCTION1 = 0;
-
- static int noOfExecutionCalls_TESTFUNCTION2 = 0;
- static int noOfExecutionsCompleted_TESTFUNCTION2 = 0;
- static int resultReceived_TESTFUNCTION2 = 0;
- static int noOfExecutionExceptions_TESTFUNCTION2 = 0;
-
- static int noOfExecutionCalls_TESTFUNCTION3 = 0;
- static int noOfExecutionsCompleted_TESTFUNCTION3 = 0;
- static int resultReceived_TESTFUNCTION3 = 0;
- static int noOfExecutionExceptions_TESTFUNCTION3 = 0;
-
- static int noOfExecutionCalls_TESTFUNCTION5 = 0;
- static int noOfExecutionsCompleted_TESTFUNCTION5 = 0;
- static int resultReceived_TESTFUNCTION5 = 0;
- static int noOfExecutionExceptions_TESTFUNCTION5 = 0;
-
- static int noOfExecutionCalls_Inline = 0;
- static int noOfExecutionsCompleted_Inline = 0;
- static int resultReceived_Inline = 0;
- static int noOfExecutionExceptions_Inline = 0;
-
- static int noOfExecutionCalls_TestFunctionException = 0;
- static int noOfExecutionsCompleted_TestFunctionException = 0;
- static int resultReceived_TestFunctionException = 0;
- static int noOfExecutionExceptions_TestFunctionException = 0;
+ private static int noOfExecutionCalls_Aggregate = 0;
+ private static int noOfExecutionsCompleted_Aggregate = 0;
+ private static int resultReceived_Aggregate = 0;
+
+ private static int noOfExecutionCalls_TESTFUNCTION1 = 0;
+ private static int noOfExecutionsCompleted_TESTFUNCTION1 = 0;
+ private static int resultReceived_TESTFUNCTION1 = 0;
+
+ private static int noOfExecutionCalls_TESTFUNCTION2 = 0;
+ private static int noOfExecutionsCompleted_TESTFUNCTION2 = 0;
+ private static int resultReceived_TESTFUNCTION2 = 0;
+
+ private static int noOfExecutionCalls_TESTFUNCTION3 = 0;
+ private static int noOfExecutionsCompleted_TESTFUNCTION3 = 0;
+ private static int resultReceived_TESTFUNCTION3 = 0;
+
+ private static int noOfExecutionCalls_TESTFUNCTION5 = 0;
+ private static int noOfExecutionsCompleted_TESTFUNCTION5 = 0;
+ private static int resultReceived_TESTFUNCTION5 = 0;
+
+ private static int noOfExecutionCalls_Inline = 0;
+ private static int noOfExecutionsCompleted_Inline = 0;
+ private static int resultReceived_Inline = 0;
@Override
- protected final void postSetUpPRClientServerTestBase() throws Exception {
+ protected final void postSetUpPRClientServerTestBase() {
// Make sure stats to linger from a previous test
disconnectAllFromDS();
}
- final SerializableCallable initializeStats = new SerializableCallable("initializeStats") {
- @Override
- public Object call() throws Exception {
-
- noOfExecutionCalls_Aggregate = 0;
- noOfExecutionsCompleted_Aggregate = 0;
- resultReceived_Aggregate = 0;
- noOfExecutionExceptions_Aggregate = 0;
-
- noOfExecutionCalls_TESTFUNCTION1 = 0;
- noOfExecutionsCompleted_TESTFUNCTION1 = 0;
- resultReceived_TESTFUNCTION1 = 0;
- noOfExecutionExceptions_TESTFUNCTION1 = 0;
-
- noOfExecutionCalls_TESTFUNCTION2 = 0;
- noOfExecutionsCompleted_TESTFUNCTION2 = 0;
- resultReceived_TESTFUNCTION2 = 0;
- noOfExecutionExceptions_TESTFUNCTION2 = 0;
-
- noOfExecutionCalls_TESTFUNCTION3 = 0;
- noOfExecutionsCompleted_TESTFUNCTION3 = 0;
- resultReceived_TESTFUNCTION3 = 0;
- noOfExecutionExceptions_TESTFUNCTION3 = 0;
-
- noOfExecutionCalls_TESTFUNCTION5 = 0;
- noOfExecutionsCompleted_TESTFUNCTION5 = 0;
- resultReceived_TESTFUNCTION5 = 0;
- noOfExecutionExceptions_TESTFUNCTION5 = 0;
-
- noOfExecutionCalls_Inline = 0;
- noOfExecutionsCompleted_Inline = 0;
- resultReceived_Inline = 0;
- noOfExecutionExceptions_Inline = 0;
-
- noOfExecutionCalls_TestFunctionException = 0;
- noOfExecutionsCompleted_TestFunctionException = 0;
- resultReceived_TestFunctionException = 0;
- noOfExecutionExceptions_TestFunctionException = 0;
- return Boolean.TRUE;
+ private final transient SerializableRunnableIF initializeStats = () -> {
+ noOfExecutionCalls_Aggregate = 0;
+ noOfExecutionsCompleted_Aggregate = 0;
+ resultReceived_Aggregate = 0;
+
+ noOfExecutionCalls_TESTFUNCTION1 = 0;
+ noOfExecutionsCompleted_TESTFUNCTION1 = 0;
+ resultReceived_TESTFUNCTION1 = 0;
+
+ noOfExecutionCalls_TESTFUNCTION2 = 0;
+ noOfExecutionsCompleted_TESTFUNCTION2 = 0;
+ resultReceived_TESTFUNCTION2 = 0;
+
+ noOfExecutionCalls_TESTFUNCTION3 = 0;
+ noOfExecutionsCompleted_TESTFUNCTION3 = 0;
+ resultReceived_TESTFUNCTION3 = 0;
+
+ noOfExecutionCalls_TESTFUNCTION5 = 0;
+ noOfExecutionsCompleted_TESTFUNCTION5 = 0;
+ resultReceived_TESTFUNCTION5 = 0;
+
+ noOfExecutionCalls_Inline = 0;
+ noOfExecutionsCompleted_Inline = 0;
+ resultReceived_Inline = 0;
+ };
+
+ private final transient SerializableRunnableIF closeDistributedSystem = () -> {
+ if (getCache() != null && !getCache().isClosed()) {
+ getCache().close();
+ getCache().getDistributedSystem().disconnect();
}
};
@@ -190,151 +177,128 @@ public class FunctionServiceStatsDUnitTest extends PRClientServerTestBase {
@Test
public void testClientServerPartitonedRegionFunctionExecutionStats() {
createScenario();
- Function function = new TestFunction(true, TestFunction.TEST_FUNCTION2);
- registerFunctionAtServer(function);
- function = new TestFunction(true, TestFunction.TEST_FUNCTION3);
- registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ registerFunctionAtServer(new TestFunction(true, TestFunction.TEST_FUNCTION2));
+ registerFunctionAtServer(new TestFunction(true, TestFunction.TEST_FUNCTION3));
client.invoke(initializeStats);
server1.invoke(initializeStats);
server2.invoke(initializeStats);
server3.invoke(initializeStats);
- SerializableCallable PopulateRegionAndExecuteFunctions =
- new SerializableCallable("PopulateRegionAndExecuteFunctions") {
- @Override
- public Object call() throws Exception {
- Region region = cache.getRegion(PartitionedRegionName);
- assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
- testKeysSet.add("execKey-" + i);
- }
- DistributedSystem.setThreadsSocketPolicy(false);
- Function function = new TestFunction(true, TestFunction.TEST_FUNCTION2);
- FunctionService.registerFunction(function);
- Execution dataSet = FunctionService.onRegion(region);
- try {
- int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
- }
- ResultCollector rc = dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE)
- .execute(function.getId());
- int resultSize = ((List) rc.getResult()).size();
- resultReceived_Aggregate += resultSize;
- resultReceived_TESTFUNCTION2 += resultSize;
- noOfExecutionCalls_Aggregate++;
- noOfExecutionCalls_TESTFUNCTION2++;
- noOfExecutionsCompleted_Aggregate++;
- noOfExecutionsCompleted_TESTFUNCTION2++;
-
- rc = dataSet.withFilter(testKeysSet).setArguments(testKeysSet)
- .execute(function.getId());
- resultSize = ((List) rc.getResult()).size();
- resultReceived_Aggregate += resultSize;
- resultReceived_TESTFUNCTION2 += resultSize;
- noOfExecutionCalls_Aggregate++;
- noOfExecutionCalls_TESTFUNCTION2++;
- noOfExecutionsCompleted_Aggregate++;
- noOfExecutionsCompleted_TESTFUNCTION2++;
-
- function = new TestFunction(true, TestFunction.TEST_FUNCTION3);
- FunctionService.registerFunction(function);
- rc = dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE)
- .execute(function.getId());
- resultSize = ((List) rc.getResult()).size();
- resultReceived_Aggregate += resultSize;
- resultReceived_TESTFUNCTION3 += resultSize;
- noOfExecutionCalls_Aggregate++;
- noOfExecutionCalls_TESTFUNCTION3++;
- noOfExecutionsCompleted_Aggregate++;
- noOfExecutionsCompleted_TESTFUNCTION3++;
-
- } catch (Exception e) {
- LogWriterUtils.getLogWriter().info("Exception : " + e.getMessage());
- e.printStackTrace();
- fail("Test failed after the put operation");
- }
- return Boolean.TRUE;
- }
- };
- client.invoke(PopulateRegionAndExecuteFunctions);
+ client.invoke(() -> {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
+ assertNotNull(region);
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
+ testKeysSet.add("execKey-" + i);
+ }
+ DistributedSystem.setThreadsSocketPolicy(false);
+ Function function = new TestFunction(true, TestFunction.TEST_FUNCTION2);
+ if (shouldRegisterFunctionsOnClient()) {
+ FunctionService.registerFunction(function);
+ }
+ Execution dataSet = FunctionService.onRegion(region);
+ try {
+ int j = 0;
+ for (String s : testKeysSet) {
+ Integer val = j++;
+ region.put(s, val);
+ }
+ ResultCollector rc =
+ dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(function.getId());
+ int resultSize = ((List) rc.getResult()).size();
+ resultReceived_Aggregate += resultSize;
+ resultReceived_TESTFUNCTION2 += resultSize;
+ noOfExecutionCalls_Aggregate++;
+ noOfExecutionCalls_TESTFUNCTION2++;
+ noOfExecutionsCompleted_Aggregate++;
+ noOfExecutionsCompleted_TESTFUNCTION2++;
+
+ rc = dataSet.withFilter(testKeysSet).setArguments(testKeysSet).execute(function.getId());
+ resultSize = ((List) rc.getResult()).size();
+ resultReceived_Aggregate += resultSize;
+ resultReceived_TESTFUNCTION2 += resultSize;
+ noOfExecutionCalls_Aggregate++;
+ noOfExecutionCalls_TESTFUNCTION2++;
+ noOfExecutionsCompleted_Aggregate++;
+ noOfExecutionsCompleted_TESTFUNCTION2++;
- SerializableCallable checkStatsOnClient = new SerializableCallable("checkStatsOnClient") {
- @Override
- public Object call() throws Exception {
- // checks for the aggregate stats
- InternalDistributedSystem iDS = (InternalDistributedSystem) cache.getDistributedSystem();
- FunctionServiceStats functionServiceStats = iDS.getFunctionServiceStats();
- waitNoFunctionsRunning(functionServiceStats);
-
- assertEquals(noOfExecutionCalls_Aggregate,
- functionServiceStats.getFunctionExecutionCalls());
- assertEquals(noOfExecutionsCompleted_Aggregate,
- functionServiceStats.getFunctionExecutionsCompleted());
- assertTrue(functionServiceStats.getResultsReceived() >= resultReceived_Aggregate);
-
- LogWriterUtils.getLogWriter().info("Calling FunctionStats for TEST_FUNCTION2 :");
- FunctionStats functionStats =
- FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION2, iDS);
- LogWriterUtils.getLogWriter().info("Called FunctionStats for TEST_FUNCTION2 :");
- assertEquals(noOfExecutionCalls_TESTFUNCTION2, functionStats.getFunctionExecutionCalls());
- assertEquals(noOfExecutionsCompleted_TESTFUNCTION2,
- functionStats.getFunctionExecutionsCompleted());
- assertTrue(functionStats.getResultsReceived() >= resultReceived_TESTFUNCTION2);
-
- functionStats = FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION3, iDS);
- assertEquals(noOfExecutionCalls_TESTFUNCTION3, functionStats.getFunctionExecutionCalls());
- assertEquals(noOfExecutionsCompleted_TESTFUNCTION3,
- functionStats.getFunctionExecutionsCompleted());
- assertTrue(functionStats.getResultsReceived() >= resultReceived_TESTFUNCTION3);
-
- return Boolean.TRUE;
+ function = new TestFunction(true, TestFunction.TEST_FUNCTION3);
+ FunctionService.registerFunction(function);
+ rc = dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(function.getId());
+ resultSize = ((List) rc.getResult()).size();
+ resultReceived_Aggregate += resultSize;
+ resultReceived_TESTFUNCTION3 += resultSize;
+ noOfExecutionCalls_Aggregate++;
+ noOfExecutionCalls_TESTFUNCTION3++;
+ noOfExecutionsCompleted_Aggregate++;
+ noOfExecutionsCompleted_TESTFUNCTION3++;
+
+ } catch (Exception e) {
+ logger.info("Exception : " + e.getMessage());
+ e.printStackTrace();
+ fail("Test failed after the put operation");
}
- };
+ });
- client.invoke(checkStatsOnClient);
+ client.invoke(() -> {
+ // checks for the aggregate stats
+ InternalDistributedSystem iDS = (InternalDistributedSystem) cache.getDistributedSystem();
+ FunctionServiceStats functionServiceStats = iDS.getFunctionServiceStats();
+ waitNoFunctionsRunning(functionServiceStats);
+
+ assertEquals(noOfExecutionCalls_Aggregate,
+ functionServiceStats.getFunctionExecutionCalls());
+ assertEquals(noOfExecutionsCompleted_Aggregate,
+ functionServiceStats.getFunctionExecutionsCompleted());
+ assertTrue(functionServiceStats.getResultsReceived() >= resultReceived_Aggregate);
+
+ logger.info("Calling FunctionStats for TEST_FUNCTION2 :");
+ FunctionStats functionStats =
+ FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION2, iDS);
+ logger.info("Called FunctionStats for TEST_FUNCTION2 :");
+ assertEquals(noOfExecutionCalls_TESTFUNCTION2, functionStats.getFunctionExecutionCalls());
+ assertEquals(noOfExecutionsCompleted_TESTFUNCTION2,
+ functionStats.getFunctionExecutionsCompleted());
+ assertTrue(functionStats.getResultsReceived() >= resultReceived_TESTFUNCTION2);
+
+ functionStats = FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION3, iDS);
+ assertEquals(noOfExecutionCalls_TESTFUNCTION3, functionStats.getFunctionExecutionCalls());
+ assertEquals(noOfExecutionsCompleted_TESTFUNCTION3,
+ functionStats.getFunctionExecutionsCompleted());
+ assertTrue(functionStats.getResultsReceived() >= resultReceived_TESTFUNCTION3);
+ });
- SerializableCallable checkStatsOnServer = new SerializableCallable("checkStatsOnClient") {
- @Override
- public Object call() throws Exception {
- // checks for the aggregate stats
- InternalDistributedSystem iDS = (InternalDistributedSystem) cache.getDistributedSystem();
- FunctionServiceStats functionServiceStats = iDS.getFunctionServiceStats();
- waitNoFunctionsRunning(functionServiceStats);
-
- // functions are executed 3 times
- noOfExecutionCalls_Aggregate += 3;
- assertTrue(
- functionServiceStats.getFunctionExecutionCalls() >= noOfExecutionCalls_Aggregate);
- noOfExecutionsCompleted_Aggregate += 3;
- assertTrue(functionServiceStats
- .getFunctionExecutionsCompleted() >= noOfExecutionsCompleted_Aggregate);
-
- FunctionStats functionStats =
- FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION2, iDS);
- // TEST_FUNCTION2 is executed twice
- noOfExecutionCalls_TESTFUNCTION2 += 2;
- assertTrue(functionStats.getFunctionExecutionCalls() >= noOfExecutionCalls_TESTFUNCTION2);
- noOfExecutionsCompleted_TESTFUNCTION2 += 2;
- assertTrue(functionStats
- .getFunctionExecutionsCompleted() >= noOfExecutionsCompleted_TESTFUNCTION2);
-
- functionStats = FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION3, iDS);
- // TEST_FUNCTION3 is executed once
- noOfExecutionCalls_TESTFUNCTION3 += 1;
- assertTrue(functionStats.getFunctionExecutionCalls() >= noOfExecutionCalls_TESTFUNCTION3);
- noOfExecutionsCompleted_TESTFUNCTION3 += 1;
- assertTrue(functionStats
- .getFunctionExecutionsCompleted() >= noOfExecutionsCompleted_TESTFUNCTION3);
-
- return Boolean.TRUE;
- }
+ SerializableRunnableIF checkStatsOnServer = () -> {
+ // checks for the aggregate stats
+ InternalDistributedSystem iDS = (InternalDistributedSystem) cache.getDistributedSystem();
+ FunctionServiceStats functionServiceStats = iDS.getFunctionServiceStats();
+ waitNoFunctionsRunning(functionServiceStats);
+
+ // functions are executed 3 times
+ noOfExecutionCalls_Aggregate += 3;
+ assertTrue(
+ functionServiceStats.getFunctionExecutionCalls() >= noOfExecutionCalls_Aggregate);
+ noOfExecutionsCompleted_Aggregate += 3;
+ assertTrue(functionServiceStats
+ .getFunctionExecutionsCompleted() >= noOfExecutionsCompleted_Aggregate);
+
+ FunctionStats functionStats =
+ FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION2, iDS);
+ // TEST_FUNCTION2 is executed twice
+ noOfExecutionCalls_TESTFUNCTION2 += 2;
+ assertTrue(functionStats.getFunctionExecutionCalls() >= noOfExecutionCalls_TESTFUNCTION2);
+ noOfExecutionsCompleted_TESTFUNCTION2 += 2;
+ assertTrue(functionStats
+ .getFunctionExecutionsCompleted() >= noOfExecutionsCompleted_TESTFUNCTION2);
+
+ functionStats = FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION3, iDS);
+ // TEST_FUNCTION3 is executed once
+ noOfExecutionCalls_TESTFUNCTION3 += 1;
+ assertTrue(functionStats.getFunctionExecutionCalls() >= noOfExecutionCalls_TESTFUNCTION3);
+ noOfExecutionsCompleted_TESTFUNCTION3 += 1;
+ assertTrue(functionStats
+ .getFunctionExecutionsCompleted() >= noOfExecutionsCompleted_TESTFUNCTION3);
};
server1.invoke(checkStatsOnServer);
@@ -354,184 +318,159 @@ public class FunctionServiceStatsDUnitTest extends PRClientServerTestBase {
public void testClientServerDistributedRegionFunctionExecutionStats() {
final String regionName = "FunctionServiceStatsDUnitTest";
- SerializableCallable createCahenServer = new SerializableCallable("createCahenServer") {
- @Override
- public Object call() throws Exception {
+ SerializableCallableIF<Integer> createCahenServer = () -> {
+ try {
+ Properties props = new Properties();
+ DistributedSystem ds = getSystem(props);
+ assertNotNull(ds);
+ ds.disconnect();
+ ds = getSystem(props);
+ cache = CacheFactory.create(ds);
+ logger.info("Created Cache on Server");
+ assertNotNull(cache);
+ AttributesFactory factory = new AttributesFactory();
+ factory.setScope(Scope.DISTRIBUTED_ACK);
+ factory.setDataPolicy(DataPolicy.REPLICATE);
+ assertNotNull(cache);
+ Region<String, Integer> region = cache.createRegion(regionName, factory.create());
+ logger.info("Region Created :" + region);
+ assertNotNull(region);
+ for (int i = 1; i <= 200; i++) {
+ region.put("execKey-" + i, i);
+ }
+ CacheServer server = cache.addCacheServer();
+ assertNotNull(server);
+ int port = AvailablePort.getRandomAvailablePort(AvailablePort.SOCKET);
+ server.setPort(port);
try {
- Properties props = new Properties();
- DistributedSystem ds = getSystem(props);
- assertNotNull(ds);
- ds.disconnect();
- ds = getSystem(props);
- cache = CacheFactory.create(ds);
- LogWriterUtils.getLogWriter().info("Created Cache on Server");
- assertNotNull(cache);
- AttributesFactory factory = new AttributesFactory();
- factory.setScope(Scope.DISTRIBUTED_ACK);
- factory.setDataPolicy(DataPolicy.REPLICATE);
- assertNotNull(cache);
- Region region = cache.createRegion(regionName, factory.create());
- LogWriterUtils.getLogWriter().info("Region Created :" + region);
- assertNotNull(region);
- for (int i = 1; i <= 200; i++) {
- region.put("execKey-" + i, new Integer(i));
- }
- CacheServer server = cache.addCacheServer();
- assertNotNull(server);
- int port = AvailablePort.getRandomAvailablePort(AvailablePort.SOCKET);
- server.setPort(port);
- try {
- server.start();
- } catch (IOException e) {
- Assert.fail("Failed to start the Server", e);
- }
- assertTrue(server.isRunning());
- return new Integer(server.getPort());
- } catch (Exception e) {
- Assert.fail("FunctionServiceStatsDUnitTest#createCache() Failed while creating the cache",
- e);
- throw e;
+ server.start();
+ } catch (IOException e) {
+ Assert.fail("Failed to start the Server", e);
}
+ assertTrue(server.isRunning());
+ return server.getPort();
+ } catch (Exception e) {
+ Assert.fail("FunctionServiceStatsDUnitTest#createCache() Failed while creating the cache",
+ e);
+ throw e;
}
};
- final Integer port1 = (Integer) server1.invoke(createCahenServer);
- final Integer port2 = (Integer) server2.invoke(createCahenServer);
- final Integer port3 = (Integer) server3.invoke(createCahenServer);
+ final Integer port1 = server1.invoke(createCahenServer);
+ final Integer port2 = server2.invoke(createCahenServer);
+ final Integer port3 = server3.invoke(createCahenServer);
- SerializableCallable createCaheInClient = new SerializableCallable("createCaheInClient") {
- @Override
- public Object call() throws Exception {
+ client.invoke(() -> {
+ try {
+ Properties props = new Properties();
+ props.put(MCAST_PORT, "0");
+ props.put(LOCATORS, "");
+ DistributedSystem ds = getSystem(props);
+ assertNotNull(ds);
+ ds.disconnect();
+ ds = getSystem(props);
+ cache = CacheFactory.create(ds);
+ logger.info("Created Cache on Client");
+ assertNotNull(cache);
+
+
+ CacheServerTestUtil.disableShufflingOfEndpoints();
+ Pool p;
try {
- Properties props = new Properties();
- props.put(MCAST_PORT, "0");
- props.put(LOCATORS, "");
- DistributedSystem ds = getSystem(props);
- assertNotNull(ds);
- ds.disconnect();
- ds = getSystem(props);
- cache = CacheFactory.create(ds);
- LogWriterUtils.getLogWriter().info("Created Cache on Client");
- assertNotNull(cache);
-
-
- CacheServerTestUtil.disableShufflingOfEndpoints();
- Pool p;
- try {
- p = PoolManager.createFactory().addServer("localhost", port1.intValue())
- .addServer("localhost", port2.intValue()).addServer("localhost", port3.intValue())
- .setPingInterval(250).setSubscriptionEnabled(false).setSubscriptionRedundancy(-1)
- .setReadTimeout(2000).setSocketBufferSize(1000).setMinConnections(6)
- .setMaxConnections(10).setRetryAttempts(3)
- .create("FunctionServiceStatsDUnitTest_pool");
- } finally {
- CacheServerTestUtil.enableShufflingOfEndpoints();
- }
- AttributesFactory factory = new AttributesFactory();
- factory.setScope(Scope.LOCAL);
- factory.setDataPolicy(DataPolicy.EMPTY);
- factory.setPoolName(p.getName());
- assertNotNull(cache);
- Region region = cache.createRegion(regionName, factory.create());
- LogWriterUtils.getLogWriter().info("Client Region Created :" + region);
- assertNotNull(region);
- for (int i = 1; i <= 200; i++) {
- region.put("execKey-" + i, new Integer(i));
- }
- return Boolean.TRUE;
- } catch (Exception e) {
- Assert.fail("FunctionServiceStatsDUnitTest#createCache() Failed while creating the cache",
- e);
- throw e;
+ p = PoolManager.createFactory().addServer("localhost", port1)
+ .addServer("localhost", port2).addServer("localhost", port3)
+ .setPingInterval(250).setSubscriptionEnabled(false).setSubscriptionRedundancy(-1)
+ .setReadTimeout(2000).setSocketBufferSize(1000).setMinConnections(6)
+ .setMaxConnections(10).setRetryAttempts(3)
+ .create("FunctionServiceStatsDUnitTest_pool");
+ } finally {
+ CacheServerTestUtil.enableShufflingOfEndpoints();
+ }
+ AttributesFactory factory = new AttributesFactory();
+ factory.setScope(Scope.LOCAL);
+ factory.setDataPolicy(DataPolicy.EMPTY);
+ factory.setPoolName(p.getName());
+ assertNotNull(cache);
+ Region<String, Integer> region = cache.createRegion(regionName, factory.create());
+ logger.info("Client Region Created :" + region);
+ assertNotNull(region);
+ for (int i = 1; i <= 200; i++) {
+ region.put("execKey-" + i, i);
}
+ } catch (Exception e) {
+ Assert.fail("FunctionServiceStatsDUnitTest#createCache() Failed while creating the cache",
+ e);
+ throw e;
}
- };
- client.invoke(createCaheInClient);
+ });
client.invoke(initializeStats);
server1.invoke(initializeStats);
server2.invoke(initializeStats);
server3.invoke(initializeStats);
- Function function = new TestFunction(true, TestFunction.TEST_FUNCTION2);
- registerFunctionAtServer(function);
- function = new TestFunction(true, TestFunction.TEST_FUNCTION3);
- registerFunctionAtServer(function);
-
- SerializableCallable ExecuteFunctions =
- new SerializableCallable("PopulateRegionAndExecuteFunctions") {
- @Override
- public Object call() throws Exception {
- Function function2 = new TestFunction(true, TestFunction.TEST_FUNCTION2);
- FunctionService.registerFunction(function2);
- Function function3 = new TestFunction(true, TestFunction.TEST_FUNCTION3);
- FunctionService.registerFunction(function3);
- Region region = cache.getRegion(regionName);
- Set filter = new HashSet();
- for (int i = 100; i < 120; i++) {
- filter.add("execKey-" + i);
- }
-
- try {
- noOfExecutionCalls_Aggregate++;
- noOfExecutionCalls_TESTFUNCTION2++;
- List list = (List) FunctionService.onRegion(region).withFilter(filter)
- .execute(function2).getResult();
- noOfExecutionsCompleted_Aggregate++;
- noOfExecutionsCompleted_TESTFUNCTION2++;
- int size = list.size();
- resultReceived_Aggregate += size;
- resultReceived_TESTFUNCTION2 += size;
-
- noOfExecutionCalls_Aggregate++;
- noOfExecutionCalls_TESTFUNCTION2++;
- list = (List) FunctionService.onRegion(region).withFilter(filter).execute(function2)
- .getResult();
- noOfExecutionsCompleted_Aggregate++;
- noOfExecutionsCompleted_TESTFUNCTION2++;
- size = list.size();
- resultReceived_Aggregate += size;
- resultReceived_TESTFUNCTION2 += size;
-
- return Boolean.TRUE;
- } catch (FunctionException e) {
- e.printStackTrace();
- Assert.fail("test failed due to", e);
- throw e;
- } catch (Exception e) {
- e.printStackTrace();
- Assert.fail("test failed due to", e);
- throw e;
- }
+ registerFunctionAtServer(new TestFunction(true, TestFunction.TEST_FUNCTION2));
+ registerFunctionAtServer(new TestFunction(true, TestFunction.TEST_FUNCTION3));
- }
- };
- client.invoke(ExecuteFunctions);
+ client.invoke(() -> {
+ Function function2 = new TestFunction(true, TestFunction.TEST_FUNCTION2);
+ Function function3 = new TestFunction(true, TestFunction.TEST_FUNCTION3);
+ if (shouldRegisterFunctionsOnClient()) {
+ FunctionService.registerFunction(function2);
+ FunctionService.registerFunction(function3);
+ }
+ Region region = cache.getRegion(regionName);
+ Set<String> filter = new HashSet<>();
+ for (int i = 100; i < 120; i++) {
+ filter.add("execKey-" + i);
+ }
- SerializableCallable checkStatsOnClient = new SerializableCallable("checkStatsOnClient") {
- @Override
- public Object call() throws Exception {
- // checks for the aggregate stats
- InternalDistributedSystem iDS = (InternalDistributedSystem) cache.getDistributedSystem();
- FunctionServiceStats functionServiceStats = iDS.getFunctionServiceStats();
- waitNoFunctionsRunning(functionServiceStats);
-
- assertEquals(noOfExecutionCalls_Aggregate,
- functionServiceStats.getFunctionExecutionCalls());
- assertEquals(noOfExecutionsCompleted_Aggregate,
- functionServiceStats.getFunctionExecutionsCompleted());
- assertEquals(resultReceived_Aggregate, functionServiceStats.getResultsReceived());
-
- FunctionStats functionStats =
- FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION2, iDS);
- assertEquals(noOfExecutionCalls_TESTFUNCTION2, functionStats.getFunctionExecutionCalls());
- assertEquals(noOfExecutionsCompleted_TESTFUNCTION2,
- functionStats.getFunctionExecutionsCompleted());
- assertEquals(resultReceived_TESTFUNCTION2, functionStats.getResultsReceived());
-
- return Boolean.TRUE;
+ try {
+ noOfExecutionCalls_Aggregate++;
+ noOfExecutionCalls_TESTFUNCTION2++;
+ List list = (List) FunctionService.onRegion(region).withFilter(filter)
+ .execute(function2).getResult();
+ noOfExecutionsCompleted_Aggregate++;
+ noOfExecutionsCompleted_TESTFUNCTION2++;
+ int size = list.size();
+ resultReceived_Aggregate += size;
+ resultReceived_TESTFUNCTION2 += size;
+
+ noOfExecutionCalls_Aggregate++;
+ noOfExecutionCalls_TESTFUNCTION2++;
+ list = (List) FunctionService.onRegion(region).withFilter(filter).execute(function2)
+ .getResult();
+ noOfExecutionsCompleted_Aggregate++;
+ noOfExecutionsCompleted_TESTFUNCTION2++;
+ size = list.size();
+ resultReceived_Aggregate += size;
+ resultReceived_TESTFUNCTION2 += size;
+ } catch (Exception e) {
+ e.printStackTrace();
+ Assert.fail("test failed due to", e);
+ throw e;
}
- };
- client.invoke(checkStatsOnClient);
+
+ });
+
+ client.invoke(() -> {
+ // checks for the aggregate stats
+ InternalDistributedSystem iDS = (InternalDistributedSystem) cache.getDistributedSystem();
+ FunctionServiceStats functionServiceStats = iDS.getFunctionServiceStats();
+ waitNoFunctionsRunning(functionServiceStats);
+
+ assertEquals(noOfExecutionCalls_Aggregate,
+ functionServiceStats.getFunctionExecutionCalls());
+ assertEquals(noOfExecutionsCompleted_Aggregate,
+ functionServiceStats.getFunctionExecutionsCompleted());
+ assertEquals(resultReceived_Aggregate, functionServiceStats.getResultsReceived());
+
+ FunctionStats functionStats =
+ FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION2, iDS);
+ assertEquals(noOfExecutionCalls_TESTFUNCTION2, functionStats.getFunctionExecutionCalls());
+ assertEquals(noOfExecutionsCompleted_TESTFUNCTION2,
+ functionStats.getFunctionExecutionsCompleted());
+ assertEquals(resultReceived_TESTFUNCTION2, functionStats.getResultsReceived());
+ });
}
/**
@@ -543,148 +482,131 @@ public class FunctionServiceStatsDUnitTest extends PRClientServerTestBase {
@Test
public void testClientServerwithoutRegion() {
createClientServerScenarionWithoutRegion();
- Function function = new TestFunction(true, TestFunction.TEST_FUNCTION1);
- registerFunctionAtServer(function);
- function = new TestFunction(true, TestFunction.TEST_FUNCTION5);
- registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ registerFunctionAtServer(new TestFunction(true, TestFunction.TEST_FUNCTION1));
+ registerFunctionAtServer(new TestFunction(true, TestFunction.TEST_FUNCTION5));
client.invoke(initializeStats);
server1.invoke(initializeStats);
server2.invoke(initializeStats);
server3.invoke(initializeStats);
- SerializableCallable ExecuteFunction = new SerializableCallable("ExecuteFunction") {
- @Override
- public Object call() throws Exception {
- DistributedSystem.setThreadsSocketPolicy(false);
- Function function = new TestFunction(true, TestFunction.TEST_FUNCTION1);
+ client.invoke(() -> {
+ DistributedSystem.setThreadsSocketPolicy(false);
+ Function function = new TestFunction(true, TestFunction.TEST_FUNCTION1);
+ if (shouldRegisterFunctionsOnClient()) {
FunctionService.registerFunction(function);
- Execution member = FunctionService.onServers(pool);
+ }
+ Execution member = FunctionService.onServers(pool);
- try {
- ResultCollector rs = member.setArguments(Boolean.TRUE).execute(function.getId());
- int size = ((List) rs.getResult()).size();
- resultReceived_Aggregate += size;
- noOfExecutionCalls_Aggregate++;
- noOfExecutionsCompleted_Aggregate++;
- resultReceived_TESTFUNCTION1 += size;
- noOfExecutionCalls_TESTFUNCTION1++;
- noOfExecutionsCompleted_TESTFUNCTION1++;
- } catch (Exception ex) {
- ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
- fail("Test failed after the execute operation nn TRUE");
- }
- function = new TestFunction(true, TestFunction.TEST_FUNCTION5);
+ try {
+ ResultCollector rs = member.setArguments(Boolean.TRUE).execute(function.getId());
+ int size = ((List) rs.getResult()).size();
+ resultReceived_Aggregate += size;
+ noOfExecutionCalls_Aggregate++;
+ noOfExecutionsCompleted_Aggregate++;
+ resultReceived_TESTFUNCTION1 += size;
+ noOfExecutionCalls_TESTFUNCTION1++;
+ noOfExecutionsCompleted_TESTFUNCTION1++;
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ logger.info("Exception : ", ex);
+ fail("Test failed after the execute operation nn TRUE");
+ }
+ function = new TestFunction(true, TestFunction.TEST_FUNCTION5);
+ if (shouldRegisterFunctionsOnClient()) {
FunctionService.registerFunction(function);
- try {
- final HashSet testKeysSet = new HashSet();
- for (int i = 0; i < 20; i++) {
- testKeysSet.add("execKey-" + i);
- }
- ResultCollector rs = member.setArguments("Success").execute(function.getId());
- int size = ((List) rs.getResult()).size();
- resultReceived_Aggregate += size;
- noOfExecutionCalls_Aggregate++;
- noOfExecutionsCompleted_Aggregate++;
- resultReceived_TESTFUNCTION5 += size;
- noOfExecutionCalls_TESTFUNCTION5++;
- noOfExecutionsCompleted_TESTFUNCTION5++;
- } catch (Exception ex) {
- ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
- fail("Test failed after the execute operationssssss");
- }
- return Boolean.TRUE;
}
- };
- client.invoke(ExecuteFunction);
-
- SerializableCallable checkStatsOnClient = new SerializableCallable("checkStatsOnClient") {
- @Override
- public Object call() throws Exception {
- // checks for the aggregate stats
- InternalDistributedSystem iDS = (InternalDistributedSystem) cache.getDistributedSystem();
- FunctionServiceStats functionServiceStats = iDS.getFunctionServiceStats();
- waitNoFunctionsRunning(functionServiceStats);
-
- assertEquals(noOfExecutionCalls_Aggregate,
- functionServiceStats.getFunctionExecutionCalls());
- assertEquals(noOfExecutionsCompleted_Aggregate,
- functionServiceStats.getFunctionExecutionsCompleted());
- assertEquals(resultReceived_Aggregate, functionServiceStats.getResultsReceived());
-
- FunctionStats functionStats =
- FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION1, iDS);
- assertEquals(noOfExecutionCalls_TESTFUNCTION1, functionStats.getFunctionExecutionCalls());
- assertEquals(noOfExecutionsCompleted_TESTFUNCTION1,
- functionStats.getFunctionExecutionsCompleted());
- assertEquals(resultReceived_TESTFUNCTION1, functionStats.getResultsReceived());
-
- functionStats = FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION5, iDS);
- assertEquals(noOfExecutionCalls_TESTFUNCTION5, functionStats.getFunctionExecutionCalls());
- assertEquals(noOfExecutionsCompleted_TESTFUNCTION5,
- functionStats.getFunctionExecutionsCompleted());
- assertEquals(resultReceived_TESTFUNCTION5, functionStats.getResultsReceived());
-
- return Boolean.TRUE;
+ try {
+ ResultCollector rs = member.setArguments("Success").execute(function.getId());
+ int size = ((List) rs.getResult()).size();
+ resultReceived_Aggregate += size;
+ noOfExecutionCalls_Aggregate++;
+ noOfExecutionsCompleted_Aggregate++;
+ resultReceived_TESTFUNCTION5 += size;
+ noOfExecutionCalls_TESTFUNCTION5++;
+ noOfExecutionsCompleted_TESTFUNCTION5++;
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ logger.info("Exception : ", ex);
+ fail("Test failed after the execute operationssssss");
}
- };
+ });
- client.invoke(checkStatsOnClient);
- SerializableCallable checkStatsOnServer = new SerializableCallable("checkStatsOnClient") {
- @Override
- public Object call() throws Exception {
- // checks for the aggregate stats
- InternalDistributedSystem iDS = (InternalDistributedSystem) cache.getDistributedSystem();
- FunctionServiceStats functionServiceStats = iDS.getFunctionServiceStats();
- waitNoFunctionsRunning(functionServiceStats);
-
- // functions are executed 2 times
- noOfExecutionCalls_Aggregate += 2;
- assertEquals(noOfExecutionCalls_Aggregate,
- functionServiceStats.getFunctionExecutionCalls());
- noOfExecutionsCompleted_Aggregate += 2;
- // this check is time sensitive, so allow it to fail a few times
- // before giving up
- for (int i = 0; i < 10; i++) {
+ client.invoke(() -> {
+ // checks for the aggregate stats
+ InternalDistributedSystem iDS = (InternalDistributedSystem) cache.getDistributedSystem();
+ FunctionServiceStats functionServiceStats = iDS.getFunctionServiceStats();
+ waitNoFunctionsRunning(functionServiceStats);
+
+ assertEquals(noOfExecutionCalls_Aggregate,
+ functionServiceStats.getFunctionExecutionCalls());
+ assertEquals(noOfExecutionsCompleted_Aggregate,
+ functionServiceStats.getFunctionExecutionsCompleted());
+ assertEquals(resultReceived_Aggregate, functionServiceStats.getResultsReceived());
+
+ FunctionStats functionStats =
+ FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION1, iDS);
+ assertEquals(noOfExecutionCalls_TESTFUNCTION1, functionStats.getFunctionExecutionCalls());
+ assertEquals(noOfExecutionsCompleted_TESTFUNCTION1,
+ functionStats.getFunctionExecutionsCompleted());
+ assertEquals(resultReceived_TESTFUNCTION1, functionStats.getResultsReceived());
+
+ functionStats = FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION5, iDS);
+ assertEquals(noOfExecutionCalls_TESTFUNCTION5, functionStats.getFunctionExecutionCalls());
+ assertEquals(noOfExecutionsCompleted_TESTFUNCTION5,
+ functionStats.getFunctionExecutionsCompleted());
+ assertEquals(resultReceived_TESTFUNCTION5, functionStats.getResultsReceived());
+
+ });
+
+ SerializableRunnableIF checkStatsOnServer = () -> {
+ // checks for the aggregate stats
+ InternalDistributedSystem iDS = (InternalDistributedSystem) cache.getDistributedSystem();
+ FunctionServiceStats functionServiceStats = iDS.getFunctionServiceStats();
+ waitNoFunctionsRunning(functionServiceStats);
+
+ // functions are executed 2 times
+ noOfExecutionCalls_Aggregate += 2;
+ assertEquals(noOfExecutionCalls_Aggregate,
+ functionServiceStats.getFunctionExecutionCalls());
+ noOfExecutionsCompleted_Aggregate += 2;
+ // this check is time sensitive, so allow it to fail a few times
+ // before giving up
+ for (int i = 0; i < 10; i++) {
+ try {
+ assertEquals(noOfExecutionsCompleted_Aggregate,
+ functionServiceStats.getFunctionExecutionsCompleted());
+ } catch (RuntimeException r) {
+ if (i == 9) {
+ throw r;
+ }
try {
- assertEquals(noOfExecutionsCompleted_Aggregate,
- functionServiceStats.getFunctionExecutionsCompleted());
- } catch (RuntimeException r) {
- if (i == 9) {
- throw r;
- }
- try {
- Thread.sleep(1000);
- } catch (InterruptedException ie) {
- Thread.currentThread().interrupt();
- throw r;
- }
+ Thread.sleep(1000);
+ } catch (InterruptedException ie) {
+ Thread.currentThread().interrupt();
+ throw r;
}
}
-
- FunctionStats functionStats =
- FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION1, iDS);
- // TEST_FUNCTION1 is executed once
- noOfExecutionCalls_TESTFUNCTION1 += 1;
- assertEquals(noOfExecutionCalls_TESTFUNCTION1, functionStats.getFunctionExecutionCalls());
- noOfExecutionsCompleted_TESTFUNCTION1 += 1;
- assertEquals(noOfExecutionsCompleted_TESTFUNCTION1,
- functionStats.getFunctionExecutionsCompleted());
-
- functionStats = FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION5, iDS);
- // TEST_FUNCTION5 is executed once
- noOfExecutionCalls_TESTFUNCTION5 += 1;
- assertEquals(noOfExecutionCalls_TESTFUNCTION5, functionStats.getFunctionExecutionCalls());
- noOfExecutionsCompleted_TESTFUNCTION5 += 1;
- assertEquals(noOfExecutionsCompleted_TESTFUNCTION5,
- functionStats.getFunctionExecutionsCompleted());
-
- return Boolean.TRUE;
}
+
+ FunctionStats functionStats =
+ FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION1, iDS);
+ // TEST_FUNCTION1 is executed once
+ noOfExecutionCalls_TESTFUNCTION1 += 1;
+ assertEquals(noOfExecutionCalls_TESTFUNCTION1, functionStats.getFunctionExecutionCalls());
+ noOfExecutionsCompleted_TESTFUNCTION1 += 1;
+ assertEquals(noOfExecutionsCompleted_TESTFUNCTION1,
+ functionStats.getFunctionExecutionsCompleted());
+
+ functionStats = FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION5, iDS);
+ // TEST_FUNCTION5 is executed once
+ noOfExecutionCalls_TESTFUNCTION5 += 1;
+ assertEquals(noOfExecutionCalls_TESTFUNCTION5, functionStats.getFunctionExecutionCalls());
+ noOfExecutionsCompleted_TESTFUNCTION5 += 1;
+ assertEquals(noOfExecutionsCompleted_TESTFUNCTION5,
+ functionStats.getFunctionExecutionsCompleted());
+
};
server1.invoke(checkStatsOnServer);
@@ -693,23 +615,12 @@ public class FunctionServiceStatsDUnitTest extends PRClientServerTestBase {
}
@Test
- public void testP2PDummyExecutionStats() throws Exception {
+ public void testP2PDummyExecutionStats() {
Host host = Host.getHost(0);
final VM datastore0 = host.getVM(0);
final VM datastore1 = host.getVM(1);
final VM datastore2 = host.getVM(2);
final VM accessor = host.getVM(3);
- SerializableCallable closeDistributedSystem =
- new SerializableCallable("closeDistributedSystem") {
- @Override
- public Object call() throws Exception {
- if (getCache() != null && !getCache().isClosed()) {
- getCache().close();
- getCache().getDistributedSystem().disconnect();
- }
- return Boolean.TRUE;
- }
- };
accessor.invoke(closeDistributedSystem);
datastore0.invoke(closeDistributedSystem);
datastore1.invoke(closeDistributedSystem);
@@ -724,7 +635,7 @@ public class FunctionServiceStatsDUnitTest extends PRClientServerTestBase {
* function execution calls from the accessor.
*/
@Test
- public void testP2PPartitionedRegionsFunctionExecutionStats() throws Exception {
+ public void testP2PPartitionedRegionsFunctionExecutionStats() {
final String rName = getUniqueName();
Host host = Host.getHost(0);
final VM datastore0 = host.getVM(0);
@@ -737,167 +648,130 @@ public class FunctionServiceStatsDUnitTest extends PRClientServerTestBase {
datastore2.invoke(initializeStats);
accessor.invoke(initializeStats);
- accessor.invoke(new SerializableCallable("Create PR") {
- @Override
- public Object call() throws Exception {
- RegionAttributes ra = PartitionedRegionTestHelper.createRegionAttrsForPR(0, 0);
- AttributesFactory raf = new AttributesFactory(ra);
- PartitionAttributesImpl pa = new PartitionAttributesImpl();
- pa.setAll(ra.getPartitionAttributes());
- pa.setTotalNumBuckets(17);
- raf.setPartitionAttributes(pa);
-
- PartitionedRegion pr = (PartitionedRegion) getCache().createRegion(rName, raf.create());
- return Boolean.TRUE;
- }
+ accessor.invoke(() -> {
+ RegionAttributes ra = PartitionedRegionTestHelper.createRegionAttrsForPR(0, 0);
+ AttributesFactory raf = new AttributesFactory(ra);
+ PartitionAttributesImpl pa = new PartitionAttributesImpl();
+ pa.setAll(ra.getPartitionAttributes());
+ pa.setTotalNumBuckets(17);
+ raf.setPartitionAttributes(pa);
+
+ getCache().createRegion(rName, raf.create());
});
- SerializableCallable dataStoreCreate =
- new SerializableCallable("Create PR with Function Factory") {
- @Override
- public Object call() throws Exception {
- RegionAttributes ra = PartitionedRegionTestHelper.createRegionAttrsForPR(0, 10);
- AttributesFactory raf = new AttributesFactory(ra);
- PartitionAttributesImpl pa = new PartitionAttributesImpl();
- pa.setAll(ra.getPartitionAttributes());
- pa.setTotalNumBuckets(17);
- raf.setPartitionAttributes(pa);
- PartitionedRegion pr = (PartitionedRegion) getCache().createRegion(rName, raf.create());
- Function function = new TestFunction(true, TestFunction.TEST_FUNCTION2);
- FunctionService.registerFunction(function);
- function = new TestFunction(true, TestFunction.TEST_FUNCTION3);
- FunctionService.registerFunction(function);
- return Boolean.TRUE;
- }
- };
+ SerializableRunnableIF dataStoreCreate = () -> {
+ RegionAttributes ra = PartitionedRegionTestHelper.createRegionAttrsForPR(0, 10);
+ AttributesFactory raf = new AttributesFactory(ra);
+ PartitionAttributesImpl pa = new PartitionAttributesImpl();
+ pa.setAll(ra.getPartitionAttributes());
+ pa.setTotalNumBuckets(17);
+ raf.setPartitionAttributes(pa);
+ getCache().createRegion(rName, raf.create());
+ Function function = new TestFunction(true, TestFunction.TEST_FUNCTION2);
+ FunctionService.registerFunction(function);
+ function = new TestFunction(true, TestFunction.TEST_FUNCTION3);
+ FunctionService.registerFunction(function);
+ };
datastore0.invoke(dataStoreCreate);
datastore1.invoke(dataStoreCreate);
datastore2.invoke(dataStoreCreate);
- accessor.invoke(new SerializableCallable("Create data, invoke exectuable") {
- @Override
- public Object call() throws Exception {
-
- PartitionedRegion pr = (PartitionedRegion) getCache().getRegion(rName);
- DistributedSystem.setThreadsSocketPolicy(false);
- final HashSet testKeys = new HashSet();
- for (int i = (pr.getTotalNumberOfBuckets() * 3); i > 0; i--) {
- testKeys.add("execKey-" + i);
- }
- int j = 0;
- for (Iterator i = testKeys.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- pr.put(i.next(), val);
- }
- Function function = new TestFunction(true, TestFunction.TEST_FUNCTION2);
- FunctionService.registerFunction(function);
- Execution dataSet = FunctionService.onRegion(pr);
- ResultCollector rc1 = dataSet.setArguments(Boolean.TRUE).execute(function);
- int size = ((List) rc1.getResult()).size();
- resultReceived_Aggregate += size;
- resultReceived_TESTFUNCTION2 += size;
-
- rc1 = dataSet.setArguments(testKeys).execute(function);
- size = ((List) rc1.getResult()).size();
- resultReceived_Aggregate += size;
- resultReceived_TESTFUNCTION2 += size;
-
- function = new TestFunction(true, TestFunction.TEST_FUNCTION3);
- FunctionService.registerFunction(function);
- rc1 = dataSet.setArguments(Boolean.TRUE).execute(function);
- size = ((List) rc1.getResult()).size();
- resultReceived_Aggregate += size;
- resultReceived_TESTFUNCTION3 += size;
-
- return Boolean.TRUE;
+ accessor.invoke(() -> {
+ PartitionedRegion pr = (PartitionedRegion) getCache().getRegion(rName);
+ DistributedSystem.setThreadsSocketPolicy(false);
+ final HashSet<String> testKeys = new HashSet<>();
+ for (int i = (pr.getTotalNumberOfBuckets() * 3); i > 0; i--) {
+ testKeys.add("execKey-" + i);
}
+ int j = 0;
+ for (Object testKey : testKeys) {
+ Integer val = j++;
+ pr.put(testKey, val);
+ }
+ Function function = new TestFunction(true, TestFunction.TEST_FUNCTION2);
+ FunctionService.registerFunction(function);
+ Execution dataSet = FunctionService.onRegion(pr);
+ ResultCollector rc1 = dataSet.setArguments(Boolean.TRUE).execute(function);
+ int size = ((List) rc1.getResult()).size();
+ resultReceived_Aggregate += size;
+ resultReceived_TESTFUNCTION2 += size;
+
+ rc1 = dataSet.setArguments(testKeys).execute(function);
+ size = ((List) rc1.getResult()).size();
+ resultReceived_Aggregate += size;
+ resultReceived_TESTFUNCTION2 += size;
+
+ function = new TestFunction(true, TestFunction.TEST_FUNCTION3);
+ FunctionService.registerFunction(function);
+ rc1 = dataSet.setArguments(Boolean.TRUE).execute(function);
+ size = ((List) rc1.getResult()).size();
+ resultReceived_Aggregate += size;
+ resultReceived_TESTFUNCTION3 += size;
});
- accessor.invoke(new SerializableCallable("checkFunctionExecutionStatsForAccessor") {
- @Override
- public Object call() throws Exception {
- InternalDistributedSystem iDS =
- ((InternalDistributedSystem) getCache().getDistributedSystem());
- FunctionServiceStats functionServiceStats = iDS.getFunctionServiceStats();
- waitNoFunctionsRunning(functionServiceStats);
-
- assertEquals(noOfExecutionCalls_Aggregate,
- functionServiceStats.getFunctionExecutionCalls());
- assertEquals(noOfExecutionsCompleted_Aggregate,
- functionServiceStats.getFunctionExecutionsCompleted());
- assertEquals(resultReceived_Aggregate, functionServiceStats.getResultsReceived());
-
- FunctionStats functionStats =
- FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION2, iDS);
- assertEquals(noOfExecutionCalls_TESTFUNCTION2, functionStats.getFunctionExecutionCalls());
- assertEquals(noOfExecutionsCompleted_TESTFUNCTION2,
- functionStats.getFunctionExecutionsCompleted());
- assertEquals(resultReceived_TESTFUNCTION2, functionStats.getResultsReceived());
-
- functionStats = FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION3, iDS);
- assertEquals(noOfExecutionCalls_TESTFUNCTION3, functionStats.getFunctionExecutionCalls());
- assertEquals(noOfExecutionsCompleted_TESTFUNCTION3,
- functionStats.getFunctionExecutionsCompleted());
- assertEquals(resultReceived_TESTFUNCTION3, functionStats.getResultsReceived());
-
- return Boolean.TRUE;
- }
+ accessor.invoke(() -> {
+ InternalDistributedSystem iDS =
+ ((InternalDistributedSystem) getCache().getDistributedSystem());
+ FunctionServiceStats functionServiceStats = iDS.getFunctionServiceStats();
+ waitNoFunctionsRunning(functionServiceStats);
+
+ assertEquals(noOfExecutionCalls_Aggregate,
+ functionServiceStats.getFunctionExecutionCalls());
+ assertEquals(noOfExecutionsCompleted_Aggregate,
+ functionServiceStats.getFunctionExecutionsCompleted());
+ assertEquals(resultReceived_Aggregate, functionServiceStats.getResultsReceived());
+
+ FunctionStats functionStats =
+ FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION2, iDS);
+ assertEquals(noOfExecutionCalls_TESTFUNCTION2, functionStats.getFunctionExecutionCalls());
+ assertEquals(noOfExecutionsCompleted_TESTFUNCTION2,
+ functionStats.getFunctionExecutionsCompleted());
+ assertEquals(resultReceived_TESTFUNCTION2, functionStats.getResultsReceived());
+
+ functionStats = FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION3, iDS);
+ assertEquals(noOfExecutionCalls_TESTFUNCTION3, functionStats.getFunctionExecutionCalls());
+ assertEquals(noOfExecutionsCompleted_TESTFUNCTION3,
+ functionStats.getFunctionExecutionsCompleted());
+ assertEquals(resultReceived_TESTFUNCTION3, functionStats.getResultsReceived());
});
- SerializableCallable checkFunctionExecutionStatsForDataStore =
- new SerializableCallable("checkFunctionExecutionStatsForDataStore") {
- @Override
- public Object call() throws Exception {
- InternalDistributedSystem iDS =
- ((InternalDistributedSystem) getCache().getDistributedSystem());
- // 3 Function Executions took place
- FunctionServiceStats functionServiceStats = iDS.getFunctionServiceStats();
- waitNoFunctionsRunning(functionServiceStats);
-
- noOfExecutionCalls_Aggregate += 3;
- noOfExecutionsCompleted_Aggregate += 3;
- assertEquals(noOfExecutionCalls_Aggregate,
- functionServiceStats.getFunctionExecutionCalls());
- assertEquals(noOfExecutionsCompleted_Aggregate,
- functionServiceStats.getFunctionExecutionsCompleted());
-
- FunctionStats functionStats =
- FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION2, iDS);
- // TEST_FUNCTION2 is executed twice
- noOfExecutionCalls_TESTFUNCTION2 += 2;
- assertEquals(noOfExecutionCalls_TESTFUNCTION2,
- functionStats.getFunctionExecutionCalls());
- noOfExecutionsCompleted_TESTFUNCTION2 += 2;
- assertEquals(noOfExecutionsCompleted_TESTFUNCTION2,
- functionStats.getFunctionExecutionsCompleted());
-
- functionStats = FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION3, iDS);
- // TEST_FUNCTION3 is executed once
- noOfExecutionCalls_TESTFUNCTION3 += 1;
- assertEquals(noOfExecutionCalls_TESTFUNCTION3,
- functionStats.getFunctionExecutionCalls());
- noOfExecutionsCompleted_TESTFUNCTION3 += 1;
- assertEquals(noOfExecutionsCompleted_TESTFUNCTION3,
- functionStats.getFunctionExecutionsCompleted());
-
- return Boolean.TRUE;
- }
- };
+ SerializableRunnableIF checkFunctionExecutionStatsForDataStore = () -> {
+ InternalDistributedSystem iDS =
+ ((InternalDistributedSystem) getCache().getDistributedSystem());
+ // 3 Function Executions took place
+ FunctionServiceStats functionServiceStats = iDS.getFunctionServiceStats();
+ waitNoFunctionsRunning(functionServiceStats);
+
+ noOfExecutionCalls_Aggregate += 3;
+ noOfExecutionsCompleted_Aggregate += 3;
+ assertEquals(noOfExecutionCalls_Aggregate,
+ functionServiceStats.getFunctionExecutionCalls());
+ assertEquals(noOfExecutionsCompleted_Aggregate,
+ functionServiceStats.getFunctionExecutionsCompleted());
+
+ FunctionStats functionStats =
+ FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION2, iDS);
+ // TEST_FUNCTION2 is executed twice
+ noOfExecutionCalls_TESTFUNCTION2 += 2;
+ assertEquals(noOfExecutionCalls_TESTFUNCTION2,
+ functionStats.getFunctionExecutionCalls());
+ noOfExecutionsCompleted_TESTFUNCTION2 += 2;
+ assertEquals(noOfExecutionsCompleted_TESTFUNCTION2,
+ functionStats.getFunctionExecutionsCompleted());
+
+ functionStats = FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION3, iDS);
+ // TEST_FUNCTION3 is executed once
+ noOfExecutionCalls_TESTFUNCTION3 += 1;
+ assertEquals(noOfExecutionCalls_TESTFUNCTION3,
+ functionStats.getFunctionExecutionCalls());
+ noOfExecutionsCompleted_TESTFUNCTION3 += 1;
+ assertEquals(noOfExecutionsCompleted_TESTFUNCTION3,
+ functionStats.getFunctionExecutionsCompleted());
+ };
datastore0.invoke(checkFunctionExecutionStatsForDataStore);
datastore1.invoke(checkFunctionExecutionStatsForDataStore);
datastore2.invoke(checkFunctionExecutionStatsForDataStore);
- SerializableCallable closeDistributedSystem =
- new SerializableCallable("closeDistributedSystem") {
- @Override
- public Object call() throws Exception {
- if (getCache() != null && !getCache().isClosed()) {
- getCache().close();
- getCache().getDistributedSystem().disconnect();
- }
- return Boolean.TRUE;
- }
- };
accessor.invoke(closeDistributedSystem);
datastore0.invoke(closeDistributedSystem);
datastore1.invoke(closeDistributedSystem);
@@ -922,96 +796,63 @@ public class FunctionServiceStatsDUnitTest extends PRClientServerTestBase {
datastore2.invoke(initializeStats);
datastore3.invoke(initializeStats);
- SerializableCallable createAndPopulateRegionWithEmpty =
- new SerializableCallable("Create PR with Function Factory") {
- @Override
- public Object call() throws Exception {
- AttributesFactory factory = new AttributesFactory();
- factory.setScope(Scope.DISTRIBUTED_ACK);
- factory.setDataPolicy(DataPolicy.EMPTY);
- Region region = getCache().createRegion(rName, factory.create());
- LogWriterUtils.getLogWriter().info("Region Created :" + region);
- assertNotNull(region);
- FunctionService.registerFunction(new TestFunction(true, TestFunction.TEST_FUNCTION2));
- for (int i = 1; i <= 200; i++) {
- region.put("execKey-" + i, new Integer(i));
- }
- return Boolean.TRUE;
- }
- };
- datastore0.invoke(createAndPopulateRegionWithEmpty);
-
- SerializableCallable createAndPopulateRegionWithReplicate =
- new SerializableCallable("Create PR with Function Factory") {
- @Override
- public Object call() throws Exception {
- AttributesFactory factory = new AttributesFactory();
- factory.setScope(Scope.DISTRIBUTED_ACK);
- factory.setDataPolicy(DataPolicy.REPLICATE);
- Region region = getCache().createRegion(rName, factory.create());
- LogWriterUtils.getLogWriter().info("Region Created :" + region);
- assertNotNull(region);
- FunctionService.registerFunction(new TestFunction(true, TestFunction.TEST_FUNCTION2));
- for (int i = 1; i <= 200; i++) {
- region.put("execKey-" + i, new Integer(i));
- }
- return Boolean.TRUE;
- }
- };
+ datastore0.invoke(() -> {
+ AttributesFactory factory = new AttributesFactory();
+ factory.setScope(Scope.DISTRIBUTED_ACK);
+ factory.setDataPolicy(DataPolicy.EMPTY);
+ Region<String, Integer> region = getCache().createRegion(rName, factory.create());
+ logger.info("Region Created :" + region);
+ assertNotNull(region);
+ FunctionService.registerFunction(new TestFunction(true, TestFunction.TEST_FUNCTION2));
+ for (int i = 1; i <= 200; i++) {
+ region.put("execKey-" + i, i);
+ }
+ });
+
+ SerializableRunnableIF createAndPopulateRegionWithReplicate = () -> {
+ AttributesFactory factory = new AttributesFactory();
+ factory.setScope(Scope.DISTRIBUTED_ACK);
+ factory.setDataPolicy(DataPolicy.REPLICATE);
+ Region<String, Integer> region = getCache().createRegion(rName, factory.create());
+ logger.info("Region Created :" + region);
+ assertNotNull(region);
+ FunctionService.registerFunction(new TestFunction(true, TestFunction.TEST_FUNCTION2));
+ for (int i = 1; i <= 200; i++) {
+ region.put("execKey-" + i, i);
+ }
+ };
datastore1.invoke(createAndPopulateRegionWithReplicate);
datastore2.invoke(createAndPopulateRegionWithReplicate);
datastore3.invoke(createAndPopulateRegionWithReplicate);
- SerializableCallable executeFunction =
- new SerializableCallable("ExecuteFunction from Normal Region") {
- @Override
- public Object call() throws Exception {
- Region region = getCache().getRegion(rName);
- try {
- List list = (List) FunctionService.onRegion(region).setArguments(Boolean.TRUE)
- .execute(TestFunction.TEST_FUNCTION2).getResult();
- // this is the Distributed Region with Empty Data policy.
- // therefore no function execution takes place here. it only receives the results.
- resultReceived_Aggregate += list.size();
- assertEquals(resultReceived_Aggregate,
- ((InternalDistributedSystem) getCache().getDistributedSystem())
- .getFunctionServiceStats().getResultsReceived());
-
- resultReceived_TESTFUNCTION2 += list.size();
- assertEquals(resultReceived_TESTFUNCTION2,
- ((InternalDistributedSystem) getCache().getDistributedSystem())
- .getFunctionServiceStats().getResultsReceived());
-
- return Boolean.TRUE;
- } catch (FunctionException e) {
- e.printStackTrace();
- Assert.fail("test failed due to", e);
- return Boolean.FALSE;
- } catch (Exception e) {
- e.printStackTrace();
- Assert.fail("test failed due to", e);
- return Boolean.FALSE;
- }
+ datastore0.invoke(() -> {
+ Region region = getCache().getRegion(rName);
+ try {
+ List list = (List) FunctionService.onRegion(region).setArguments(Boolean.TRUE)
+ .execute(TestFunction.TEST_FUNCTION2).getResult();
+ // this is the Distributed Region with Empty Data policy.
+ // therefore no function execution takes place here. it only receives the results.
+ resultReceived_Aggregate += list.size();
+ assertEquals(resultReceived_Aggregate,
+ ((InternalDistributedSystem) getCache().getDistributedSystem())
+ .getFunctionServiceStats().getResultsReceived());
+
+ resultReceived_TESTFUNCTION2 += list.size();
+ assertEquals(resultReceived_TESTFUNCTION2,
+ ((InternalDistributedSystem) getCache().getDistributedSystem())
+ .getFunctionServiceStats().getResultsReceived());
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ Assert.fail("test failed due to", e);
+ }
+ });
- }
- };
- datastore0.invoke(executeFunction);
// there is a replicated region on 3 nodes so we cannot predict on which
// node the function execution will take place
// so i have avoided that check.
- SerializableCallable closeDistributedSystem =
- new SerializableCallable("closeDistributedSystem") {
- @Override
- public Object call() throws Exception {
- if (getCache() != null && !getCache().isClosed()) {
- getCache().close();
- getCache().getDistributedSystem().disconnect();
- }
- return Boolean.TRUE;
- }
- };
datastore0.invoke(closeDistributedSystem);
datastore1.invoke(closeDistributedSystem);
datastore2.invoke(closeDistributedSystem);
@@ -1028,27 +869,22 @@ public class FunctionServiceStatsDUnitTest extends PRClientServerTestBase {
* equal tio the no of functions from member 1
*/
@Test
- public void testP2PMembersFunctionExecutionStats() throws Exception {
+ public void testP2PMembersFunctionExecutionStats() {
Host host = Host.getHost(0);
VM member1 = host.getVM(0);
VM member2 = host.getVM(1);
VM member3 = host.getVM(2);
VM member4 = host.getVM(3);
- SerializableCallable connectToDistributedSystem =
- new SerializableCallable("connectToDistributedSystem") {
- @Override
- public Object call() throws Exception {
- Properties props = new Properties();
- try {
- ds = getSystem(props);
- assertNotNull(ds);
- } catch (Exception e) {
- Assert.fail("Failed while creating the Distribued System", e);
- }
- return Boolean.TRUE;
- }
- };
+ SerializableRunnableIF connectToDistributedSystem = () -> {
+ Properties props = new Properties();
+ try {
+ ds = getSystem(props);
+ assertNotNull(ds);
+ } catch (Exception e) {
+ Assert.fail("Failed while creating the Distribued System", e);
+ }
+ };
member1.invoke(connectToDistributedSystem);
member2.invoke(connectToDistributedSystem);
member3.invoke(connectToDistributedSystem);
@@ -1059,14 +895,15 @@ public class FunctionServiceStatsDUnitTest extends PRClientServerTestBase {
member3.invoke(initializeStats);
member4.invoke(initializeStats);
- final int noOfMembers = 1;
final Function inlineFunction = new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<String> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
} else {
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
}
}
@@ -1081,96 +918,71 @@ public class FunctionServiceStatsDUnitTest extends PRClientServerTestBase {
}
};
- member1.invoke(new SerializableCallable("excuteOnMembers_InlineFunction") {
- @Override
- public Object call() throws Exception {
+ member1.invoke(() -> {
- assertNotNull(ds);
- Execution memberExecution = null;
- DistributedMember localmember = ds.getDistributedMember();
- memberExecution = FunctionService.onMember(localmember);
+ assertNotNull(ds);
+ DistributedMember localmember = ds.getDistributedMember();
+ Execution memberExecution = FunctionService.onMember(localmember);
- memberExecution.setArguments("Key");
- try {
- ResultCollector rc = memberExecution.execute(inlineFunction);
- int size = ((List) rc.getResult()).size();
- resultReceived_Aggregate += size;
- noOfExecutionCalls_Aggregate++;
- noOfExecutionsCompleted_Aggregate++;
- resultReceived_Inline += size;
- noOfExecutionCalls_Inline++;
- noOfExecutionsCompleted_Inline++;
-
- } catch (Exception e) {
- LogWriterUtils.getLogWriter().info("Exception Occurred : " + e.getMessage());
- e.printStackTrace();
- Assert.fail("Test failed", e);
- }
- return Boolean.TRUE;
+ memberExecution.setArguments("Key");
+ try {
+ ResultCollector rc = memberExecution.execute(inlineFunction);
+ int size = ((List) rc.getResult()).size();
+ resultReceived_Aggregate += size;
+ noOfExecutionCalls_Aggregate++;
+ noOfExecutionsCompleted_Aggregate++;
+ resultReceived_Inline += size;
+ noOfExecutionCalls_Inline++;
+ noOfExecutionsCompleted_Inline++;
+
+ } catch (Exception e) {
+ logger.info("Exception Occurred : " + e.getMessage());
+ e.printStackTrace();
+ Assert.fail("Test failed", e);
}
});
- member1.invoke(new SerializableCallable("checkFunctionExecutionStatsForMember1") {
- @Override
- public Object call() throws Exception {
- FunctionServiceStats functionServiceStats = ds.getFunctionServiceStats();
- waitNoFunctionsRunning(functionServiceStats);
-
- assertEquals(noOfExecutionCalls_Aggregate,
- functionServiceStats.getFunctionExecutionCalls());
- assertEquals(noOfExecutionsCompleted_Aggregate,
- functionServiceStats.getFunctionExecutionsCompleted());
- assertEquals(resultReceived_Aggregate, functionServiceStats.getResultsReceived());
-
- FunctionStats functionStats = FunctionStats.getFunctionStats(inlineFunction.getId(), ds);
- assertEquals(noOfExecutionCalls_Inline, functionStats.getFunctionExecutionCalls());
- assertEquals(noOfExecutionsCompleted_Inline,
- functionStats.getFunctionExecutionsCompleted());
- assertEquals(resultReceived_Inline, functionStats.getResultsReceived());
- return Boolean.TRUE;
- }
+ member1.invoke(() -> {
+ FunctionServiceStats functionServiceStats = ds.getFunctionServiceStats();
+ waitNoFunctionsRunning(functionServiceStats);
+
+ assertEquals(noOfExecutionCalls_Aggregate,
+ functionServiceStats.getFunctionExecutionCalls());
+ assertEquals(noOfExecutionsCompleted_Aggregate,
+ functionServiceStats.getFunctionExecutionsCompleted());
+ assertEquals(resultReceived_Aggregate, functionServiceStats.getResultsReceived());
+
+ FunctionStats functionStats = FunctionStats.getFunctionStats(inlineFunction.getId(), ds);
+ assertEquals(noOfExecutionCalls_Inline, functionStats.getFunctionExecutionCalls());
+ assertEquals(noOfExecutionsCompleted_Inline,
+ functionStats.getFunctionExecutionsCompleted());
+ assertEquals(resultReceived_Inline, functionStats.getResultsReceived());
});
- SerializableCallable checkFunctionExecutionStatsForOtherMember =
- new SerializableCallable("checkFunctionExecutionStatsForOtherMember") {
- @Override
- public Object call() throws Exception {
- FunctionServiceStats functionServiceStats = ds.getFunctionServiceStats();
- waitNoFunctionsRunning(functionServiceStats);
-
- // One function Execution took place on there members
- // noOfExecutionCalls_Aggregate++;
- // noOfExecutionsCompleted_Aggregate++;
- assertEquals(noOfExecutionCalls_Aggregate,
- functionServiceStats.getFunctionExecutionCalls());
- assertEquals(noOfExecutionsCompleted_Aggregate,
- functionServiceStats.getFunctionExecutionsCompleted());
-
- FunctionStats functionStats =
- FunctionStats.getFunctionStats(inlineFunction.getId(), ds);
- // noOfExecutionCalls_Inline++;
- // noOfExecutionsCompleted_Inline++;
- assertEquals(noOfExecutionCalls_Inline, functionStats.getFunctionExecutionCalls());
- assertEquals(noOfExecutionsCompleted_Inline,
- functionStats.getFunctionExecutionsCompleted());
- return Boolean.TRUE;
- }
- };
+ SerializableRunnableIF checkFunctionExecutionStatsForOtherMember = () -> {
+ FunctionServiceStats functionServiceStats = ds.getFunctionServiceStats();
+ waitNoFunctionsRunning(functionServiceStats);
+
+ // One function Execution took place on there members
+ // noOfExecutionCalls_Aggregate++;
+ // noOfExecutionsCompleted_Aggregate++;
+ assertEquals(noOfExecutionCalls_Aggregate,
+ functionServiceStats.getFunctionExecutionCalls());
+ assertEquals(noOfExecutionsCompleted_Aggregate,
+ functionServiceStats.getFunctionExecutionsCompleted());
+
+ FunctionStats functionStats =
+ FunctionStats.getFunctionStats(inlineFunction.getId(), ds);
+ // noOfExecutionCalls_Inline++;
+ // noOfExecutionsCompleted_Inline++;
+ assertEquals(noOfExecutionCalls_Inline, functionStats.getFunctionExecutionCalls());
+ assertEquals(noOfExecutionsCompleted_Inline,
+ functionStats.getFunctionExecutionsCompleted());
+ };
member2.invoke(checkFunctionExecutionStatsForOtherMember);
member3.invoke(checkFunctionExecutionStatsForOtherMember);
member4.invoke(checkFunctionExecutionStatsForOtherMember);
- SerializableCallable closeDistributedSystem =
- new SerializableCallable("closeDistributedSystem") {
- @Override
- public Object call() throws Exception {
- if (getCache() != null && !getCache().isClosed()) {
- getCache().close();
- getCache().getDistributedSystem().disconnect();
- }
- return Boolean.TRUE;
- }
- };
member1.invoke(closeDistributedSystem);
member2.invoke(closeDistributedSystem);
member3.invoke(closeDistributedSystem);
@@ -1192,7 +1004,7 @@ public class FunctionServiceStatsDUnitTest extends PRClientServerTestBase {
* in datatostore1
*/
@Test
- public void testFunctionExecutionExceptionStatsOnAllNodesPRegion() throws Exception {
+ public void testFunctionExecutionExceptionStatsOnAllNodesPRegion() {
final String rName = getUniqueName();
Host host = Host.getHost(0);
final VM datastore0 = host.getVM(0);
@@ -1205,108 +1017,49 @@ public class FunctionServiceStatsDUnitTest extends PRClientServerTestBase {
datastore2.invoke(initializeStats);
datastore3.invoke(initializeStats);
- SerializableCallable dataStoreCreate =
- new SerializableCallable("Create PR with Function Factory") {
- @Override
- public Object call() throws Exception {
- RegionAttributes ra = PartitionedRegionTestHelper.createRegionAttrsForPR(0, 10);
- AttributesFactory raf = new AttributesFactory(ra);
- PartitionAttributesImpl pa = new PartitionAttributesImpl();
- pa.setAll(ra.getPartitionAttributes());
- pa.setTotalNumBuckets(17);
- raf.setPartitionAttributes(pa);
- getCache().createRegion(rName, raf.create());
- Function function = new TestFunction(true, "TestFunctionException");
- FunctionService.registerFunction(function);
- return Boolean.TRUE;
- }
- };
+ SerializableRunnableIF dataStoreCreate = () -> {
+ RegionAttributes ra = PartitionedRegionTestHelper.createRegionAttrsForPR(0, 10);
+ AttributesFactory raf = new AttributesFactory(ra);
+ PartitionAttributesImpl pa = new PartitionAttributesImpl();
+ pa.setAll(ra.getPartitionAttributes());
+ pa.setTotalNumBuckets(17);
+ raf.setPartitionAttributes(pa);
+ getCache().createRegion(rName, raf.create());
+ Function function = new TestFunction(true, "TestFunctionException");
+ FunctionService.registerFunction(function);
+ };
datastore0.invoke(dataStoreCreate);
datastore1.invoke(dataStoreCreate);
datastore2.invoke(dataStoreCreate);
datastore3.invoke(dataStoreCreate);
- Object o = datastore3.invoke(new SerializableCallable("Create data, invoke exectuable") {
- @Override
- public Object call() throws Exception {
- PartitionedRegion pr = (PartitionedRegion) getCache().getRegion(rName);
- DistributedSystem.setThreadsSocketPolicy(false);
- final HashSet testKeys = new HashSet();
- for (int i = (pr.getTotalNumberOfBuckets() * 3); i > 0; i--) {
- testKeys.add("execKey-" + i);
- }
- int j = 0;
- for (Iterator i = testKeys.iterator(); i.hasNext();) {
- Integer key = new Integer(j++);
- pr.put(key, i.next());
- }
- try {
- Function function = new TestFunction(true, "TestFunctionException");
- FunctionService.registerFunction(function);
- Execution dataSet = FunctionService.onRegion(pr);
- ResultCollector rc = dataSet.setArguments(Boolean.TRUE).execute(function.getId());
- // Wait Criterion is added to make sure that the function execution
- // happens on all nodes and all nodes get the FunctionException so that the stats will get
- // incremented,
- Wait.pause(2000);
- rc.getResult();
- } catch (Exception expected) {
- return Boolean.TRUE;
- }
+ datastore3.invoke(() -> {
+ PartitionedRegion pr = (PartitionedRegion) getCache().getRegion(rName);
+ DistributedSystem.setThreadsSocketPolicy(false);
+ final HashSet<String> testKeys = new HashSet<>();
+ for (int i = (pr.getTotalNumberOfBuckets() * 3); i > 0; i--) {
+ testKeys.add("execKey-" + i);
+ }
+ int j = 0;
+ for (Object testKey : testKeys) {
+ Integer key = j++;
+ pr.put(key, testKey);
+ }
+ try {
+ Function function = new TestFunction(true, "TestFunctionException");
+ FunctionService.registerFunction(function);
+ Execution dataSet = FunctionService.onRegion(pr);
+ ResultCollector rc = dataSet.setArguments(Boolean.TRUE).execute(function.getId());
+ // Wait Criterion is added to make sure that the function execution
+ // happens on all nodes and all nodes get the FunctionException so that the stats will get
+ // incremented,
+ Wait.pause(2000);
+ rc.getResult();
fail("No exception Occurred");
- return Boolean.FALSE;
+ } catch (Exception ignored) {
}
});
- assertEquals(Boolean.TRUE, o);
-
- SerializableCallable checkFunctionExecutionStatsForDataStore =
- new SerializableCallable("checkFunctionExecutionStatsForDataStore") {
- @Override
- public Object call() throws Exception {
- FunctionStats functionStats =
- FunctionStats.getFunctionStats("TestFunctionException", getSystem());
- noOfExecutionCalls_TestFunctionException++;
- noOfExecutionExceptions_TestFunctionException++;
- assertEquals(noOfExecutionCalls_TestFunctionException,
- functionStats.getFunctionExecutionCalls());
- assertEquals(noOfExecutionsCompleted_TestFunctionException,
- functionStats.getFunctionExecutionsCompleted());
- assertEquals(noOfExecutionExceptions_TestFunctionException,
- functionStats.getFunctionExecutionExceptions());
-
- noOfExecutionCalls_Aggregate++;
- noOfExecutionExceptions_Aggregate++;
- FunctionServiceStats functionServiceStats =
- ((InternalDistributedSystem) getCache().getDistributedSystem())
- .getFunctionServiceStats();
- assertEquals(noOfExecutionCalls_Aggregate,
- functionServiceStats.getFunctionExecutionCalls());
- assertEquals(noOfExecutionsCompleted_Aggregate,
- functionServiceStats.getFunctionExecutionsCompleted());
- assertEquals(noOfExecutionExceptions_Aggregate,
- functionServiceStats.getFunctionExecutionExceptions());
- return Boolean.TRUE;
- }
- };
-
- /*
- * datastore0.invoke(checkFunctionExecutionStatsForDataStore);
- * datastore1.invoke(checkFunctionExecutionStatsForDataStore);
- * datastore2.invoke(checkFunctionExecutionStatsForDataStore);
- * datastore3.invoke(checkFunctionExecutionStatsForDataStore);
- */
-
- SerializableCallable closeDistributedSystem =
- new SerializableCallable("closeDistributedSystem") {
- @Override
- public Object call() throws Exception {
- if (getCache() != null && !getCache().isClosed()) {
- getCache().close();
- getCache().getDistributedSystem().disconnect();
- }
- return Boolean.TRUE;
- }
- };
+
datastore0.invoke(closeDistributedSystem);
datastore1.invoke(closeDistributedSystem);
datastore2.invoke(closeDistributedSystem);
@@ -1315,7 +1068,7 @@ public class FunctionServiceStatsDUnitTest extends PRClientServerTestBase {
private void createScenario() {
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 0, 13, null);
+ createCommonServerAttributes("TestPartitionedRegion", null, 0, null);
createClientServerScenarion(commonAttributes, 20, 20, 20);
}
}
diff --git a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerFunctionExecutionNoAckDUnitTest.java b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerFunctionExecutionNoAckDUnitTest.java
index 1760064..3d8faa2 100644
--- a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerFunctionExecutionNoAckDUnitTest.java
+++ b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerFunctionExecutionNoAckDUnitTest.java
@@ -22,8 +22,12 @@ import java.io.Serializable;
import java.util.HashSet;
import java.util.List;
+import org.apache.logging.log4j.Logger;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.UseParametersRunnerFactory;
import org.apache.geode.cache.execute.Execution;
import org.apache.geode.cache.execute.Function;
@@ -31,12 +35,17 @@ import org.apache.geode.cache.execute.FunctionService;
import org.apache.geode.cache.execute.ResultCollector;
import org.apache.geode.distributed.DistributedSystem;
import org.apache.geode.internal.cache.functions.TestFunction;
-import org.apache.geode.test.dunit.LogWriterUtils;
+import org.apache.geode.internal.logging.LogService;
import org.apache.geode.test.junit.categories.ClientServerTest;
import org.apache.geode.test.junit.categories.FunctionServiceTest;
+import org.apache.geode.test.junit.runners.CategoryWithParameterizedRunnerFactory;
@Category({ClientServerTest.class, FunctionServiceTest.class})
+@RunWith(Parameterized.class)
+@UseParametersRunnerFactory(CategoryWithParameterizedRunnerFactory.class)
public class PRClientServerFunctionExecutionNoAckDUnitTest extends PRClientServerTestBase {
+ private static final Logger logger = LogService.getLogger();
+
private static final String TEST_FUNCTION1 = TestFunction.TEST_FUNCTION1;
Boolean isByName = null;
@@ -65,7 +74,7 @@ public class PRClientServerFunctionExecutionNoAckDUnitTest extends PRClientServe
isByName = new Boolean(true);
toRegister = new Boolean(true);
- LogWriterUtils.getLogWriter().info(
+ logger.info(
"PRClientServerFunctionExecutionNoAckDUnitTest#testServerFunctionExecution_NoAck : Starting test");
client.invoke(() -> PRClientServerFunctionExecutionNoAckDUnitTest.serverExecution(isByName,
functionNoAck, functionAck, toRegister));
@@ -83,7 +92,7 @@ public class PRClientServerFunctionExecutionNoAckDUnitTest extends PRClientServe
registerFunctionAtServer(functionAck);
toRegister = new Boolean(false);
isByName = new Boolean(true);
- LogWriterUtils.getLogWriter().info(
+ logger.info(
"PRClientServerFunctionExecutionNoAckDUnitTest#testServerFunctionExecution_NoAck : Starting test");
client.invoke(() -> PRClientServerFunctionExecutionNoAckDUnitTest.serverExecution(isByName,
functionNoAck, functionAck, toRegister));
@@ -92,7 +101,7 @@ public class PRClientServerFunctionExecutionNoAckDUnitTest extends PRClientServe
}
private void createScenario() {
- LogWriterUtils.getLogWriter()
+ logger
.info("PRClientServerFFunctionExecutionDUnitTest#createScenario : creating scenario");
createClientServerScenarionWithoutRegion();
}
@@ -114,11 +123,11 @@ public class PRClientServerFunctionExecutionNoAckDUnitTest extends PRClientServe
for (int i = 0; i < NUM_ITERATION; i++)
execute(member, Boolean.TRUE, functionNoAck, isByName, toRegister);
t.stop();
- LogWriterUtils.getLogWriter().info("Time taken to execute boolean based" + NUM_ITERATION
+ logger.info("Time taken to execute boolean based" + NUM_ITERATION
+ "NoAck functions :" + t.getTimeInMs());
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operation");
}
@@ -132,11 +141,11 @@ public class PRClientServerFunctionExecutionNoAckDUnitTest extends PRClientServe
for (int i = 0; i < NUM_ITERATION; i++)
execute(member, testKeysSet, functionNoAck, isByName, toRegister);
t.stop();
- LogWriterUtils.getLogWriter().info(
+ logger.info(
"Time taken to execute setbased" + NUM_ITERATION + "NoAck functions :" + t.getTimeInMs());
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operationssssss");
}
if (toRegister.booleanValue()) {
@@ -154,11 +163,11 @@ public class PRClientServerFunctionExecutionNoAckDUnitTest extends PRClientServe
timeinms += t.getTimeInMs();
assertEquals(Boolean.TRUE, ((List) rc.getResult()).get(0));
}
- LogWriterUtils.getLogWriter().info("Time taken to execute boolean based" + NUM_ITERATION
+ logger.info("Time taken to execute boolean based" + NUM_ITERATION
+ "haveResults functions :" + timeinms);
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operation");
}
@@ -180,11 +189,11 @@ public class PRClientServerFunctionExecutionNoAckDUnitTest extends PRClientServe
}
}
- LogWriterUtils.getLogWriter().info(
+ logger.info(
"Time taken to execute setbased" + NUM_ITERATION + "haveResults functions :" + timeinms);
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operationssssss");
}
}
@@ -204,7 +213,7 @@ public class PRClientServerFunctionExecutionNoAckDUnitTest extends PRClientServe
execute(member, Boolean.TRUE, function, isByName, toRegister);
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operation allserver ");
}
@@ -216,7 +225,7 @@ public class PRClientServerFunctionExecutionNoAckDUnitTest extends PRClientServe
execute(member, testKeysSet, function, isByName, toRegister);
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
fail("Test failed after the execute operation");
}
}
@@ -225,15 +234,15 @@ public class PRClientServerFunctionExecutionNoAckDUnitTest extends PRClientServe
Boolean isByName, Boolean toRegister) throws Exception {
if (isByName.booleanValue()) {// by name
if (toRegister.booleanValue()) {
- LogWriterUtils.getLogWriter().info("The function name to execute : " + function.getId());
+ logger.info("The function name to execute : " + function.getId());
Execution me = member.setArguments(args);
- LogWriterUtils.getLogWriter().info("The args passed : " + args);
+ logger.info("The args passed : " + args);
return me.execute(function.getId());
} else {
- LogWriterUtils.getLogWriter()
+ logger
.info("The function name to execute : (without Register) " + function.getId());
Execution me = member.setArguments(args);
- LogWriterUtils.getLogWriter().info("The args passed : " + args);
+ logger.info("The args passed : " + args);
return me.execute(function.getId());
}
} else { // By Instance
diff --git a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionDUnitTest.java b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionDUnitTest.java
index b4b628b..5d2819c 100755
--- a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionDUnitTest.java
+++ b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionDUnitTest.java
@@ -24,7 +24,6 @@ import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.io.Serializable;
-import java.rmi.ServerException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
@@ -33,8 +32,12 @@ import java.util.Iterator;
import java.util.List;
import java.util.Set;
+import org.apache.logging.log4j.Logger;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.UseParametersRunnerFactory;
import org.apache.geode.DataSerializable;
import org.apache.geode.cache.AttributesFactory;
@@ -53,55 +56,60 @@ import org.apache.geode.cache.execute.FunctionContext;
import org.apache.geode.cache.execute.FunctionException;
import org.apache.geode.cache.execute.FunctionInvocationTargetException;
import org.apache.geode.cache.execute.FunctionService;
-import org.apache.geode.cache.execute.RegionFunctionContext;
import org.apache.geode.cache.execute.ResultCollector;
+import org.apache.geode.cache.execute.ResultSender;
import org.apache.geode.distributed.DistributedSystem;
import org.apache.geode.internal.cache.PartitionedRegion;
import org.apache.geode.internal.cache.functions.TestFunction;
import org.apache.geode.internal.cache.tier.sockets.CacheServerTestUtil;
+import org.apache.geode.internal.logging.LogService;
import org.apache.geode.test.dunit.Assert;
import org.apache.geode.test.dunit.IgnoredException;
-import org.apache.geode.test.dunit.LogWriterUtils;
import org.apache.geode.test.dunit.SerializableRunnable;
import org.apache.geode.test.dunit.Wait;
import org.apache.geode.test.dunit.WaitCriterion;
import org.apache.geode.test.junit.categories.ClientServerTest;
import org.apache.geode.test.junit.categories.FunctionServiceTest;
+import org.apache.geode.test.junit.runners.CategoryWithParameterizedRunnerFactory;
@Category({ClientServerTest.class, FunctionServiceTest.class})
+@RunWith(Parameterized.class)
+@UseParametersRunnerFactory(CategoryWithParameterizedRunnerFactory.class)
public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServerTestBase {
+ private static final Logger logger = LogService.getLogger();
+
private static final String TEST_FUNCTION7 = TestFunction.TEST_FUNCTION7;
private static final String TEST_FUNCTION2 = TestFunction.TEST_FUNCTION2;
- Boolean isByName = null;
+ private Boolean isByName = null;
private static int retryCount = 0;
- Boolean toRegister = null;
+ private Boolean toRegister = null;
private static Region metaDataRegion;
- static final String retryRegionName = "RetryDataRegion";
+ private static final String retryRegionName = "RetryDataRegion";
@Test
- public void test_Bug_43126_Function_Not_Registered() throws InterruptedException {
+ public void test_Bug_43126_Function_Not_Registered() {
createScenario();
try {
client
- .invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.executeRegisteredFunction());
+ .invoke(PRClientServerRegionFunctionExecutionDUnitTest::executeRegisteredFunction);
} catch (Exception e) {
- assertEquals(true, (e.getCause() instanceof ServerOperationException));
+ assertTrue((e.getCause() instanceof ServerOperationException));
assertTrue(
e.getCause().getMessage().contains("The function is not registered for function id"));
}
}
@Test
- public void test_Bug43126() throws InterruptedException {
+ public void test_Bug43126() {
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.executeRegisteredFunction());
+ client.invoke(PRClientServerRegionFunctionExecutionDUnitTest::executeRegisteredFunction);
}
/*
@@ -113,8 +121,8 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
- toRegister = new Boolean(true);
+ isByName = Boolean.TRUE;
+ toRegister = Boolean.TRUE;
SerializableRunnable suspect = new SerializableRunnable() {
@Override
public void run() {
@@ -142,8 +150,8 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
@Test
public void testServerSingleKeyExecution_Bug43513_OnRegion() {
createScenario_SingleConnection();
- client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
- .serverSingleKeyExecutionOnRegion_SingleConnection());
+ client.invoke(
+ PRClientServerRegionFunctionExecutionDUnitTest::serverSingleKeyExecutionOnRegion_SingleConnection);
}
@Test
@@ -151,8 +159,8 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
createScenario();
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_SEND_EXCEPTION);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
- toRegister = new Boolean(true);
+ isByName = Boolean.TRUE;
+ toRegister = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
.serverSingleKeyExecution_SendException(isByName, toRegister));
}
@@ -162,8 +170,8 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
createScenario();
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_THROW_EXCEPTION);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
- toRegister = new Boolean(true);
+ isByName = Boolean.TRUE;
+ toRegister = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
.serverSingleKeyExecution_ThrowException(isByName, toRegister));
}
@@ -173,8 +181,8 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
createScenarioWith2Regions();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
- toRegister = new Boolean(true);
+ isByName = Boolean.TRUE;
+ toRegister = Boolean.TRUE;
SerializableRunnable suspect = new SerializableRunnable() {
@Override
public void run() {
@@ -186,7 +194,7 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
};
runOnAllServers(suspect);
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
- .serverSingleKeyExecutionWith2Regions(isByName, toRegister));
+ .serverSingleKeyExecutionWith2Regions(toRegister));
SerializableRunnable endSuspect = new SerializableRunnable() {
@Override
public void run() {
@@ -208,8 +216,8 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
createScenario();
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_NO_LASTRESULT);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
- toRegister = new Boolean(true);
+ isByName = Boolean.TRUE;
+ toRegister = Boolean.TRUE;
final IgnoredException ex = IgnoredException.addIgnoredException("did not send last result");
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
@@ -222,8 +230,8 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
- toRegister = new Boolean(false);
+ isByName = Boolean.TRUE;
+ toRegister = Boolean.FALSE;
SerializableRunnable suspect = new SerializableRunnable() {
@Override
public void run() {
@@ -256,8 +264,8 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
@Test
public void testserverSingleKeyExecution_FunctionInvocationTargetException() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
- .serverSingleKeyExecution_FunctionInvocationTargetException());
+ client.invoke(
+ PRClientServerRegionFunctionExecutionDUnitTest::serverSingleKeyExecution_FunctionInvocationTargetException);
}
@Test
@@ -265,7 +273,7 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
createScenario();
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_SOCKET_TIMEOUT);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
.serverSingleKeyExecutionSocketTimeOut(isByName));
}
@@ -279,7 +287,7 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(false);
+ isByName = Boolean.FALSE;
toRegister = true;
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
.serverSingleKeyExecution(isByName, toRegister));
@@ -292,7 +300,7 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
public void testServerSingleKeyExecution_byInlineFunction() {
createScenario();
client.invoke(
- () -> PRClientServerRegionFunctionExecutionDUnitTest.serverSingleKeyExecution_Inline());
+ PRClientServerRegionFunctionExecutionDUnitTest::serverSingleKeyExecution_Inline);
}
/*
@@ -304,12 +312,12 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(
() -> PRClientServerRegionFunctionExecutionDUnitTest.serverMultiKeyExecution(isByName));
- server1.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.checkBucketsOnServer());
- server2.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.checkBucketsOnServer());
- server3.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.checkBucketsOnServer());
+ server1.invoke(PRClientServerRegionFunctionExecutionDUnitTest::checkBucketsOnServer);
+ server2.invoke(PRClientServerRegionFunctionExecutionDUnitTest::checkBucketsOnServer);
+ server3.invoke(PRClientServerRegionFunctionExecutionDUnitTest::checkBucketsOnServer);
}
/*
@@ -321,15 +329,15 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_BUCKET_FILTER);
registerFunctionAtServer(function);
// test multi key filter
- Set<Integer> bucketFilterSet = new HashSet<Integer>();
+ Set<Integer> bucketFilterSet = new HashSet<>();
bucketFilterSet.add(3);
bucketFilterSet.add(6);
bucketFilterSet.add(8);
- client.invoke(() -> PRClientServerTestBase.serverBucketFilterExecution(bucketFilterSet));
+ client.invoke(() -> serverBucketFilterExecution(bucketFilterSet));
bucketFilterSet.clear();
// Test single filter
bucketFilterSet.add(7);
- client.invoke(() -> PRClientServerTestBase.serverBucketFilterExecution(bucketFilterSet));
+ client.invoke(() -> serverBucketFilterExecution(bucketFilterSet));
}
@@ -339,17 +347,16 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_BUCKET_FILTER);
registerFunctionAtServer(function);
// test multi key filter
- Set<Integer> bucketFilterSet = new HashSet<Integer>();
+ Set<Integer> bucketFilterSet = new HashSet<>();
bucketFilterSet.add(3);
bucketFilterSet.add(6);
bucketFilterSet.add(8);
- Set<Integer> keyFilterSet = new HashSet<Integer>();
+ Set<Integer> keyFilterSet = new HashSet<>();
keyFilterSet.add(75);
keyFilterSet.add(25);
- client.invoke(() -> PRClientServerTestBase.serverBucketFilterOverrideExecution(bucketFilterSet,
- keyFilterSet));
+ client.invoke(() -> serverBucketFilterOverrideExecution(bucketFilterSet, keyFilterSet));
}
@@ -358,7 +365,7 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
createScenario();
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_SEND_EXCEPTION);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
.serverMultiKeyExecution_SendException(isByName));
}
@@ -368,7 +375,7 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
createScenario();
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_THROW_EXCEPTION);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
.serverMultiKeyExecution_ThrowException(isByName));
}
@@ -382,7 +389,7 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
public void testserverMultiKeyExecution_byInlineFunction() {
createScenario();
client.invoke(
- () -> PRClientServerRegionFunctionExecutionDUnitTest.serverMultiKeyExecution_Inline());
+ PRClientServerRegionFunctionExecutionDUnitTest::serverMultiKeyExecution_Inline);
}
/*
@@ -394,8 +401,8 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
@Test
public void testserverMultiKeyExecution_FunctionInvocationTargetException() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
- .serverMultiKeyExecution_FunctionInvocationTargetException());
+ client.invoke(
+ PRClientServerRegionFunctionExecutionDUnitTest::serverMultiKeyExecution_FunctionInvocationTargetException);
}
/*
@@ -407,7 +414,7 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
createScenario();
Function function = new TestFunction(false, TEST_FUNCTION7);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
.serverMultiKeyExecutionNoResult(isByName));
}
@@ -421,7 +428,7 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(false);
+ isByName = Boolean.FALSE;
client.invoke(
() -> PRClientServerRegionFunctionExecutionDUnitTest.serverMultiKeyExecution(isByName));
}
@@ -435,7 +442,7 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
.serverMultiKeyExecutionOnASingleBucket(isByName));
}
@@ -449,22 +456,22 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(false);
+ isByName = Boolean.FALSE;
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
.serverMultiKeyExecutionOnASingleBucket(isByName));
}
- public static void regionSingleKeyExecutionNonHA(Boolean isByName, Function function,
- Boolean toRegister) throws Exception {
- Region region = cache.getRegion(PartitionedRegionName);
+ static void regionSingleKeyExecutionNonHA(Boolean isByName, Function function,
+ Boolean toRegister) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
- if (toRegister.booleanValue()) {
+ if (toRegister) {
FunctionService.registerFunction(function);
} else {
FunctionService.unregisterFunction(function.getId());
@@ -473,13 +480,13 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
Execution dataSet = FunctionService.onRegion(region);
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
try {
- ArrayList<String> args = new ArrayList<String>();
+ ArrayList<String> args = new ArrayList<>();
args.add(retryRegionName);
args.add("regionSingleKeyExecutionNonHA");
- ResultCollector rs = execute(dataSet, testKeysSet, args, function, isByName);
+ execute(dataSet, testKeysSet, args, function, isByName);
fail("Expected ServerConnectivityException not thrown!");
} catch (Exception ex) {
if (!(ex.getCause() instanceof ServerConnectivityException)
@@ -489,17 +496,17 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
}
}
- public static void regionExecutionHAOneServerDown(Boolean isByName, Function function,
- Boolean toRegister) throws Exception {
+ static void regionExecutionHAOneServerDown(Boolean isByName, Function function,
+ Boolean toRegister) {
- Region region = cache.getRegion(PartitionedRegionName);
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
- if (toRegister.booleanValue()) {
+ if (toRegister) {
FunctionService.registerFunction(function);
} else {
FunctionService.unregisterFunction(function.getId());
@@ -508,9 +515,9 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
Execution dataSet = FunctionService.onRegion(region);
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
- ArrayList<String> args = new ArrayList<String>();
+ ArrayList<String> args = new ArrayList<>();
args.add(retryRegionName);
args.add("regionExecutionHAOneServerDown");
@@ -518,17 +525,17 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
assertEquals(1, ((List) rs.getResult()).size());
}
- public static void regionExecutionHATwoServerDown(Boolean isByName, Function function,
- Boolean toRegister) throws Exception {
+ static void regionExecutionHATwoServerDown(Boolean isByName, Function function,
+ Boolean toRegister) {
- Region region = cache.getRegion(PartitionedRegionName);
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
- if (toRegister.booleanValue()) {
+ if (toRegister) {
FunctionService.registerFunction(function);
} else {
FunctionService.unregisterFunction(function.getId());
@@ -537,9 +544,9 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
Execution dataSet = FunctionService.onRegion(region);
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
- ArrayList<String> args = new ArrayList<String>();
+ ArrayList<String> args = new ArrayList<>();
args.add(retryRegionName);
args.add("regionExecutionHATwoServerDown");
@@ -547,11 +554,11 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
assertEquals(1, ((List) rs.getResult()).size());
}
- public static void createReplicatedRegion() {
+ static void createReplicatedRegion() {
metaDataRegion = cache.createRegionFactory(RegionShortcut.REPLICATE).create(retryRegionName);
}
- public static void createProxyRegion(String hostName) {
+ public static void createProxyRegion() {
CacheServerTestUtil.disableShufflingOfEndpoints();
AttributesFactory factory = new AttributesFactory();
factory.setScope(Scope.LOCAL);
@@ -562,7 +569,7 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
assertNotNull(metaDataRegion);
}
- public static void verifyMetaData(Integer arg1, Integer arg2) {
+ static void verifyMetaData(Integer arg1, Integer arg2) {
if (arg1 == 0) {
assertNull(metaDataRegion.get("stopped"));
@@ -581,10 +588,12 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
FunctionService.registerFunction(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
} else if (context.getArguments() instanceof Boolean) {
- context.getResultSender().lastResult(Boolean.FALSE);
+ resultSender.lastResult(Boolean.FALSE);
}
}
@@ -600,26 +609,28 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
});
}
- public static void FunctionExecution_Inline_Bug40714() {
- Region region = cache.getRegion(PartitionedRegionName);
+ static void FunctionExecution_Inline_Bug40714() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 10); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 10); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
int j = 0;
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- region.put(i.next(), val);
+ for (String s : testKeysSet) {
+ Integer val = j++;
+ region.put(s, val);
}
List list = (List) FunctionService.onRegion(region).setArguments(Boolean.TRUE)
.execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
} else if (context.getArguments() instanceof Boolean) {
- context.getResultSender().lastResult(Boolean.TRUE);
+ resultSender.lastResult(Boolean.TRUE);
}
}
@@ -641,20 +652,19 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
}
}
- public static void verifyDeadAndLiveServers(final Integer expectedDeadServers,
- final Integer expectedLiveServers) {
+ public static void verifyDeadAndLiveServers(final Integer expectedLiveServers) {
WaitCriterion wc = new WaitCriterion() {
String excuse;
@Override
public boolean done() {
int sz = pool.getConnectedServerCount();
- LogWriterUtils.getLogWriter().info("Checking for the Live Servers : Expected : "
+ logger.info("Checking for the Live Servers : Expected : "
+ expectedLiveServers + " Available :" + sz);
- if (sz == expectedLiveServers.intValue()) {
+ if (sz == expectedLiveServers) {
return true;
}
- excuse = "Expected " + expectedLiveServers.intValue() + " but found " + sz;
+ excuse = "Expected " + expectedLiveServers + " but found " + sz;
return false;
}
@@ -666,12 +676,12 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
Wait.waitForCriterion(wc, 3 * 60 * 1000, 1000, true);
}
- public static void executeFunction() throws ServerException, InterruptedException {
+ public static void executeFunction() {
Region region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 10); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 10); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -682,21 +692,21 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
ResultCollector rc1 =
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(function.getId());
List l = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + l.size());
+ logger.info("Result size : " + l.size());
assertEquals(3, l.size());
- for (Iterator i = l.iterator(); i.hasNext();) {
- assertEquals(Boolean.TRUE, i.next());
+ for (Object o : l) {
+ assertEquals(Boolean.TRUE, o);
}
} catch (CacheClosedException e) {
// okay - ignore
}
}
- public static Object executeFunctionHA() throws Exception {
+ static Object executeFunctionHA() {
Region region = cache.getRegion(PartitionedRegionName);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 10); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 10); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -706,89 +716,85 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
ResultCollector rc1 =
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(function.getId());
List l = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + l.size());
+ logger.info("Result size : " + l.size());
return l;
}
- public static void putOperation() {
- Region region = cache.getRegion(PartitionedRegionName);
+ static void putOperation() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 10); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 10); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String s : testKeysSet) {
+ Integer val = j++;
+ region.put(s, val);
}
}
protected void createScenario() {
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 0, 13, null);
+ createCommonServerAttributes("TestPartitionedRegion", null, 0, null);
createClientServerScenarion(commonAttributes, 20, 20, 20);
}
- protected void createScenarioForBucketFilter() {
+ private void createScenarioForBucketFilter() {
ArrayList commonAttributes = createCommonServerAttributes("TestPartitionedRegion",
- new BucketFilterPRResolver(), 0, 113, null);
+ new BucketFilterPRResolver(), 0, null);
createClientServerScenarion(commonAttributes, 20, 20, 20);
}
private void createScenario_SingleConnection() {
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 0, 13, null);
- createClientServerScenarion_SingleConnection(commonAttributes, 0, 20, 20);
+ createCommonServerAttributes("TestPartitionedRegion", null, 0, null);
+ createClientServerScenarion_SingleConnection(commonAttributes, 0, 20);
}
private void createScenarioWith2Regions() {
ArrayList commonAttributes =
- createCommonServerAttributes(PartitionedRegionName, null, 0, 13, null);
+ createCommonServerAttributes(PartitionedRegionName, null, 0, null);
createClientServerScenarionWith2Regions(commonAttributes, 20, 20, 20);
}
- public static void checkBucketsOnServer() {
+ private static void checkBucketsOnServer() {
PartitionedRegion region = (PartitionedRegion) cache.getRegion(PartitionedRegionName);
HashMap localBucket2RegionMap = (HashMap) region.getDataStore().getSizeLocally();
- LogWriterUtils.getLogWriter().info(
+ logger.info(
"Size of the " + PartitionedRegionName + " in this VM :- " + localBucket2RegionMap.size());
Set entrySet = localBucket2RegionMap.entrySet();
assertNotNull(entrySet);
}
- public static void serverMultiKeyExecutionOnASingleBucket(Boolean isByName) throws Exception {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecutionOnASingleBucket(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
int j = 0;
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- region.put(i.next(), val);
+ for (String value : testKeysSet) {
+ Integer val = j++;
+ region.put(value, val);
}
DistributedSystem.setThreadsSocketPolicy(false);
- for (Iterator kiter = testKeysSet.iterator(); kiter.hasNext();) {
- Set singleKeySet = Collections.singleton(kiter.next());
+ for (String o : testKeysSet) {
+ Set<String> singleKeySet = Collections.singleton(o);
Function function = new TestFunction(true, TEST_FUNCTION2);
FunctionService.registerFunction(function);
Execution dataSet = FunctionService.onRegion(region);
ResultCollector rc1 = execute(dataSet, singleKeySet, Boolean.TRUE, function, isByName);
- List l = null;
- l = ((List) rc1.getResult());
+ List l = ((List) rc1.getResult());
assertEquals(1, l.size());
ResultCollector rc2 =
- execute(dataSet, singleKeySet, new HashSet(singleKeySet), function, isByName);
- List l2 = null;
- l2 = ((List) rc2.getResult());
+ execute(dataSet, singleKeySet, new HashSet<>(singleKeySet), function, isByName);
+ List l2 = ((List) rc2.getResult());
assertEquals(1, l2.size());
List subList = (List) l2.iterator().next();
@@ -797,11 +803,11 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
}
}
- public static void serverMultiKeyExecution(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecution(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -810,31 +816,29 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
Execution dataSet = FunctionService.onRegion(region);
try {
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
+ HashSet<Integer> origVals = new HashSet<>();
+ for (String element : testKeysSet) {
+ Integer val = j++;
origVals.add(val);
- region.put(i.next(), val);
+ region.put(element, val);
}
- List l = null;
ResultCollector rc1 = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
- l = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + l.size());
+ List l = ((List) rc1.getResult());
+ logger.info("Result size : " + l.size());
assertEquals(3, l.size());
- for (Iterator i = l.iterator(); i.hasNext();) {
- assertEquals(Boolean.TRUE, i.next());
+ for (Object item : l) {
+ assertEquals(Boolean.TRUE, item);
}
- List l2 = null;
ResultCollector rc2 = execute(dataSet, testKeysSet, testKeysSet, function, isByName);
- l2 = ((List) rc2.getResult());
+ List l2 = ((List) rc2.getResult());
assertEquals(3, l2.size());
- HashSet foundVals = new HashSet();
- for (Iterator i = l2.iterator(); i.hasNext();) {
- ArrayList subL = (ArrayList) i.next();
+ HashSet<Integer> foundVals = new HashSet<>();
+ for (Object value : l2) {
+ ArrayList subL = (ArrayList) value;
assertTrue(subL.size() > 0);
- for (Iterator subI = subL.iterator(); subI.hasNext();) {
- assertTrue(foundVals.add(subI.next()));
+ for (Object o : subL) {
+ assertTrue(foundVals.add((Integer) o));
}
}
assertEquals(origVals, foundVals);
@@ -847,11 +851,11 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
- public static void serverMultiKeyExecution_SendException(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecution_SendException(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -859,20 +863,17 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
FunctionService.registerFunction(function);
Execution dataSet = FunctionService.onRegion(region);
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String value : testKeysSet) {
+ Integer val = j++;
+ region.put(value, val);
}
try {
- List l = null;
ResultCollector rc1 = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
- l = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + l.size());
+ List l = ((List) rc1.getResult());
+ logger.info("Result size : " + l.size());
assertEquals(3, l.size());
- for (Iterator i = l.iterator(); i.hasNext();) {
- assertTrue(i.next() instanceof MyFunctionExecutionException);
+ for (Object o : l) {
+ assertTrue(o instanceof MyFunctionExecutionException);
}
} catch (Exception ex) {
ex.printStackTrace();
@@ -880,7 +881,6 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
}
try {
- List l = null;
ResultCollector rc1 = execute(dataSet, testKeysSet, testKeysSet, function, isByName);
List resultList = (List) rc1.getResult();
assertEquals(((testKeysSet.size() * 3) + 3), resultList.size());
@@ -899,11 +899,11 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
}
}
- public static void serverMultiKeyExecution_ThrowException(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecution_ThrowException(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -911,26 +911,23 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
FunctionService.registerFunction(function);
Execution dataSet = FunctionService.onRegion(region);
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String o : testKeysSet) {
+ Integer val = j++;
+ region.put(o, val);
}
try {
- List l = null;
- ResultCollector rc1 = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
+ execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
fail("Exception Expected");
} catch (Exception ex) {
ex.printStackTrace();
}
}
- public static void serverMultiKeyExecutionSocketTimeOut(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ static void serverMultiKeyExecutionSocketTimeOut(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -939,19 +936,16 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
Execution dataSet = FunctionService.onRegion(region);
try {
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String value : testKeysSet) {
+ Integer val = j++;
+ region.put(value, val);
}
- List l = null;
ResultCollector rc1 = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
- l = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + l.size());
+ List l = ((List) rc1.getResult());
+ logger.info("Result size : " + l.size());
assertEquals(3, l.size());
- for (Iterator i = l.iterator(); i.hasNext();) {
- assertEquals(Boolean.TRUE, i.next());
+ for (Object o : l) {
+ assertEquals(Boolean.TRUE, o);
}
} catch (Exception e) {
@@ -960,11 +954,11 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
}
}
- public static void serverSingleKeyExecutionSocketTimeOut(Boolean isByName) throws Exception {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecutionSocketTimeOut(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
@@ -972,7 +966,7 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
FunctionService.registerFunction(function);
Execution dataSet = FunctionService.onRegion(region);
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
ResultCollector rs = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
assertEquals(Boolean.TRUE, ((List) rs.getResult()).get(0));
@@ -982,32 +976,31 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
}
- public static void serverMultiKeyExecution_Inline() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecution_Inline() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
Execution dataSet = FunctionService.onRegion(region);
try {
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String value : testKeysSet) {
+ Integer val = j++;
+ region.put(value, val);
}
- List l = null;
ResultCollector rc1 =
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
} else if (context.getArguments() instanceof Boolean) {
- context.getResultSender().lastResult(Boolean.TRUE);
+ resultSender.lastResult(Boolean.TRUE);
}
}
@@ -1021,44 +1014,41 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
return true;
}
});
- l = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + l.size());
+ List l = ((List) rc1.getResult());
+ logger.info("Result size : " + l.size());
assertEquals(3, l.size());
- for (Iterator i = l.iterator(); i.hasNext();) {
- assertEquals(Boolean.TRUE, i.next());
+ for (Object o : l) {
+ assertEquals(Boolean.TRUE, o);
}
} catch (Exception e) {
- LogWriterUtils.getLogWriter().info("Exception : " + e.getMessage());
+ logger.info("Exception : " + e.getMessage());
e.printStackTrace();
fail("Test failed after the put operation");
}
}
- public static void serverMultiKeyExecution_FunctionInvocationTargetException() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecution_FunctionInvocationTargetException() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
Execution dataSet = FunctionService.onRegion(region);
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String o : testKeysSet) {
+ Integer val = j++;
+ region.put(o, val);
}
- ResultCollector rc1 = null;
try {
- rc1 =
+ ResultCollector rc1 =
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
- if (((RegionFunctionContext) context).isPossibleDuplicate()) {
- context.getResultSender().lastResult(new Integer(retryCount));
+ if (context.isPossibleDuplicate()) {
+ context.getResultSender().lastResult(retryCount);
return;
}
if (context.getArguments() instanceof Boolean) {
@@ -1086,11 +1076,11 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
}
- public static void serverMultiKeyExecutionNoResult(Boolean isByName) throws Exception {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecutionNoResult(Boolean isByName) throws Exception {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -1101,11 +1091,9 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
String msg = "<ExpectedException action=add>" + "FunctionException" + "</ExpectedException>";
cache.getLogger().info(msg);
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String o : testKeysSet) {
+ Integer val = j++;
+ region.put(o, val);
}
ResultCollector rc1 = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
rc1.getResult();
@@ -1121,41 +1109,31 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
}
}
- public static void serverSingleKeyExecutionOnRegion_SingleConnection() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecutionOnRegion_SingleConnection() {
+ Region<Integer, String> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
for (int i = 0; i < 13; i++) {
- region.put(new Integer(i), "KB_" + i);
+ region.put(i, "KB_" + i);
}
Function function = new TestFunction(false, TEST_FUNCTION2);
Execution dataSet = FunctionService.onRegion(region);
dataSet.setArguments(Boolean.TRUE).execute(function);
- region.put(new Integer(2), "KB_2");
- assertEquals("KB_2", region.get(new Integer(2)));
- }
-
- public static void serverSingleKeyExecutionOnServer_SingleConnection() {
- Region region = cache.getRegion(PartitionedRegionName);
- assertNotNull(region);
- Function function = new TestFunction(false, TEST_FUNCTION2);
- Execution dataSet = FunctionService.onServer(pool);
- dataSet.setArguments(Boolean.TRUE).execute(function);
- region.put(new Integer(1), "KB_1");
- assertEquals("KB_1", region.get(new Integer(1)));
+ region.put(2, "KB_2");
+ assertEquals("KB_2", region.get(2));
}
- public static void serverSingleKeyExecution(Boolean isByName, Boolean toRegister)
+ private static void serverSingleKeyExecution(Boolean isByName, Boolean toRegister)
throws Exception {
- Region region = cache.getRegion(PartitionedRegionName);
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
Function function = new TestFunction(true, TEST_FUNCTION2);
- if (toRegister.booleanValue()) {
+ if (toRegister) {
FunctionService.registerFunction(function);
} else {
FunctionService.unregisterFunction(function.getId());
@@ -1171,33 +1149,33 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
throw ex;
}
}
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
ResultCollector rs = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
assertEquals(Boolean.TRUE, ((List) rs.getResult()).get(0));
ResultCollector rs2 = execute(dataSet, testKeysSet, testKey, function, isByName);
- assertEquals(new Integer(1), ((List) rs2.getResult()).get(0));
+ assertEquals(1, ((List) rs2.getResult()).get(0));
- HashMap putData = new HashMap();
- putData.put(testKey + "1", new Integer(2));
- putData.put(testKey + "2", new Integer(3));
+ HashMap<String, Integer> putData = new HashMap<>();
+ putData.put(testKey + "1", 2);
+ putData.put(testKey + "2", 3);
ResultCollector rs1 = execute(dataSet, testKeysSet, putData, function, isByName);
assertEquals(Boolean.TRUE, ((List) rs1.getResult()).get(0));
- assertEquals(new Integer(2), region.get(testKey + "1"));
- assertEquals(new Integer(3), region.get(testKey + "2"));
+ assertEquals((Integer) 2, region.get(testKey + "1"));
+ assertEquals((Integer) 3, region.get(testKey + "2"));
}
- public static void executeRegisteredFunction() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void executeRegisteredFunction() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
Execution dataSet = FunctionService.onRegion(region);
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
((AbstractExecution) dataSet).removeFunctionAttributes(TestFunction.TEST_FUNCTION2);
ResultCollector rs = dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE)
.execute(TestFunction.TEST_FUNCTION2);
@@ -1212,18 +1190,17 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
assertNotNull(functionAttributes);
}
- public static void serverSingleKeyExecution_SendException(Boolean isByName, Boolean toRegister)
- throws Exception {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecution_SendException(Boolean isByName, Boolean toRegister) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_SEND_EXCEPTION);
- if (toRegister.booleanValue()) {
+ if (toRegister) {
FunctionService.registerFunction(function);
} else {
FunctionService.unregisterFunction(function.getId());
@@ -1231,10 +1208,9 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
}
Execution dataSet = FunctionService.onRegion(region);
- region.put(testKey, new Integer(1));
- ResultCollector rs = null;
+ region.put(testKey, 1);
- rs = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
+ ResultCollector rs = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
assertTrue(((List) rs.getResult()).get(0) instanceof MyFunctionExecutionException);
rs = execute(dataSet, testKeysSet, (Serializable) testKeysSet, function, isByName);
@@ -1251,17 +1227,18 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
assertEquals(1, exceptionCount);
}
- public static void serverSingleKeyExecution_ThrowException(Boolean isByName, Boolean toRegister) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecution_ThrowException(Boolean isByName,
+ Boolean toRegister) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_THROW_EXCEPTION);
- if (toRegister.booleanValue()) {
+ if (toRegister) {
FunctionService.registerFunction(function);
} else {
FunctionService.unregisterFunction(function.getId());
@@ -1269,24 +1246,21 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
}
Execution dataSet = FunctionService.onRegion(region);
- region.put(testKey, new Integer(1));
- ResultCollector rs = null;
+ region.put(testKey, 1);
try {
- rs = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
+ execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
fail("Exception Expected");
- } catch (Exception ex) {
+ } catch (Exception ignored) {
}
}
- public static void serverSingleKeyExecutionWith2Regions(Boolean isByName, Boolean toRegister) {
- Region region1 = cache.getRegion(PartitionedRegionName + "1");
+ private static void serverSingleKeyExecutionWith2Regions(Boolean toRegister) {
+ Region<String, Integer> region1 = cache.getRegion(PartitionedRegionName + "1");
assertNotNull(region1);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
- testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
Function function = new TestFunction(true, TEST_FUNCTION2);
- if (toRegister.booleanValue()) {
+ if (toRegister) {
FunctionService.registerFunction(function);
} else {
FunctionService.unregisterFunction(function.getId());
@@ -1294,16 +1268,16 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
}
Execution dataSet1 = FunctionService.onRegion(region1);
- region1.put(testKey, new Integer(1));
+ region1.put(testKey, 1);
ResultCollector rs = dataSet1.execute(function.getId());
assertEquals(Boolean.FALSE, ((List) rs.getResult()).get(0));
- Region region2 = cache.getRegion(PartitionedRegionName + "2");
+ Region<String, Integer> region2 = cache.getRegion(PartitionedRegionName + "2");
assertNotNull(region2);
Execution dataSet2 = FunctionService.onRegion(region2);
- region2.put(testKey, new Integer(1));
+ region2.put(testKey, 1);
try {
rs = dataSet2.execute(function.getId());
assertEquals(Boolean.TRUE, ((List) rs.getResult()).get(0));
@@ -1315,18 +1289,17 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
}
}
- public static void serverSingleKeyExecution_NoLastResult(Boolean isByName, Boolean toRegister)
- throws Exception {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecution_NoLastResult(Boolean isByName, Boolean toRegister) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_NO_LASTRESULT);
- if (toRegister.booleanValue()) {
+ if (toRegister) {
FunctionService.registerFunction(function);
} else {
FunctionService.unregisterFunction(function.getId());
@@ -1334,7 +1307,7 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
}
Execution dataSet = FunctionService.onRegion(region);
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
try {
ResultCollector rs = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
assertEquals(Boolean.TRUE, ((List) rs.getResult()).get(0));
@@ -1347,11 +1320,11 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
}
}
- public static void serverSingleKeyExecution_FunctionInvocationTargetException() throws Exception {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecution_FunctionInvocationTargetException() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
@@ -1359,18 +1332,18 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
FunctionService.registerFunction(function);
Execution dataSet = FunctionService.onRegion(region);
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
ResultCollector rs = execute(dataSet, testKeysSet, Boolean.TRUE, function, false);
ArrayList list = (ArrayList) rs.getResult();
assertTrue(((Integer) list.get(0)) >= 5);
}
- public static void serverSingleKeyExecution_Inline() throws Exception {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecution_Inline() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
@@ -1383,10 +1356,12 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
}
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
}
@Override
@@ -1412,16 +1387,18 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
+ "</ExpectedException>");
}
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
ResultCollector rs =
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
} else {
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
}
}
@@ -1441,10 +1418,12 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
dataSet.withFilter(testKeysSet).setArguments(testKey).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
} else {
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
}
}
@@ -1479,16 +1458,16 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
}
- public static void serverBug43430() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverBug43430() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
Execution dataSet = FunctionService.onRegion(region);
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
try {
cache.getLogger()
.info("<ExpectedException action=add>"
@@ -1498,10 +1477,12 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
.execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
}
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
}
@Override
@@ -1518,7 +1499,7 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
if (!expected.getCause().getMessage().contains(
"Could not create an instance of org.apache.geode.internal.cache.execute.PRClientServerRegionFunctionExecutionDUnitTest$UnDeserializable")) {
throw expected;
- } ;
+ }
} finally {
cache.getLogger()
.info("<ExpectedException action=remove>"
@@ -1528,8 +1509,8 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
}
private static ResultCollector execute(Execution dataSet, Set testKeysSet, Serializable args,
- Function function, Boolean isByName) throws Exception {
- if (isByName.booleanValue()) {// by name
+ Function function, Boolean isByName) {
+ if (isByName) {// by name
return dataSet.withFilter(testKeysSet).setArguments(args).execute(function.getId());
} else { // By Instance
return dataSet.withFilter(testKeysSet).setArguments(args).execute(function);
@@ -1555,7 +1536,7 @@ public class PRClientServerRegionFunctionExecutionDUnitTest extends PRClientServ
}
};
runOnAllServers(suspect);
- client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.serverBug43430());
+ client.invoke(PRClientServerRegionFunctionExecutionDUnitTest::serverBug43430);
SerializableRunnable endSuspect = new SerializableRunnable() {
@Override
public void run() {
diff --git a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionFailoverDUnitTest.java b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionFailoverDUnitTest.java
index 63c39d9..13228e5 100644
--- a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionFailoverDUnitTest.java
+++ b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionFailoverDUnitTest.java
@@ -26,8 +26,12 @@ import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
+import org.apache.logging.log4j.Logger;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.UseParametersRunnerFactory;
import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.CacheFactory;
@@ -49,28 +53,34 @@ import org.apache.geode.internal.cache.GemFireCacheImpl;
import org.apache.geode.internal.cache.LocalRegion;
import org.apache.geode.internal.cache.functions.TestFunction;
import org.apache.geode.internal.cache.tier.sockets.CacheServerTestUtil;
+import org.apache.geode.internal.logging.LogService;
import org.apache.geode.test.dunit.Assert;
import org.apache.geode.test.dunit.AsyncInvocation;
import org.apache.geode.test.dunit.DistributedTestUtils;
import org.apache.geode.test.dunit.Host;
import org.apache.geode.test.dunit.IgnoredException;
-import org.apache.geode.test.dunit.LogWriterUtils;
import org.apache.geode.test.dunit.NetworkUtils;
import org.apache.geode.test.dunit.SerializableRunnable;
+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.junit.categories.ClientServerTest;
import org.apache.geode.test.junit.categories.FunctionServiceTest;
+import org.apache.geode.test.junit.runners.CategoryWithParameterizedRunnerFactory;
@Category({ClientServerTest.class, FunctionServiceTest.class})
+@RunWith(Parameterized.class)
+@UseParametersRunnerFactory(CategoryWithParameterizedRunnerFactory.class)
public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRClientServerTestBase {
+ private static final Logger logger = LogService.getLogger();
+
private static Locator locator = null;
- private static Region region = null;
+ private static Region<Integer, Object> region = null;
@Override
- protected void postSetUpPRClientServerTestBase() throws Exception {
+ protected void postSetUpPRClientServerTestBase() {
IgnoredException.addIgnoredException("Connection reset");
IgnoredException.addIgnoredException("SocketTimeoutException");
IgnoredException.addIgnoredException("ServerConnectivityException");
@@ -83,7 +93,7 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_SOCKET_TIMEOUT);
registerFunctionAtServer(function);
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
- .serverMultiKeyExecutionSocketTimeOut(new Boolean(true)));
+ .serverMultiKeyExecutionSocketTimeOut(Boolean.TRUE));
}
/*
@@ -91,25 +101,25 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
* failover to other available server
*/
@Test
- public void testServerFailoverWithTwoServerAliveHA() throws InterruptedException {
+ public void testServerFailoverWithTwoServerAliveHA() {
IgnoredException.addIgnoredException("FunctionInvocationTargetException");
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 1, 13, null);
+ createCommonServerAttributes("TestPartitionedRegion", null, 1, null);
createClientServerScenarion(commonAttributes, 20, 20, 20);
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_HA);
registerFunctionAtServer(function);
- server2.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.stopServerHA());
- server3.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.stopServerHA());
- client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.putOperation());
+ server2.invoke(PRClientServerRegionFunctionExecutionDUnitTest::stopServerHA);
+ server3.invoke(PRClientServerRegionFunctionExecutionDUnitTest::stopServerHA);
+ client.invoke(PRClientServerRegionFunctionExecutionDUnitTest::putOperation);
int AsyncInvocationArrSize = 1;
AsyncInvocation[] async = new AsyncInvocation[AsyncInvocationArrSize];
async[0] = client
- .invokeAsync(() -> PRClientServerRegionFunctionExecutionDUnitTest.executeFunctionHA());
- server2.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.startServerHA());
- server3.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.startServerHA());
- server1.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.stopServerHA());
+ .invokeAsync(PRClientServerRegionFunctionExecutionDUnitTest::executeFunctionHA);
+ server2.invoke(PRClientServerRegionFunctionExecutionDUnitTest::startServerHA);
+ server3.invoke(PRClientServerRegionFunctionExecutionDUnitTest::startServerHA);
+ server1.invoke(PRClientServerRegionFunctionExecutionDUnitTest::stopServerHA);
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
- .verifyDeadAndLiveServers(new Integer(1), new Integer(2)));
+ .verifyDeadAndLiveServers(2));
ThreadUtils.join(async[0], 6 * 60 * 1000);
if (async[0].getException() != null) {
Assert.fail("UnExpected Exception Occurred : ", async[0].getException());
@@ -123,25 +133,25 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
* failover to other available server
*/
@Test
- public void testServerCacheClosedFailoverWithTwoServerAliveHA() throws InterruptedException {
+ public void testServerCacheClosedFailoverWithTwoServerAliveHA() {
IgnoredException.addIgnoredException("FunctionInvocationTargetException");
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 1, 13, null);
+ createCommonServerAttributes("TestPartitionedRegion", null, 1, null);
createClientServerScenarion(commonAttributes, 20, 20, 20);
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_HA);
registerFunctionAtServer(function);
- server2.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.stopServerHA());
- server3.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.stopServerHA());
- client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.putOperation());
+ server2.invoke(PRClientServerRegionFunctionExecutionDUnitTest::stopServerHA);
+ server3.invoke(PRClientServerRegionFunctionExecutionDUnitTest::stopServerHA);
+ client.invoke(PRClientServerRegionFunctionExecutionDUnitTest::putOperation);
int AsyncInvocationArrSize = 1;
AsyncInvocation[] async = new AsyncInvocation[AsyncInvocationArrSize];
async[0] = client
- .invokeAsync(() -> PRClientServerRegionFunctionExecutionDUnitTest.executeFunctionHA());
- server2.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.startServerHA());
- server3.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.startServerHA());
- server1.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.closeCacheHA());
+ .invokeAsync(PRClientServerRegionFunctionExecutionDUnitTest::executeFunctionHA);
+ server2.invoke(PRClientServerRegionFunctionExecutionDUnitTest::startServerHA);
+ server3.invoke(PRClientServerRegionFunctionExecutionDUnitTest::startServerHA);
+ server1.invoke(PRClientServerRegionFunctionExecutionDUnitTest::closeCacheHA);
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
- .verifyDeadAndLiveServers(new Integer(1), new Integer(2)));
+ .verifyDeadAndLiveServers(2));
ThreadUtils.join(async[0], 5 * 60 * 1000);
if (async[0].getException() != null) {
Assert.fail("UnExpected Exception Occurred : ", async[0].getException());
@@ -153,27 +163,30 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
@Test
public void testBug40714() {
createScenario();
- server1.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.registerFunction());
- server1.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.registerFunction());
- server1.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.registerFunction());
- client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.registerFunction());
+ server1.invoke(
+ (SerializableRunnableIF) PRClientServerRegionFunctionExecutionDUnitTest::registerFunction);
+ server1.invoke(
+ (SerializableRunnableIF) PRClientServerRegionFunctionExecutionDUnitTest::registerFunction);
+ server1.invoke(
+ (SerializableRunnableIF) PRClientServerRegionFunctionExecutionDUnitTest::registerFunction);
+ client.invoke(
+ (SerializableRunnableIF) PRClientServerRegionFunctionExecutionDUnitTest::registerFunction);
client.invoke(
- () -> PRClientServerRegionFunctionExecutionDUnitTest.FunctionExecution_Inline_Bug40714());
+ PRClientServerRegionFunctionExecutionDUnitTest::FunctionExecution_Inline_Bug40714);
}
@Test
- public void testOnRegionFailoverWithTwoServerDownHA() throws InterruptedException {
+ public void testOnRegionFailoverWithTwoServerDownHA() {
IgnoredException.addIgnoredException("FunctionInvocationTargetException");
createScenario();
- server1.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.createReplicatedRegion());
+ server1.invoke(PRClientServerRegionFunctionExecutionDUnitTest::createReplicatedRegion);
- server2.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.createReplicatedRegion());
+ server2.invoke(PRClientServerRegionFunctionExecutionDUnitTest::createReplicatedRegion);
- server3.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.createReplicatedRegion());
+ server3.invoke(PRClientServerRegionFunctionExecutionDUnitTest::createReplicatedRegion);
- client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
- .createProxyRegion(NetworkUtils.getServerHostName(server1.getHost())));
+ client.invoke(PRClientServerRegionFunctionExecutionDUnitTest::createProxyRegion);
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_HA_REGION);
registerFunctionAtServer(function);
@@ -181,27 +194,25 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
.regionExecutionHATwoServerDown(Boolean.FALSE, function, Boolean.FALSE));
- client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
- .verifyMetaData(new Integer(2), new Integer(1)));
+ client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.verifyMetaData(2, 1));
}
// retry attempts is 2
@Test
- public void testOnRegionFailoverWithOneServerDownHA() throws InterruptedException {
+ public void testOnRegionFailoverWithOneServerDownHA() {
IgnoredException.addIgnoredException("FunctionInvocationTargetException");
createScenario();
server1
- .invokeAsync(() -> PRClientServerRegionFunctionExecutionDUnitTest.createReplicatedRegion());
+ .invokeAsync(PRClientServerRegionFunctionExecutionDUnitTest::createReplicatedRegion);
server2
- .invokeAsync(() -> PRClientServerRegionFunctionExecutionDUnitTest.createReplicatedRegion());
+ .invokeAsync(PRClientServerRegionFunctionExecutionDUnitTest::createReplicatedRegion);
server3
- .invokeAsync(() -> PRClientServerRegionFunctionExecutionDUnitTest.createReplicatedRegion());
+ .invokeAsync(PRClientServerRegionFunctionExecutionDUnitTest::createReplicatedRegion);
- client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
- .createProxyRegion(NetworkUtils.getServerHostName(server1.getHost())));
+ client.invoke(PRClientServerRegionFunctionExecutionDUnitTest::createProxyRegion);
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_HA_REGION);
registerFunctionAtServer(function);
@@ -210,7 +221,7 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
.regionExecutionHAOneServerDown(Boolean.FALSE, function, Boolean.FALSE));
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
- .verifyMetaData(new Integer(1), new Integer(1)));
+ .verifyMetaData(1, 1));
}
/*
@@ -218,18 +229,16 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
* shouldn't failover to other available server
*/
@Test
- public void testOnRegionFailoverNonHA() throws InterruptedException { // See #47489 before
- // enabling it
+ public void testOnRegionFailoverNonHA() {
createScenario();
IgnoredException.addIgnoredException("FunctionInvocationTargetException");
- server1.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.createReplicatedRegion());
+ server1.invoke(PRClientServerRegionFunctionExecutionDUnitTest::createReplicatedRegion);
- server2.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.createReplicatedRegion());
+ server2.invoke(PRClientServerRegionFunctionExecutionDUnitTest::createReplicatedRegion);
- server3.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.createReplicatedRegion());
+ server3.invoke(PRClientServerRegionFunctionExecutionDUnitTest::createReplicatedRegion);
- client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
- .createProxyRegion(NetworkUtils.getServerHostName(server1.getHost())));
+ client.invoke(PRClientServerRegionFunctionExecutionDUnitTest::createProxyRegion);
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_NONHA_REGION);
registerFunctionAtServer(function);
@@ -237,7 +246,7 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
.regionSingleKeyExecutionNonHA(Boolean.FALSE, function, Boolean.FALSE));
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
- .verifyMetaData(new Integer(1), new Integer(0)));
+ .verifyMetaData(1, 0));
}
/*
@@ -245,28 +254,24 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
* shouldn't failover to other available server
*/
@Test
- public void testOnRegionFailoverNonHASingleHop() throws InterruptedException { // See #47489
- // before enabling
- // it
+ public void testOnRegionFailoverNonHASingleHop() {
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 0, 13, null);
+ createCommonServerAttributes("TestPartitionedRegion", null, 0, null);
createClientServerScenarioSingleHop(commonAttributes, 20, 20, 20);
- server1.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.createReplicatedRegion());
+ server1.invoke(PRClientServerRegionFunctionExecutionDUnitTest::createReplicatedRegion);
- server2.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.createReplicatedRegion());
+ server2.invoke(PRClientServerRegionFunctionExecutionDUnitTest::createReplicatedRegion);
- server3.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest.createReplicatedRegion());
+ server3.invoke(PRClientServerRegionFunctionExecutionDUnitTest::createReplicatedRegion);
- client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
- .createProxyRegion(NetworkUtils.getServerHostName(server1.getHost())));
+ client.invoke(PRClientServerRegionFunctionExecutionDUnitTest::createProxyRegion);
// Make sure the buckets are created.
client.invoke(new SerializableRunnable() {
-
@Override
public void run() {
- region = (LocalRegion) cache.getRegion(PRClientServerTestBase.PartitionedRegionName);
+ region = cache.getRegion(PRClientServerTestBase.PartitionedRegionName);
for (int i = 0; i < 13; i++) {
region.put(i, i);
}
@@ -274,12 +279,12 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
});
// Make sure the client metadata is up to date.
- client.invoke(() -> PRClientServerRegionFunctionExecutionFailoverDUnitTest.fetchMetaData());
+ client.invoke(PRClientServerRegionFunctionExecutionFailoverDUnitTest::fetchMetaData);
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_NONHA_REGION);
registerFunctionAtServer(function);
final Function function2 = new TestFunction(true, TestFunction.TEST_FUNCTION_NONHA_NOP);
- registerFunctionAtServer(function);
+ registerFunctionAtServer(function2);
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
.regionSingleKeyExecutionNonHA(Boolean.FALSE, function, Boolean.FALSE));
@@ -300,11 +305,11 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
// });
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
- .verifyMetaData(new Integer(1), new Integer(0)));
+ .verifyMetaData(1, 0));
}
@Test
- public void testServerBucketMovedException() throws InterruptedException {
+ public void testServerBucketMovedException() {
IgnoredException.addIgnoredException("BucketMovedException");
final Host host = Host.getHost(0);
@@ -316,7 +321,7 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
disconnectAllFromDS();
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 1, 113, null);
+ createCommonServerAttributes("TestPartitionedRegion", null, 1, null);
final int portLocator = AvailablePort.getRandomAvailablePort(AvailablePort.SOCKET);
final String hostLocator = NetworkUtils.getServerHostName(server1.getHost());
@@ -325,22 +330,19 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
startLocatorInVM(portLocator);
try {
- Integer port1 =
- (Integer) server1.invoke(() -> createServerWithLocator(locator, false, commonAttributes));
+ server1.invoke(() -> createServerWithLocator(locator, false, commonAttributes));
- Integer port2 =
- (Integer) server2.invoke(() -> createServerWithLocator(locator, false, commonAttributes));
+ server2.invoke(() -> createServerWithLocator(locator, false, commonAttributes));
server4.invoke(() -> createClientWithLocator(hostLocator, portLocator));
- server4.invoke(() -> PRClientServerRegionFunctionExecutionFailoverDUnitTest.putIntoRegion());
+ server4.invoke(PRClientServerRegionFunctionExecutionFailoverDUnitTest::putIntoRegion);
- server4.invoke(() -> PRClientServerRegionFunctionExecutionFailoverDUnitTest.fetchMetaData());
+ server4.invoke(PRClientServerRegionFunctionExecutionFailoverDUnitTest::fetchMetaData);
- Integer port3 =
- (Integer) server3.invoke(() -> createServerWithLocator(locator, false, commonAttributes));
+ server3.invoke(() -> createServerWithLocator(locator, false, commonAttributes));
Object result = server4
- .invoke(() -> PRClientServerRegionFunctionExecutionFailoverDUnitTest.executeFunction());
+ .invoke(PRClientServerRegionFunctionExecutionFailoverDUnitTest::executeFunction);
List l = (List) result;
assertEquals(2, l.size());
@@ -350,17 +352,16 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
}
@Test
- public void testServerBucketMovedException_LocalServer() throws InterruptedException {
+ public void testServerBucketMovedException_LocalServer() {
IgnoredException.addIgnoredException("BucketMovedException");
final Host host = Host.getHost(0);
VM server1 = host.getVM(0);
VM server2 = host.getVM(1);
- VM server3 = host.getVM(2);
VM server4 = host.getVM(3);
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 0, 113, null);
+ createCommonServerAttributes("TestPartitionedRegion", null, 0, null);
final int portLocator = AvailablePort.getRandomAvailablePort(AvailablePort.SOCKET);
final String hostLocator = NetworkUtils.getServerHostName(server1.getHost());
@@ -369,19 +370,17 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
startLocatorInVM(portLocator);
try {
- Integer port1 =
- (Integer) server1.invoke(() -> createServerWithLocator(locator, false, commonAttributes));
+ server1.invoke(() -> createServerWithLocator(locator, false, commonAttributes));
server4.invoke(() -> createClientWithLocator(hostLocator, portLocator));
- server4.invoke(() -> PRClientServerRegionFunctionExecutionFailoverDUnitTest.putIntoRegion());
+ server4.invoke(PRClientServerRegionFunctionExecutionFailoverDUnitTest::putIntoRegion);
- server4.invoke(() -> PRClientServerRegionFunctionExecutionFailoverDUnitTest.fetchMetaData());
+ server4.invoke(PRClientServerRegionFunctionExecutionFailoverDUnitTest::fetchMetaData);
- Integer port2 =
- (Integer) server2.invoke(() -> createServerWithLocator(locator, false, commonAttributes));
+ server2.invoke(() -> createServerWithLocator(locator, false, commonAttributes));
Object result = server4
- .invoke(() -> PRClientServerRegionFunctionExecutionFailoverDUnitTest.executeFunction());
+ .invoke(PRClientServerRegionFunctionExecutionFailoverDUnitTest::executeFunction);
List l = (List) result;
assertEquals(2, l.size());
@@ -390,11 +389,11 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
}
}
- public static void fetchMetaData() {
+ private static void fetchMetaData() {
((GemFireCacheImpl) cache).getClientMetadataService().getClientPRMetadata((LocalRegion) region);
}
- public void startLocatorInVM(final int locatorPort) {
+ private void startLocatorInVM(final int locatorPort) {
File logFile = new File("locator-" + locatorPort + ".log");
@@ -413,12 +412,11 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
locator.stop();
}
- public int createServerWithLocator(String locator, boolean isAccessor, ArrayList commonAttrs) {
+ private int createServerWithLocator(String locator, boolean isAccessor, ArrayList commonAttrs) {
Properties props = new Properties();
- props = new Properties();
props.setProperty(LOCATORS, locator);
DistributedSystem ds = getSystem(props);
- cache = new CacheFactory(props).create(ds);
+ cache = CacheFactory.create(ds);
CacheServer server = cache.addCacheServer();
int port = AvailablePort.getRandomAvailablePort(AvailablePort.SOCKET);
@@ -433,22 +431,21 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
if (isAccessor) {
paf.setLocalMaxMemory(0);
}
- paf.setTotalNumBuckets(((Integer) commonAttrs.get(3)).intValue())
- .setRedundantCopies(((Integer) commonAttrs.get(2)).intValue());
+ paf.setTotalNumBuckets((Integer) commonAttrs.get(3))
+ .setRedundantCopies((Integer) commonAttrs.get(2));
AttributesFactory attr = new AttributesFactory();
attr.setPartitionAttributes(paf.create());
region = cache.createRegion(regionName, attr.create());
assertNotNull(region);
- LogWriterUtils.getLogWriter()
+ logger
.info("Partitioned Region " + regionName + " created Successfully :" + region.toString());
return port;
}
- public void createClientWithLocator(String host, int port0) {
+ private void createClientWithLocator(String host, int port0) {
Properties props = new Properties();
- props = new Properties();
props.setProperty(MCAST_PORT, "0");
props.setProperty(LOCATORS, "");
DistributedSystem ds = getSystem(props);
@@ -470,7 +467,7 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
RegionAttributes attrs = factory.create();
region = cache.createRegion(regionName, attrs);
assertNotNull(region);
- LogWriterUtils.getLogWriter()
+ logger
.info("Distributed Region " + regionName + " created Successfully :" + region.toString());
}
@@ -478,7 +475,7 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
for (int i = 0; i < 113; i++) {
region.put(i, "KB_" + i);
}
- LogWriterUtils.getLogWriter()
+ logger
.info("Distributed Region " + regionName + " Have size :" + region.size());
}
@@ -486,19 +483,14 @@ public class PRClientServerRegionFunctionExecutionFailoverDUnitTest extends PRCl
Execution execute = FunctionService.onRegion(region);
ResultCollector rc = execute.setArguments(Boolean.TRUE)
.execute(new TestFunction(true, TestFunction.TEST_FUNCTION_LASTRESULT));
- LogWriterUtils.getLogWriter().info("Exeuction Result :" + rc.getResult());
+ logger.info("Exeuction Result :" + rc.getResult());
List l = ((List) rc.getResult());
return l;
}
- public static void checkSize() {
- LogWriterUtils.getLogWriter()
- .info("Partitioned Region " + regionName + " Have size :" + region.size());
- }
-
protected void createScenario() {
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 0, 13, null);
+ createCommonServerAttributes("TestPartitionedRegion", null, 0, null);
createClientServerScenarion(commonAttributes, 20, 20, 20);
}
diff --git a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.java b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.java
index 3a36913..bdbdbbe 100644
--- a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.java
+++ b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.java
@@ -19,23 +19,21 @@ import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.io.EOFException;
-import java.io.IOException;
import java.io.Serializable;
-import java.net.SocketException;
-import java.net.SocketTimeoutException;
-import java.rmi.ServerException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
-import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
+import org.apache.logging.log4j.Logger;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.UseParametersRunnerFactory;
import org.apache.geode.cache.CacheClosedException;
import org.apache.geode.cache.Region;
@@ -46,30 +44,36 @@ import org.apache.geode.cache.execute.FunctionContext;
import org.apache.geode.cache.execute.FunctionException;
import org.apache.geode.cache.execute.FunctionInvocationTargetException;
import org.apache.geode.cache.execute.FunctionService;
-import org.apache.geode.cache.execute.RegionFunctionContext;
import org.apache.geode.cache.execute.ResultCollector;
-import org.apache.geode.distributed.DistributedMember;
+import org.apache.geode.cache.execute.ResultSender;
import org.apache.geode.distributed.DistributedSystem;
import org.apache.geode.internal.cache.PartitionedRegion;
import org.apache.geode.internal.cache.functions.TestFunction;
+import org.apache.geode.internal.logging.LogService;
import org.apache.geode.test.dunit.Assert;
import org.apache.geode.test.dunit.AsyncInvocation;
import org.apache.geode.test.dunit.IgnoredException;
-import org.apache.geode.test.dunit.LogWriterUtils;
+import org.apache.geode.test.dunit.SerializableRunnableIF;
import org.apache.geode.test.dunit.ThreadUtils;
import org.apache.geode.test.dunit.Wait;
import org.apache.geode.test.dunit.WaitCriterion;
import org.apache.geode.test.junit.categories.ClientServerTest;
import org.apache.geode.test.junit.categories.FunctionServiceTest;
+import org.apache.geode.test.junit.runners.CategoryWithParameterizedRunnerFactory;
@Category({ClientServerTest.class, FunctionServiceTest.class})
+@RunWith(Parameterized.class)
+@UseParametersRunnerFactory(CategoryWithParameterizedRunnerFactory.class)
public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
extends PRClientServerTestBase {
+
+ private static final Logger logger = LogService.getLogger();
+
private static final String TEST_FUNCTION7 = TestFunction.TEST_FUNCTION7;
private static final String TEST_FUNCTION2 = TestFunction.TEST_FUNCTION2;
- Boolean isByName = null;
+ private Boolean isByName = null;
private static int retryCount = 0;
@@ -85,7 +89,7 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(false);
+ isByName = Boolean.FALSE;
client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
.serverAllKeyExecution(isByName));
}
@@ -96,7 +100,7 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
@Test
public void testServerGetAllFunction() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.getAll());
+ client.invoke(PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::getAll);
}
/*
@@ -105,7 +109,7 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
@Test
public void testServerPutAllFunction() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.putAll());
+ client.invoke(PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::putAll);
}
/*
@@ -117,7 +121,7 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
.serverSingleKeyExecution(isByName));
}
@@ -130,8 +134,8 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
@Test
public void testserverSingleKeyExecution_FunctionInvocationTargetException() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
- .serverSingleKeyExecution_FunctionInvocationTargetException());
+ client.invoke(
+ PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::serverSingleKeyExecution_FunctionInvocationTargetException);
}
/*
@@ -143,15 +147,15 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_BUCKET_FILTER);
registerFunctionAtServer(function);
- Set<Integer> bucketFilterSet = new HashSet<Integer>();
+ Set<Integer> bucketFilterSet = new HashSet<>();
bucketFilterSet.add(3);
bucketFilterSet.add(6);
bucketFilterSet.add(8);
- client.invoke(() -> PRClientServerTestBase.serverBucketFilterExecution(bucketFilterSet));
+ client.invoke(() -> serverBucketFilterExecution(bucketFilterSet));
bucketFilterSet.clear();
// Test single filter
bucketFilterSet.add(7);
- client.invoke(() -> PRClientServerTestBase.serverBucketFilterExecution(bucketFilterSet));
+ client.invoke(() -> serverBucketFilterExecution(bucketFilterSet));
}
@Test
@@ -160,16 +164,16 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_BUCKET_FILTER);
registerFunctionAtServer(function);
// test multi key filter
- Set<Integer> bucketFilterSet = new HashSet<Integer>();
+ Set<Integer> bucketFilterSet = new HashSet<>();
bucketFilterSet.add(3);
bucketFilterSet.add(6);
bucketFilterSet.add(8);
- Set<Integer> keyFilterSet = new HashSet<Integer>();
+ Set<Integer> keyFilterSet = new HashSet<>();
keyFilterSet.add(75);
keyFilterSet.add(25);
- client.invoke(() -> PRClientServerTestBase.serverBucketFilterOverrideExecution(bucketFilterSet,
+ client.invoke(() -> serverBucketFilterOverrideExecution(bucketFilterSet,
keyFilterSet));
}
@@ -179,7 +183,7 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_SOCKET_TIMEOUT);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
.serverSingleKeyExecutionSocketTimeOut(isByName));
}
@@ -193,7 +197,7 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(false);
+ isByName = Boolean.FALSE;
client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
.serverSingleKeyExecution(isByName));
}
@@ -204,8 +208,8 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
@Test
public void testServerSingleKeyExecution_byInlineFunction() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
- .serverSingleKeyExecution_Inline());
+ client.invoke(
+ PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::serverSingleKeyExecution_Inline);
}
/*
@@ -217,15 +221,15 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
.serverMultiKeyExecution(isByName));
server1.invoke(
- () -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.checkBucketsOnServer());
+ PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::checkBucketsOnServer);
server2.invoke(
- () -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.checkBucketsOnServer());
+ PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::checkBucketsOnServer);
server3.invoke(
- () -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.checkBucketsOnServer());
+ PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::checkBucketsOnServer);
}
@Test
@@ -233,7 +237,7 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_SOCKET_TIMEOUT);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
.serverMultiKeyExecutionSocketTimeOut(isByName));
}
@@ -244,8 +248,8 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
@Test
public void testserverMultiKeyExecution_byInlineFunction() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
- .serverMultiKeyExecution_Inline());
+ client.invoke(
+ PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::serverMultiKeyExecution_Inline);
}
/*
@@ -257,8 +261,8 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
@Test
public void testserverMultiKeyExecution_FunctionInvocationTargetException() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
- .serverMultiKeyExecution_FunctionInvocationTargetException());
+ client.invoke(
+ PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::serverMultiKeyExecution_FunctionInvocationTargetException);
}
/*
@@ -270,7 +274,7 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(false, TEST_FUNCTION7);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
.serverMultiKeyExecutionNoResult(isByName));
}
@@ -284,7 +288,7 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(false);
+ isByName = Boolean.FALSE;
client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
.serverMultiKeyExecution(isByName));
}
@@ -298,7 +302,7 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
.serverMultiKeyExecutionOnASingleBucket(isByName));
}
@@ -312,7 +316,7 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(false);
+ isByName = Boolean.FALSE;
client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
.serverMultiKeyExecutionOnASingleBucket(isByName));
}
@@ -322,26 +326,26 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
* failover to other available server
*/
@Test
- public void testServerFailoverWithTwoServerAliveHA() throws InterruptedException {
+ public void testServerFailoverWithTwoServerAliveHA() {
IgnoredException.addIgnoredException("FunctionInvocationTargetException");
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 1, 13, null);
+ createCommonServerAttributes("TestPartitionedRegion", null, 1, null);
createClientServerScenarion(commonAttributes, 20, 20, 20);
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_HA);
registerFunctionAtServer(function);
- server2.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.stopServerHA());
- server3.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.stopServerHA());
- client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.putOperation());
+ server2.invoke(PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::stopServerHA);
+ server3.invoke(PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::stopServerHA);
+ client.invoke(PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::putOperation);
int AsyncInvocationArrSize = 1;
AsyncInvocation[] async = new AsyncInvocation[AsyncInvocationArrSize];
async[0] = client.invokeAsync(
- () -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.executeFunctionHA());
- server2.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.startServerHA());
- server3.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.startServerHA());
- server1.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.stopServerHA());
+ PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::executeFunctionHA);
+ server2.invoke(PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::startServerHA);
+ server3.invoke(PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::startServerHA);
+ server1.invoke(PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::stopServerHA);
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
- .verifyDeadAndLiveServers(new Integer(1), new Integer(2)));
+ .verifyDeadAndLiveServers(2));
ThreadUtils.join(async[0], 6 * 60 * 1000);
if (async[0].getException() != null) {
Assert.fail("UnExpected Exception Occurred : ", async[0].getException());
@@ -356,25 +360,25 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
* failover to other available server
*/
@Test
- public void testServerCacheClosedFailoverWithTwoServerAliveHA() throws InterruptedException {
+ public void testServerCacheClosedFailoverWithTwoServerAliveHA() {
IgnoredException.addIgnoredException("FunctionInvocationTargetException");
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 1, 13, null);
+ createCommonServerAttributes("TestPartitionedRegion", null, 1, null);
createClientServerScenarion(commonAttributes, 20, 20, 20);
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_HA);
registerFunctionAtServer(function);
- server2.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.stopServerHA());
- server3.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.stopServerHA());
- client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.putOperation());
+ server2.invoke(PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::stopServerHA);
+ server3.invoke(PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::stopServerHA);
+ client.invoke(PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::putOperation);
int AsyncInvocationArrSize = 1;
AsyncInvocation[] async = new AsyncInvocation[AsyncInvocationArrSize];
async[0] = client.invokeAsync(
- () -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.executeFunctionHA());
- server2.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.startServerHA());
- server3.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.startServerHA());
- server1.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.closeCacheHA());
+ PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::executeFunctionHA);
+ server2.invoke(PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::startServerHA);
+ server3.invoke(PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::startServerHA);
+ server1.invoke(PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::closeCacheHA);
client.invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
- .verifyDeadAndLiveServers(new Integer(1), new Integer(2)));
+ .verifyDeadAndLiveServers(2));
ThreadUtils.join(async[0], 5 * 60 * 1000);
if (async[0].getException() != null) {
Assert.fail("UnExpected Exception Occurred : ", async[0].getException());
@@ -387,25 +391,31 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
public void testBug40714() {
createScenario();
server1
- .invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.registerFunction());
+ .invoke(
+ (SerializableRunnableIF) PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::registerFunction);
server1
- .invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.registerFunction());
+ .invoke(
+ (SerializableRunnableIF) PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::registerFunction);
server1
- .invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.registerFunction());
+ .invoke(
+ (SerializableRunnableIF) PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::registerFunction);
client
- .invoke(() -> PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest.registerFunction());
+ .invoke(
+ (SerializableRunnableIF) PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest::registerFunction);
client.invoke(
- () -> PRClientServerRegionFunctionExecutionDUnitTest.FunctionExecution_Inline_Bug40714());
+ PRClientServerRegionFunctionExecutionDUnitTest::FunctionExecution_Inline_Bug40714);
}
public static void registerFunction() {
FunctionService.registerFunction(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
} else if (context.getArguments() instanceof Boolean) {
- context.getResultSender().lastResult(Boolean.FALSE);
+ resultSender.lastResult(Boolean.FALSE);
}
}
@@ -421,73 +431,19 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
});
}
- public static void FunctionExecution_Inline_Bug40714() {
- Region region = cache.getRegion(PartitionedRegionName);
- assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 10); i > 0; i--) {
- testKeysSet.add("execKey-" + i);
- }
- int j = 0;
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- region.put(i.next(), val);
- }
- HashMap resultMap = (HashMap) FunctionService.onRegion(region).setArguments(Boolean.TRUE)
- .execute(new FunctionAdapter() {
- @Override
- public void execute(FunctionContext context) {
- if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
- } else if (context.getArguments() instanceof Boolean) {
- context.getResultSender().lastResult(Boolean.TRUE);
- }
- }
-
- @Override
- public String getId() {
- return "Function";
- }
-
- @Override
- public boolean hasResult() {
- return true;
- }
- }).getResult();
-
- assertEquals(3, resultMap.size());
-
- Iterator mapIterator = resultMap.entrySet().iterator();
- Map.Entry entry = null;
- DistributedMember key = null;
- ArrayList resultListForMember = null;
-
- while (mapIterator.hasNext()) {
- entry = (Map.Entry) mapIterator.next();
- key = (DistributedMember) entry.getKey();
- resultListForMember = (ArrayList) entry.getValue();
-
- for (Object result : resultListForMember) {
- assertEquals(Boolean.TRUE, result);
- }
- }
-
- }
-
- public static void verifyDeadAndLiveServers(final Integer expectedDeadServers,
- final Integer expectedLiveServers) {
+ public static void verifyDeadAndLiveServers(final Integer expectedLiveServers) {
WaitCriterion wc = new WaitCriterion() {
String excuse;
@Override
public boolean done() {
int sz = pool.getConnectedServerCount();
- LogWriterUtils.getLogWriter().info("Checking for the Live Servers : Expected : "
- + expectedLiveServers + " Available :" + sz);
- if (sz == expectedLiveServers.intValue()) {
+ logger.info("Checking for the Live Servers : Expected : " + expectedLiveServers
+ + " Available :" + sz);
+ if (sz == expectedLiveServers) {
return true;
}
- excuse = "Expected " + expectedLiveServers.intValue() + " but found " + sz;
+ excuse = "Expected " + expectedLiveServers + " but found " + sz;
return false;
}
@@ -499,12 +455,12 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
Wait.waitForCriterion(wc, 3 * 60 * 1000, 1000, true);
}
- public static void executeFunction() throws ServerException, InterruptedException {
+ public static void executeFunction() {
Region region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 10); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 10); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -518,32 +474,24 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
HashMap resultMap = ((HashMap) rc1.getResult());
assertEquals(3, resultMap.size());
- Iterator mapIterator = resultMap.entrySet().iterator();
- Map.Entry entry = null;
- DistributedMember key = null;
- ArrayList resultListForMember = null;
-
- while (mapIterator.hasNext()) {
- entry = (Map.Entry) mapIterator.next();
- key = (DistributedMember) entry.getKey();
- resultListForMember = (ArrayList) entry.getValue();
+ for (Object o : resultMap.entrySet()) {
+ Map.Entry entry = (Map.Entry) o;
+ ArrayList resultListForMember = (ArrayList) entry.getValue();
for (Object result : resultListForMember) {
assertEquals(Boolean.TRUE, result);
}
}
} catch (Exception e) {
- LogWriterUtils.getLogWriter().info("Got an exception : " + e.getMessage());
- assertTrue(e instanceof EOFException || e instanceof SocketException
- || e instanceof SocketTimeoutException || e instanceof ServerException
- || e instanceof IOException || e instanceof CacheClosedException);
+ logger.info("Got an exception : " + e.getMessage());
+ assertTrue(e instanceof CacheClosedException);
}
}
- public static Object executeFunctionHA() throws Exception {
+ private static Object executeFunctionHA() {
Region region = cache.getRegion(PartitionedRegionName);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 10); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 10); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -553,52 +501,50 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
ResultCollector rc1 =
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(function.getId());
List l = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + l.size());
+ logger.info("Result size : " + l.size());
return l;
}
- public static void putOperation() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void putOperation() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 10); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 10); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String s : testKeysSet) {
+ Integer val = j++;
+ region.put(s, val);
}
}
private void createScenario() {
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 0, 13, null);
+ createCommonServerAttributes("TestPartitionedRegion", null, 0, null);
createClientServerScenarioNoSingleHop(commonAttributes, 20, 20, 20);
}
private void createScenarioForBucketFilter() {
ArrayList commonAttributes = createCommonServerAttributes("TestPartitionedRegion",
- new BucketFilterPRResolver(), 0, 113, null);
+ new BucketFilterPRResolver(), 0, null);
createClientServerScenarioNoSingleHop(commonAttributes, 20, 20, 20);
}
- public static void checkBucketsOnServer() {
+ private static void checkBucketsOnServer() {
PartitionedRegion region = (PartitionedRegion) cache.getRegion(PartitionedRegionName);
HashMap localBucket2RegionMap = (HashMap) region.getDataStore().getSizeLocally();
- LogWriterUtils.getLogWriter().info(
+ logger.info(
"Size of the " + PartitionedRegionName + " in this VM :- " + localBucket2RegionMap.size());
Set entrySet = localBucket2RegionMap.entrySet();
assertNotNull(entrySet);
}
- public static void serverAllKeyExecution(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverAllKeyExecution(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() / 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets / 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -607,43 +553,30 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
Execution dataSet = FunctionService.onRegion(region);
try {
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
+ HashSet<Integer> origVals = new HashSet<>();
+ for (String item : testKeysSet) {
+ Integer val = j++;
origVals.add(val);
- region.put(i.next(), val);
+ region.put(item, val);
}
ResultCollector rc1 = executeOnAll(dataSet, Boolean.TRUE, function, isByName);
- List resultList = (List) ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + resultList.size());
- LogWriterUtils.getLogWriter().info("Result are SSSS : " + resultList);
+ List resultList = (List) rc1.getResult();
+ logger.info("Result size : " + resultList.size());
+ logger.info("Result are SSSS : " + resultList);
assertEquals(3, resultList.size());
- Iterator resultIterator = resultList.iterator();
- Map.Entry entry = null;
- DistributedMember key = null;
- List resultListForMember = new ArrayList();
-
- // while (resultIterator.hasNext()) {
- // resultListForMember.add(resultIterator.next());
- //
- // for (Object result : resultListForMember) {
- // assertIndexDetailsEquals(Boolean.TRUE, result);
- // }
- // }
for (Object result : resultList) {
assertEquals(Boolean.TRUE, result);
}
- List l2 = null;
ResultCollector rc2 = executeOnAll(dataSet, testKeysSet, function, isByName);
- l2 = ((List) rc2.getResult());
+ List l2 = ((List) rc2.getResult());
assertEquals(3, l2.size());
- HashSet foundVals = new HashSet();
- for (Iterator i = l2.iterator(); i.hasNext();) {
- ArrayList subL = (ArrayList) (i.next());
+ HashSet<Integer> foundVals = new HashSet<>();
+ for (Object value : l2) {
+ ArrayList subL = (ArrayList) (value);
assertTrue(subL.size() > 0);
- for (Iterator subI = subL.iterator(); subI.hasNext();) {
- assertTrue(foundVals.add(subI.next()));
+ for (Object o : subL) {
+ assertTrue(foundVals.add((Integer) o));
}
}
assertEquals(origVals, foundVals);
@@ -655,27 +588,26 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
}
public static void getAll() {
- Region region = cache.getRegion(PartitionedRegionName);
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final List testKeysList = new ArrayList();
- for (int i = (totalNumBuckets.intValue() * 3); i > 0; i--) {
+ final List<String> testKeysList = new ArrayList<>();
+ for (int i = (totalNumBuckets * 3); i > 0; i--) {
testKeysList.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
try {
int j = 0;
- Map origVals = new HashMap();
- for (Iterator i = testKeysList.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- Object key = i.next();
+ Map<String, Integer> origVals = new HashMap<>();
+ for (String key : testKeysList) {
+ Integer val = j++;
origVals.put(key, val);
region.put(key, val);
}
Map resultMap = region.getAll(testKeysList);
- assertTrue(resultMap.equals(origVals));
+ assertEquals(resultMap, origVals);
Wait.pause(2000);
Map secondResultMap = region.getAll(testKeysList);
- assertTrue(secondResultMap.equals(origVals));
+ assertEquals(secondResultMap, origVals);
} catch (Exception e) {
Assert.fail("Test failed after the put operation", e);
@@ -684,27 +616,26 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
}
public static void putAll() {
- Region region = cache.getRegion(PartitionedRegionName);
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final List testKeysList = new ArrayList();
- for (int i = (totalNumBuckets.intValue() * 3); i > 0; i--) {
+ final List<String> testKeysList = new ArrayList<>();
+ for (int i = (totalNumBuckets * 3); i > 0; i--) {
testKeysList.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
try {
int j = 0;
- Map origVals = new HashMap();
- for (Iterator i = testKeysList.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- Object key = i.next();
+ Map<String, Integer> origVals = new HashMap<>();
+ for (String key : testKeysList) {
+ Integer val = j++;
origVals.put(key, val);
region.put(key, val);
}
Map resultMap = region.getAll(testKeysList);
- assertTrue(resultMap.equals(origVals));
+ assertEquals(resultMap, origVals);
Wait.pause(2000);
Map secondResultMap = region.getAll(testKeysList);
- assertTrue(secondResultMap.equals(origVals));
+ assertEquals(secondResultMap, origVals);
} catch (Exception e) {
Assert.fail("Test failed after the put operation", e);
@@ -712,52 +643,50 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
}
}
- public static void serverMultiKeyExecutionOnASingleBucket(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecutionOnASingleBucket(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
int j = 0;
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- region.put(i.next(), val);
+ for (String value : testKeysSet) {
+ Integer val = j++;
+ region.put(value, val);
}
DistributedSystem.setThreadsSocketPolicy(false);
- for (Iterator kiter = testKeysSet.iterator(); kiter.hasNext();) {
+ for (String o : testKeysSet) {
try {
- Set singleKeySet = Collections.singleton(kiter.next());
+ Set<String> singleKeySet = Collections.singleton(o);
Function function = new TestFunction(true, TEST_FUNCTION2);
FunctionService.registerFunction(function);
Execution dataSet = FunctionService.onRegion(region);
ResultCollector rc1 = execute(dataSet, singleKeySet, Boolean.TRUE, function, isByName);
- List l = null;
- l = ((List) rc1.getResult());
+ List l = ((List) rc1.getResult());
assertEquals(1, l.size());
ResultCollector rc2 =
- execute(dataSet, singleKeySet, new HashSet(singleKeySet), function, isByName);
- List l2 = null;
- l2 = ((List) rc2.getResult());
+ execute(dataSet, singleKeySet, new HashSet<>(singleKeySet), function, isByName);
+ List l2 = ((List) rc2.getResult());
assertEquals(1, l2.size());
List subList = (List) l2.iterator().next();
assertEquals(1, subList.size());
assertEquals(region.get(singleKeySet.iterator().next()), subList.iterator().next());
} catch (Exception expected) {
- LogWriterUtils.getLogWriter().info("Exception : " + expected.getMessage());
+ logger.info("Exception : " + expected.getMessage());
expected.printStackTrace();
fail("Test failed after the put operation");
}
}
}
- public static void serverMultiKeyExecution(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecution(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -766,31 +695,29 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
Execution dataSet = FunctionService.onRegion(region);
try {
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
+ HashSet<Integer> origVals = new HashSet<>();
+ for (String element : testKeysSet) {
+ Integer val = j++;
origVals.add(val);
- region.put(i.next(), val);
+ region.put(element, val);
}
- List l = null;
ResultCollector rc1 = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
- l = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + l.size());
+ List l = ((List) rc1.getResult());
+ logger.info("Result size : " + l.size());
assertEquals(3, l.size());
- for (Iterator i = l.iterator(); i.hasNext();) {
- assertEquals(Boolean.TRUE, i.next());
+ for (Object item : l) {
+ assertEquals(Boolean.TRUE, item);
}
- List l2 = null;
ResultCollector rc2 = execute(dataSet, testKeysSet, testKeysSet, function, isByName);
- l2 = ((List) rc2.getResult());
+ List l2 = ((List) rc2.getResult());
assertEquals(3, l2.size());
- HashSet foundVals = new HashSet();
- for (Iterator i = l2.iterator(); i.hasNext();) {
- ArrayList subL = (ArrayList) i.next();
+ HashSet<Integer> foundVals = new HashSet<>();
+ for (Object value : l2) {
+ ArrayList subL = (ArrayList) value;
assertTrue(subL.size() > 0);
- for (Iterator subI = subL.iterator(); subI.hasNext();) {
- assertTrue(foundVals.add(subI.next()));
+ for (Object o : subL) {
+ assertTrue(foundVals.add((Integer) o));
}
}
assertEquals(origVals, foundVals);
@@ -802,11 +729,11 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
}
- public static void serverMultiKeyExecutionSocketTimeOut(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecutionSocketTimeOut(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -815,19 +742,16 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
Execution dataSet = FunctionService.onRegion(region);
try {
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String value : testKeysSet) {
+ Integer val = j++;
+ region.put(value, val);
}
- List l = null;
ResultCollector rc1 = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
- l = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + l.size());
+ List l = ((List) rc1.getResult());
+ logger.info("Result size : " + l.size());
assertEquals(3, l.size());
- for (Iterator i = l.iterator(); i.hasNext();) {
- assertEquals(Boolean.TRUE, i.next());
+ for (Object o : l) {
+ assertEquals(Boolean.TRUE, o);
}
} catch (Exception e) {
@@ -836,11 +760,11 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
}
}
- public static void serverSingleKeyExecutionSocketTimeOut(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecutionSocketTimeOut(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
@@ -848,7 +772,7 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
FunctionService.registerFunction(function);
Execution dataSet = FunctionService.onRegion(region);
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
try {
ResultCollector rs = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
assertEquals(Boolean.TRUE, ((List) rs.getResult()).get(0));
@@ -858,37 +782,36 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
Assert.fail("Test failed after the put operation", ex);
}
}
- public static void serverMultiKeyExecution_Inline() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecution_Inline() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
Execution dataSet = FunctionService.onRegion(region);
try {
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String value : testKeysSet) {
+ Integer val = j++;
+ region.put(value, val);
}
- List l = null;
ResultCollector rc1 =
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
} else if (context.getArguments() instanceof Boolean) {
- context.getResultSender().lastResult(Boolean.TRUE);
+ resultSender.lastResult(Boolean.TRUE);
}
}
@@ -902,44 +825,41 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
return true;
}
});
- l = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + l.size());
+ List l = ((List) rc1.getResult());
+ logger.info("Result size : " + l.size());
assertEquals(3, l.size());
- for (Iterator i = l.iterator(); i.hasNext();) {
- assertEquals(Boolean.TRUE, i.next());
+ for (Object o : l) {
+ assertEquals(Boolean.TRUE, o);
}
} catch (Exception e) {
- LogWriterUtils.getLogWriter().info("Exception : " + e.getMessage());
+ logger.info("Exception : " + e.getMessage());
e.printStackTrace();
fail("Test failed after the put operation");
}
}
- public static void serverMultiKeyExecution_FunctionInvocationTargetException() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecution_FunctionInvocationTargetException() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
Execution dataSet = FunctionService.onRegion(region);
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String o : testKeysSet) {
+ Integer val = j++;
+ region.put(o, val);
}
- ResultCollector rc1 = null;
try {
- rc1 =
+ ResultCollector rc1 =
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
- if (((RegionFunctionContext) context).isPossibleDuplicate()) {
- context.getResultSender().lastResult(new Integer(retryCount));
+ if (context.isPossibleDuplicate()) {
+ context.getResultSender().lastResult(retryCount);
return;
}
if (context.getArguments() instanceof Boolean) {
@@ -967,11 +887,11 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
}
- public static void serverMultiKeyExecutionNoResult(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecutionNoResult(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -982,11 +902,9 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
String msg = "<ExpectedException action=add>" + "FunctionException" + "</ExpectedException>";
cache.getLogger().info(msg);
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String o : testKeysSet) {
+ Integer val = j++;
+ region.put(o, val);
}
ResultCollector rc1 = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
rc1.getResult();
@@ -994,7 +912,7 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
fail("Test failed after the put operation");
} catch (FunctionException expected) {
expected.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : " + expected.getMessage());
+ logger.info("Exception : " + expected.getMessage());
assertTrue(expected.getMessage()
.startsWith((String.format("Cannot %s result as the Function#hasResult() is false",
"return any"))));
@@ -1006,11 +924,11 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
}
}
- public static void serverSingleKeyExecution(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecution(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
@@ -1025,36 +943,36 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
|| expected.getMessage().startsWith("Unexpected exception during"));
}
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
try {
ResultCollector rs = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
assertEquals(Boolean.TRUE, ((List) rs.getResult()).get(0));
ResultCollector rs2 = execute(dataSet, testKeysSet, testKey, function, isByName);
- assertEquals(new Integer(1), ((List) rs2.getResult()).get(0));
+ assertEquals(1, ((List) rs2.getResult()).get(0));
- HashMap putData = new HashMap();
- putData.put(testKey + "1", new Integer(2));
- putData.put(testKey + "2", new Integer(3));
+ HashMap<String, Integer> putData = new HashMap<>();
+ putData.put(testKey + "1", 2);
+ putData.put(testKey + "2", 3);
ResultCollector rs1 = execute(dataSet, testKeysSet, putData, function, isByName);
assertEquals(Boolean.TRUE, ((List) rs1.getResult()).get(0));
- assertEquals(new Integer(2), region.get(testKey + "1"));
- assertEquals(new Integer(3), region.get(testKey + "2"));
+ assertEquals((Integer) 2, region.get(testKey + "1"));
+ assertEquals((Integer) 3, region.get(testKey + "2"));
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
Assert.fail("Test failed after the put operation", ex);
}
}
- public static void serverSingleKeyExecution_FunctionInvocationTargetException() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecution_FunctionInvocationTargetException() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
@@ -1062,7 +980,7 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
FunctionService.registerFunction(function);
Execution dataSet = FunctionService.onRegion(region);
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
try {
ResultCollector rs = execute(dataSet, testKeysSet, Boolean.TRUE, function, false);
ArrayList list = (ArrayList) rs.getResult();
@@ -1073,11 +991,11 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
}
}
- public static void serverSingleKeyExecution_Inline() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecution_Inline() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
@@ -1090,10 +1008,12 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
}
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
}
@Override
@@ -1107,7 +1027,7 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
}
});
} catch (Exception expected) {
- LogWriterUtils.getLogWriter().fine("Exception occurred : " + expected.getMessage());
+ logger.debug("Exception occurred : " + expected.getMessage());
assertTrue(expected.getMessage().contains("No target node found for KEY = " + testKey)
|| expected.getMessage().startsWith("Server could not send the reply")
|| expected.getMessage().startsWith("Unexpected exception during"));
@@ -1118,16 +1038,18 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
+ "</ExpectedException>");
}
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
try {
ResultCollector rs =
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
} else {
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
}
}
@@ -1147,10 +1069,12 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
dataSet.withFilter(testKeysSet).setArguments(testKey).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
} else {
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
}
}
@@ -1168,14 +1092,14 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
Assert.fail("Test failed after the put operation", ex);
}
}
private static ResultCollector execute(Execution dataSet, Set testKeysSet, Serializable args,
- Function function, Boolean isByName) throws Exception {
- if (isByName.booleanValue()) {// by name
+ Function function, Boolean isByName) {
+ if (isByName) {// by name
return dataSet.withFilter(testKeysSet).setArguments(args).execute(function.getId());
} else { // By Instance
return dataSet.withFilter(testKeysSet).setArguments(args).execute(function);
@@ -1183,8 +1107,8 @@ public class PRClientServerRegionFunctionExecutionNoSingleHopDUnitTest
}
private static ResultCollector executeOnAll(Execution dataSet, Serializable args,
- Function function, Boolean isByName) throws Exception {
- if (isByName.booleanValue()) {// by name
+ Function function, Boolean isByName) {
+ if (isByName) {// by name
return dataSet.setArguments(args).execute(function.getId());
} else { // By Instance
return dataSet.setArguments(args).execute(function);
diff --git a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.java b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.java
index dc0a342..3043d58 100644
--- a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.java
+++ b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.java
@@ -19,24 +19,22 @@ import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.io.EOFException;
-import java.io.IOException;
import java.io.Serializable;
-import java.net.SocketException;
-import java.net.SocketTimeoutException;
-import java.rmi.ServerException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
-import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
+import org.apache.logging.log4j.Logger;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.UseParametersRunnerFactory;
import org.apache.geode.cache.CacheClosedException;
import org.apache.geode.cache.Region;
@@ -47,31 +45,36 @@ import org.apache.geode.cache.execute.FunctionContext;
import org.apache.geode.cache.execute.FunctionException;
import org.apache.geode.cache.execute.FunctionInvocationTargetException;
import org.apache.geode.cache.execute.FunctionService;
-import org.apache.geode.cache.execute.RegionFunctionContext;
import org.apache.geode.cache.execute.ResultCollector;
+import org.apache.geode.cache.execute.ResultSender;
import org.apache.geode.distributed.ConfigurationProperties;
-import org.apache.geode.distributed.DistributedMember;
import org.apache.geode.distributed.DistributedSystem;
import org.apache.geode.internal.cache.PartitionedRegion;
import org.apache.geode.internal.cache.functions.TestFunction;
+import org.apache.geode.internal.logging.LogService;
import org.apache.geode.test.dunit.Assert;
import org.apache.geode.test.dunit.AsyncInvocation;
import org.apache.geode.test.dunit.IgnoredException;
-import org.apache.geode.test.dunit.LogWriterUtils;
+import org.apache.geode.test.dunit.SerializableRunnableIF;
import org.apache.geode.test.dunit.ThreadUtils;
import org.apache.geode.test.dunit.Wait;
import org.apache.geode.test.dunit.WaitCriterion;
import org.apache.geode.test.junit.categories.ClientServerTest;
import org.apache.geode.test.junit.categories.FunctionServiceTest;
+import org.apache.geode.test.junit.runners.CategoryWithParameterizedRunnerFactory;
@Category({ClientServerTest.class, FunctionServiceTest.class})
+@RunWith(Parameterized.class)
+@UseParametersRunnerFactory(CategoryWithParameterizedRunnerFactory.class)
public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
extends PRClientServerTestBase {
+ private static final Logger logger = LogService.getLogger();
+
private static final String TEST_FUNCTION7 = TestFunction.TEST_FUNCTION7;
private static final String TEST_FUNCTION2 = TestFunction.TEST_FUNCTION2;
- Boolean isByName = null;
+ private Boolean isByName = null;
private static int retryCount = 0;
@@ -95,7 +98,7 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(false);
+ isByName = Boolean.FALSE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
.serverAllKeyExecution(isByName));
}
@@ -106,7 +109,7 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
@Test
public void testServerGetAllFunction() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.getAll());
+ client.invoke(PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::getAll);
}
/*
@@ -115,7 +118,7 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
@Test
public void testServerPutAllFunction() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.putAll());
+ client.invoke(PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::putAll);
}
/*
@@ -127,7 +130,7 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
.serverSingleKeyExecution(isByName));
}
@@ -140,8 +143,8 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
@Test
public void testserverSingleKeyExecution_FunctionInvocationTargetException() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
- .serverSingleKeyExecution_FunctionInvocationTargetException());
+ client.invoke(
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::serverSingleKeyExecution_FunctionInvocationTargetException);
}
@Test
@@ -149,7 +152,7 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_SOCKET_TIMEOUT);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
.serverSingleKeyExecutionSocketTimeOut(isByName));
}
@@ -163,7 +166,7 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(false);
+ isByName = Boolean.FALSE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
.serverSingleKeyExecution(isByName));
}
@@ -174,8 +177,8 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
@Test
public void testServerSingleKeyExecution_byInlineFunction() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
- .serverSingleKeyExecution_Inline());
+ client.invoke(
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::serverSingleKeyExecution_Inline);
}
/*
@@ -187,15 +190,15 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
.serverMultiKeyExecution(isByName));
- server1.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
- .checkBucketsOnServer());
- server2.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
- .checkBucketsOnServer());
- server3.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
- .checkBucketsOnServer());
+ server1.invoke(
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::checkBucketsOnServer);
+ server2.invoke(
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::checkBucketsOnServer);
+ server3.invoke(
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::checkBucketsOnServer);
}
@Test
@@ -203,7 +206,7 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_SOCKET_TIMEOUT);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
.serverMultiKeyExecutionSocketTimeOut(isByName));
}
@@ -214,8 +217,8 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
@Test
public void testserverMultiKeyExecution_byInlineFunction() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
- .serverMultiKeyExecution_Inline());
+ client.invoke(
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::serverMultiKeyExecution_Inline);
}
/*
@@ -227,8 +230,8 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
@Test
public void testserverMultiKeyExecution_FunctionInvocationTargetException() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
- .serverMultiKeyExecution_FunctionInvocationTargetException());
+ client.invoke(
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::serverMultiKeyExecution_FunctionInvocationTargetException);
}
/*
@@ -240,7 +243,7 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(false, TEST_FUNCTION7);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
.serverMultiKeyExecutionNoResult(isByName));
}
@@ -254,7 +257,7 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(false);
+ isByName = Boolean.FALSE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
.serverMultiKeyExecution(isByName));
}
@@ -268,7 +271,7 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
.serverMultiKeyExecutionOnASingleBucket(isByName));
}
@@ -282,7 +285,7 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(false);
+ isByName = Boolean.FALSE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
.serverMultiKeyExecutionOnASingleBucket(isByName));
}
@@ -292,37 +295,37 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
* failover to other available server
*/
@Test
- public void testServerFailoverWithTwoServerAliveHA() throws InterruptedException {
+ public void testServerFailoverWithTwoServerAliveHA() {
IgnoredException.addIgnoredException("FunctionInvocationTargetException");
IgnoredException.addIgnoredException("Connection reset");
IgnoredException.addIgnoredException("SocketTimeoutException");
IgnoredException.addIgnoredException("ServerConnectivityException");
IgnoredException.addIgnoredException("Socket Closed");
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 1, 13, null);
+ createCommonServerAttributes("TestPartitionedRegion", null, 1, null);
createClientServerScenarion(commonAttributes, 20, 20, 20);
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_HA);
registerFunctionAtServer(function);
server2.invoke(
- () -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.stopServerHA());
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::stopServerHA);
server3.invoke(
- () -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.stopServerHA());
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::stopServerHA);
client.invoke(
- () -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.putOperation());
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::putOperation);
int AsyncInvocationArrSize = 1;
AsyncInvocation[] async = new AsyncInvocation[AsyncInvocationArrSize];
async[0] =
- client.invokeAsync(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
- .executeFunctionHA());
+ client.invokeAsync(
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::executeFunctionHA);
server2.invoke(
- () -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.startServerHA());
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::startServerHA);
server3.invoke(
- () -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.startServerHA());
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::startServerHA);
server1.invoke(
- () -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.stopServerHA());
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::stopServerHA);
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
- .verifyDeadAndLiveServers(new Integer(1), new Integer(2)));
+ .verifyDeadAndLiveServers(2));
ThreadUtils.join(async[0], 6 * 60 * 1000);
if (async[0].getException() != null) {
Assert.fail("UnExpected Exception Occurred : ", async[0].getException());
@@ -337,36 +340,36 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
* failover to other available server
*/
@Test
- public void testServerCacheClosedFailoverWithTwoServerAliveHA() throws InterruptedException {
+ public void testServerCacheClosedFailoverWithTwoServerAliveHA() {
IgnoredException.addIgnoredException("FunctionInvocationTargetException");
IgnoredException.addIgnoredException("Connection reset");
IgnoredException.addIgnoredException("SocketTimeoutException");
IgnoredException.addIgnoredException("ServerConnectivityException");
IgnoredException.addIgnoredException("Socket Closed");
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 1, 13, null);
+ createCommonServerAttributes("TestPartitionedRegion", null, 1, null);
createClientServerScenarion(commonAttributes, 20, 20, 20);
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_HA);
registerFunctionAtServer(function);
server2.invoke(
- () -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.stopServerHA());
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::stopServerHA);
server3.invoke(
- () -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.stopServerHA());
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::stopServerHA);
client.invoke(
- () -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.putOperation());
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::putOperation);
int AsyncInvocationArrSize = 1;
AsyncInvocation[] async = new AsyncInvocation[AsyncInvocationArrSize];
async[0] =
- client.invokeAsync(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
- .executeFunctionHA());
+ client.invokeAsync(
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::executeFunctionHA);
server2.invoke(
- () -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.startServerHA());
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::startServerHA);
server3.invoke(
- () -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.startServerHA());
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::startServerHA);
server1.invoke(
- () -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.closeCacheHA());
+ PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::closeCacheHA);
client.invoke(() -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
- .verifyDeadAndLiveServers(new Integer(1), new Integer(2)));
+ .verifyDeadAndLiveServers(2));
ThreadUtils.join(async[0], 5 * 60 * 1000);
if (async[0].getException() != null) {
Assert.fail("UnExpected Exception Occurred : ", async[0].getException());
@@ -379,25 +382,27 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
public void testBug40714() {
createScenario();
server1.invoke(
- () -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.registerFunction());
+ (SerializableRunnableIF) PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::registerFunction);
server1.invoke(
- () -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.registerFunction());
+ (SerializableRunnableIF) PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::registerFunction);
server1.invoke(
- () -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.registerFunction());
+ (SerializableRunnableIF) PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::registerFunction);
client.invoke(
- () -> PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest.registerFunction());
+ (SerializableRunnableIF) PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest::registerFunction);
client.invoke(
- () -> PRClientServerRegionFunctionExecutionDUnitTest.FunctionExecution_Inline_Bug40714());
+ PRClientServerRegionFunctionExecutionDUnitTest::FunctionExecution_Inline_Bug40714);
}
public static void registerFunction() {
FunctionService.registerFunction(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
} else if (context.getArguments() instanceof Boolean) {
- context.getResultSender().lastResult(Boolean.FALSE);
+ resultSender.lastResult(Boolean.FALSE);
}
}
@@ -413,73 +418,19 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
});
}
- public static void FunctionExecution_Inline_Bug40714() {
- Region region = cache.getRegion(PartitionedRegionName);
- assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 10); i > 0; i--) {
- testKeysSet.add("execKey-" + i);
- }
- int j = 0;
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- region.put(i.next(), val);
- }
- HashMap resultMap = (HashMap) FunctionService.onRegion(region).setArguments(Boolean.TRUE)
- .execute(new FunctionAdapter() {
- @Override
- public void execute(FunctionContext context) {
- if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
- } else if (context.getArguments() instanceof Boolean) {
- context.getResultSender().lastResult(Boolean.TRUE);
- }
- }
-
- @Override
- public String getId() {
- return "Function";
- }
-
- @Override
- public boolean hasResult() {
- return true;
- }
- }).getResult();
-
- assertEquals(3, resultMap.size());
-
- Iterator mapIterator = resultMap.entrySet().iterator();
- Map.Entry entry = null;
- DistributedMember key = null;
- ArrayList resultListForMember = null;
-
- while (mapIterator.hasNext()) {
- entry = (Map.Entry) mapIterator.next();
- key = (DistributedMember) entry.getKey();
- resultListForMember = (ArrayList) entry.getValue();
-
- for (Object result : resultListForMember) {
- assertEquals(Boolean.TRUE, result);
- }
- }
-
- }
-
- public static void verifyDeadAndLiveServers(final Integer expectedDeadServers,
- final Integer expectedLiveServers) {
+ public static void verifyDeadAndLiveServers(final Integer expectedLiveServers) {
WaitCriterion wc = new WaitCriterion() {
String excuse;
@Override
public boolean done() {
int sz = pool.getConnectedServerCount();
- LogWriterUtils.getLogWriter().info("Checking for the Live Servers : Expected : "
+ logger.info("Checking for the Live Servers : Expected : "
+ expectedLiveServers + " Available :" + sz);
- if (sz == expectedLiveServers.intValue()) {
+ if (sz == expectedLiveServers) {
return true;
}
- excuse = "Expected " + expectedLiveServers.intValue() + " but found " + sz;
+ excuse = "Expected " + expectedLiveServers + " but found " + sz;
return false;
}
@@ -491,12 +442,11 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
Wait.waitForCriterion(wc, 3 * 60 * 1000, 1000, true);
}
- public static void executeFunction() throws ServerException, InterruptedException {
-
+ public static void executeFunction() {
Region region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 10); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 10); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -510,32 +460,24 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
HashMap resultMap = ((HashMap) rc1.getResult());
assertEquals(3, resultMap.size());
- Iterator mapIterator = resultMap.entrySet().iterator();
- Map.Entry entry = null;
- DistributedMember key = null;
- ArrayList resultListForMember = null;
-
- while (mapIterator.hasNext()) {
- entry = (Map.Entry) mapIterator.next();
- key = (DistributedMember) entry.getKey();
- resultListForMember = (ArrayList) entry.getValue();
+ for (Object o : resultMap.entrySet()) {
+ Map.Entry entry = (Map.Entry) o;
+ ArrayList resultListForMember = (ArrayList) entry.getValue();
for (Object result : resultListForMember) {
assertEquals(Boolean.TRUE, result);
}
}
} catch (Exception e) {
- LogWriterUtils.getLogWriter().info("Got an exception : " + e.getMessage());
- assertTrue(e instanceof EOFException || e instanceof SocketException
- || e instanceof SocketTimeoutException || e instanceof ServerException
- || e instanceof IOException || e instanceof CacheClosedException);
+ logger.info("Got an exception : " + e.getMessage());
+ assertTrue(e instanceof CacheClosedException);
}
}
- public static Object executeFunctionHA() throws Exception {
+ private static Object executeFunctionHA() {
Region region = cache.getRegion(PartitionedRegionName);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 10); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 10); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -545,46 +487,44 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
ResultCollector rc1 =
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(function.getId());
List l = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + l.size());
+ logger.info("Result size : " + l.size());
return l;
}
- public static void putOperation() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void putOperation() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 10); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 10); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String s : testKeysSet) {
+ Integer val = j++;
+ region.put(s, val);
}
}
private void createScenario() {
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 0, 13, null);
+ createCommonServerAttributes("TestPartitionedRegion", null, 0, null);
createClientServerScenarioSelectorNoSingleHop(commonAttributes, 20, 20, 20);
}
- public static void checkBucketsOnServer() {
+ private static void checkBucketsOnServer() {
PartitionedRegion region = (PartitionedRegion) cache.getRegion(PartitionedRegionName);
HashMap localBucket2RegionMap = (HashMap) region.getDataStore().getSizeLocally();
- LogWriterUtils.getLogWriter().info(
+ logger.info(
"Size of the " + PartitionedRegionName + " in this VM :- " + localBucket2RegionMap.size());
Set entrySet = localBucket2RegionMap.entrySet();
assertNotNull(entrySet);
}
- public static void serverAllKeyExecution(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverAllKeyExecution(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() / 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets / 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -593,43 +533,30 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
Execution dataSet = FunctionService.onRegion(region);
try {
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
+ HashSet<Integer> origVals = new HashSet<>();
+ for (String item : testKeysSet) {
+ Integer val = j++;
origVals.add(val);
- region.put(i.next(), val);
+ region.put(item, val);
}
ResultCollector rc1 = executeOnAll(dataSet, Boolean.TRUE, function, isByName);
- List resultList = (List) ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + resultList.size());
- LogWriterUtils.getLogWriter().info("Result are SSSS : " + resultList);
+ List resultList = (List) rc1.getResult();
+ logger.info("Result size : " + resultList.size());
+ logger.info("Result are SSSS : " + resultList);
assertEquals(3, resultList.size());
- Iterator resultIterator = resultList.iterator();
- Map.Entry entry = null;
- DistributedMember key = null;
- List resultListForMember = new ArrayList();
-
- // while (resultIterator.hasNext()) {
- // resultListForMember.add(resultIterator.next());
- //
- // for (Object result : resultListForMember) {
- // assertIndexDetailsEquals(Boolean.TRUE, result);
- // }
- // }
for (Object result : resultList) {
assertEquals(Boolean.TRUE, result);
}
- List l2 = null;
ResultCollector rc2 = executeOnAll(dataSet, testKeysSet, function, isByName);
- l2 = ((List) rc2.getResult());
+ List l2 = ((List) rc2.getResult());
assertEquals(3, l2.size());
- HashSet foundVals = new HashSet();
- for (Iterator i = l2.iterator(); i.hasNext();) {
- ArrayList subL = (ArrayList) (i.next());
+ HashSet<Integer> foundVals = new HashSet();
+ for (Object value : l2) {
+ ArrayList subL = (ArrayList) (value);
assertTrue(subL.size() > 0);
- for (Iterator subI = subL.iterator(); subI.hasNext();) {
- assertTrue(foundVals.add(subI.next()));
+ for (Object o : subL) {
+ assertTrue(foundVals.add((Integer) o));
}
}
assertEquals(origVals, foundVals);
@@ -641,27 +568,26 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
}
public static void getAll() {
- Region region = cache.getRegion(PartitionedRegionName);
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final List testKeysList = new ArrayList();
- for (int i = (totalNumBuckets.intValue() * 3); i > 0; i--) {
+ final List<String> testKeysList = new ArrayList<>();
+ for (int i = (totalNumBuckets * 3); i > 0; i--) {
testKeysList.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
try {
int j = 0;
- Map origVals = new HashMap();
- for (Iterator i = testKeysList.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- Object key = i.next();
+ Map<String, Integer> origVals = new HashMap<>();
+ for (String key : testKeysList) {
+ Integer val = j++;
origVals.put(key, val);
region.put(key, val);
}
Map resultMap = region.getAll(testKeysList);
- assertTrue(resultMap.equals(origVals));
+ assertEquals(resultMap, origVals);
Wait.pause(2000);
Map secondResultMap = region.getAll(testKeysList);
- assertTrue(secondResultMap.equals(origVals));
+ assertEquals(secondResultMap, origVals);
} catch (Exception e) {
Assert.fail("Test failed after the put operation", e);
@@ -670,27 +596,26 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
}
public static void putAll() {
- Region region = cache.getRegion(PartitionedRegionName);
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final List testKeysList = new ArrayList();
- for (int i = (totalNumBuckets.intValue() * 3); i > 0; i--) {
+ final List<String> testKeysList = new ArrayList<>();
+ for (int i = (totalNumBuckets * 3); i > 0; i--) {
testKeysList.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
try {
int j = 0;
- Map origVals = new HashMap();
- for (Iterator i = testKeysList.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- Object key = i.next();
+ Map<String, Integer> origVals = new HashMap<>();
+ for (String key : testKeysList) {
+ Integer val = j++;
origVals.put(key, val);
region.put(key, val);
}
Map resultMap = region.getAll(testKeysList);
- assertTrue(resultMap.equals(origVals));
+ assertEquals(resultMap, origVals);
Wait.pause(2000);
Map secondResultMap = region.getAll(testKeysList);
- assertTrue(secondResultMap.equals(origVals));
+ assertEquals(secondResultMap, origVals);
} catch (Exception e) {
Assert.fail("Test failed after the put operation", e);
@@ -698,52 +623,50 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
}
}
- public static void serverMultiKeyExecutionOnASingleBucket(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecutionOnASingleBucket(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
int j = 0;
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- region.put(i.next(), val);
+ for (String value : testKeysSet) {
+ Integer val = j++;
+ region.put(value, val);
}
DistributedSystem.setThreadsSocketPolicy(false);
- for (Iterator kiter = testKeysSet.iterator(); kiter.hasNext();) {
+ for (String o : testKeysSet) {
try {
- Set singleKeySet = Collections.singleton(kiter.next());
+ Set<String> singleKeySet = Collections.singleton(o);
Function function = new TestFunction(true, TEST_FUNCTION2);
FunctionService.registerFunction(function);
Execution dataSet = FunctionService.onRegion(region);
ResultCollector rc1 = execute(dataSet, singleKeySet, Boolean.TRUE, function, isByName);
- List l = null;
- l = ((List) rc1.getResult());
+ List l = ((List) rc1.getResult());
assertEquals(1, l.size());
ResultCollector rc2 =
- execute(dataSet, singleKeySet, new HashSet(singleKeySet), function, isByName);
- List l2 = null;
- l2 = ((List) rc2.getResult());
+ execute(dataSet, singleKeySet, new HashSet<>(singleKeySet), function, isByName);
+ List l2 = ((List) rc2.getResult());
assertEquals(1, l2.size());
List subList = (List) l2.iterator().next();
assertEquals(1, subList.size());
assertEquals(region.get(singleKeySet.iterator().next()), subList.iterator().next());
} catch (Exception expected) {
- LogWriterUtils.getLogWriter().info("Exception : " + expected.getMessage());
+ logger.info("Exception : " + expected.getMessage());
expected.printStackTrace();
fail("Test failed after the put operation");
}
}
}
- public static void serverMultiKeyExecution(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecution(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -752,31 +675,29 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
Execution dataSet = FunctionService.onRegion(region);
try {
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
+ HashSet<Integer> origVals = new HashSet<>();
+ for (String element : testKeysSet) {
+ Integer val = j++;
origVals.add(val);
- region.put(i.next(), val);
+ region.put(element, val);
}
- List l = null;
ResultCollector rc1 = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
- l = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + l.size());
+ List l = ((List) rc1.getResult());
+ logger.info("Result size : " + l.size());
assertEquals(3, l.size());
- for (Iterator i = l.iterator(); i.hasNext();) {
- assertEquals(Boolean.TRUE, i.next());
+ for (Object item : l) {
+ assertEquals(Boolean.TRUE, item);
}
- List l2 = null;
ResultCollector rc2 = execute(dataSet, testKeysSet, testKeysSet, function, isByName);
- l2 = ((List) rc2.getResult());
+ List l2 = ((List) rc2.getResult());
assertEquals(3, l2.size());
- HashSet foundVals = new HashSet();
- for (Iterator i = l2.iterator(); i.hasNext();) {
- ArrayList subL = (ArrayList) i.next();
+ HashSet<Integer> foundVals = new HashSet<>();
+ for (Object value : l2) {
+ ArrayList subL = (ArrayList) value;
assertTrue(subL.size() > 0);
- for (Iterator subI = subL.iterator(); subI.hasNext();) {
- assertTrue(foundVals.add(subI.next()));
+ for (Object o : subL) {
+ assertTrue(foundVals.add((Integer) o));
}
}
assertEquals(origVals, foundVals);
@@ -787,11 +708,11 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
}
}
- public static void serverMultiKeyExecutionSocketTimeOut(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecutionSocketTimeOut(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -800,19 +721,16 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
Execution dataSet = FunctionService.onRegion(region);
try {
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String value : testKeysSet) {
+ Integer val = j++;
+ region.put(value, val);
}
- List l = null;
ResultCollector rc1 = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
- l = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + l.size());
+ List l = ((List) rc1.getResult());
+ logger.info("Result size : " + l.size());
assertEquals(3, l.size());
- for (Iterator i = l.iterator(); i.hasNext();) {
- assertEquals(Boolean.TRUE, i.next());
+ for (Object o : l) {
+ assertEquals(Boolean.TRUE, o);
}
} catch (Exception e) {
@@ -821,11 +739,11 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
}
}
- public static void serverSingleKeyExecutionSocketTimeOut(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecutionSocketTimeOut(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
@@ -833,7 +751,7 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
FunctionService.registerFunction(function);
Execution dataSet = FunctionService.onRegion(region);
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
try {
ResultCollector rs = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
assertEquals(Boolean.TRUE, ((List) rs.getResult()).get(0));
@@ -843,37 +761,36 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
Assert.fail("Test failed after the put operation", ex);
}
}
- public static void serverMultiKeyExecution_Inline() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecution_Inline() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
Execution dataSet = FunctionService.onRegion(region);
try {
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String value : testKeysSet) {
+ Integer val = j++;
+ region.put(value, val);
}
- List l = null;
ResultCollector rc1 =
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
} else if (context.getArguments() instanceof Boolean) {
- context.getResultSender().lastResult(Boolean.TRUE);
+ resultSender.lastResult(Boolean.TRUE);
}
}
@@ -887,44 +804,41 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
return true;
}
});
- l = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + l.size());
+ List l = ((List) rc1.getResult());
+ logger.info("Result size : " + l.size());
assertEquals(3, l.size());
- for (Iterator i = l.iterator(); i.hasNext();) {
- assertEquals(Boolean.TRUE, i.next());
+ for (Object o : l) {
+ assertEquals(Boolean.TRUE, o);
}
} catch (Exception e) {
- LogWriterUtils.getLogWriter().info("Exception : " + e.getMessage());
+ logger.info("Exception : " + e.getMessage());
e.printStackTrace();
fail("Test failed after the put operation");
}
}
- public static void serverMultiKeyExecution_FunctionInvocationTargetException() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecution_FunctionInvocationTargetException() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
Execution dataSet = FunctionService.onRegion(region);
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String o : testKeysSet) {
+ Integer val = j++;
+ region.put(o, val);
}
- ResultCollector rc1 = null;
try {
- rc1 =
+ ResultCollector rc1 =
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
- if (((RegionFunctionContext) context).isPossibleDuplicate()) {
- context.getResultSender().lastResult(new Integer(retryCount));
+ if (context.isPossibleDuplicate()) {
+ context.getResultSender().lastResult(retryCount);
return;
}
if (context.getArguments() instanceof Boolean) {
@@ -952,11 +866,11 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
}
- public static void serverMultiKeyExecutionNoResult(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecutionNoResult(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -967,11 +881,9 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
String msg = "<ExpectedException action=add>" + "FunctionException" + "</ExpectedException>";
cache.getLogger().info(msg);
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String o : testKeysSet) {
+ Integer val = j++;
+ region.put(o, val);
}
ResultCollector rc1 = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
rc1.getResult();
@@ -979,7 +891,7 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
fail("Test failed after the put operation");
} catch (FunctionException expected) {
expected.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : " + expected.getMessage());
+ logger.info("Exception : " + expected.getMessage());
assertTrue(expected.getMessage()
.startsWith((String.format("Cannot %s result as the Function#hasResult() is false",
"return any"))));
@@ -991,11 +903,11 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
}
}
- public static void serverSingleKeyExecution(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecution(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
@@ -1010,36 +922,36 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
|| expected.getMessage().startsWith("Unexpected exception during"));
}
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
try {
ResultCollector rs = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
assertEquals(Boolean.TRUE, ((List) rs.getResult()).get(0));
ResultCollector rs2 = execute(dataSet, testKeysSet, testKey, function, isByName);
- assertEquals(new Integer(1), ((List) rs2.getResult()).get(0));
+ assertEquals(1, ((List) rs2.getResult()).get(0));
- HashMap putData = new HashMap();
- putData.put(testKey + "1", new Integer(2));
- putData.put(testKey + "2", new Integer(3));
+ HashMap<String, Integer> putData = new HashMap<>();
+ putData.put(testKey + "1", 2);
+ putData.put(testKey + "2", 3);
ResultCollector rs1 = execute(dataSet, testKeysSet, putData, function, isByName);
assertEquals(Boolean.TRUE, ((List) rs1.getResult()).get(0));
- assertEquals(new Integer(2), region.get(testKey + "1"));
- assertEquals(new Integer(3), region.get(testKey + "2"));
+ assertEquals((Integer) 2, region.get(testKey + "1"));
+ assertEquals((Integer) 3, region.get(testKey + "2"));
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
Assert.fail("Test failed after the put operation", ex);
}
}
- public static void serverSingleKeyExecution_FunctionInvocationTargetException() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecution_FunctionInvocationTargetException() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
@@ -1047,7 +959,7 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
FunctionService.registerFunction(function);
Execution dataSet = FunctionService.onRegion(region);
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
try {
ResultCollector rs = execute(dataSet, testKeysSet, Boolean.TRUE, function, false);
ArrayList list = (ArrayList) rs.getResult();
@@ -1058,11 +970,11 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
}
}
- public static void serverSingleKeyExecution_Inline() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecution_Inline() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
@@ -1075,10 +987,12 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
}
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
}
@Override
@@ -1092,7 +1006,7 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
}
});
} catch (Exception expected) {
- LogWriterUtils.getLogWriter().fine("Exception occurred : " + expected.getMessage());
+ logger.debug("Exception occurred : " + expected.getMessage());
assertTrue(expected.getMessage().contains("No target node found for KEY = " + testKey)
|| expected.getMessage().startsWith("Server could not send the reply")
|| expected.getMessage().startsWith("Unexpected exception during"));
@@ -1103,16 +1017,18 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
+ "</ExpectedException>");
}
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
try {
ResultCollector rs =
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
} else {
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
}
}
@@ -1132,10 +1048,12 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
dataSet.withFilter(testKeysSet).setArguments(testKey).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
} else {
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
}
}
@@ -1153,14 +1071,14 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
Assert.fail("Test failed after the put operation", ex);
}
}
private static ResultCollector execute(Execution dataSet, Set testKeysSet, Serializable args,
- Function function, Boolean isByName) throws Exception {
- if (isByName.booleanValue()) {// by name
+ Function function, Boolean isByName) {
+ if (isByName) {// by name
return dataSet.withFilter(testKeysSet).setArguments(args).execute(function.getId());
} else { // By Instance
return dataSet.withFilter(testKeysSet).setArguments(args).execute(function);
@@ -1168,8 +1086,8 @@ public class PRClientServerRegionFunctionExecutionSelectorNoSingleHopDUnitTest
}
private static ResultCollector executeOnAll(Execution dataSet, Serializable args,
- Function function, Boolean isByName) throws Exception {
- if (isByName.booleanValue()) {// by name
+ Function function, Boolean isByName) {
+ if (isByName) {// by name
return dataSet.setArguments(args).execute(function.getId());
} else { // By Instance
return dataSet.setArguments(args).execute(function);
diff --git a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionSingleHopDUnitTest.java b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionSingleHopDUnitTest.java
index a479b30..3fcb454 100644
--- a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionSingleHopDUnitTest.java
+++ b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerRegionFunctionExecutionSingleHopDUnitTest.java
@@ -12,6 +12,7 @@
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
+
package org.apache.geode.internal.cache.execute;
import static org.junit.Assert.assertEquals;
@@ -19,12 +20,7 @@ import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.io.EOFException;
-import java.io.IOException;
import java.io.Serializable;
-import java.net.SocketException;
-import java.net.SocketTimeoutException;
-import java.rmi.ServerException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
@@ -34,8 +30,12 @@ import java.util.List;
import java.util.Map;
import java.util.Set;
+import org.apache.logging.log4j.Logger;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.UseParametersRunnerFactory;
import org.apache.geode.cache.CacheClosedException;
import org.apache.geode.cache.Region;
@@ -46,30 +46,36 @@ import org.apache.geode.cache.execute.FunctionContext;
import org.apache.geode.cache.execute.FunctionException;
import org.apache.geode.cache.execute.FunctionInvocationTargetException;
import org.apache.geode.cache.execute.FunctionService;
-import org.apache.geode.cache.execute.RegionFunctionContext;
import org.apache.geode.cache.execute.ResultCollector;
+import org.apache.geode.cache.execute.ResultSender;
import org.apache.geode.distributed.DistributedSystem;
import org.apache.geode.distributed.DistributedSystemDisconnectedException;
import org.apache.geode.internal.cache.PartitionedRegion;
import org.apache.geode.internal.cache.functions.TestFunction;
+import org.apache.geode.internal.logging.LogService;
import org.apache.geode.test.dunit.Assert;
import org.apache.geode.test.dunit.AsyncInvocation;
import org.apache.geode.test.dunit.IgnoredException;
-import org.apache.geode.test.dunit.LogWriterUtils;
+import org.apache.geode.test.dunit.SerializableRunnableIF;
import org.apache.geode.test.dunit.ThreadUtils;
import org.apache.geode.test.dunit.Wait;
import org.apache.geode.test.dunit.WaitCriterion;
import org.apache.geode.test.junit.categories.ClientServerTest;
import org.apache.geode.test.junit.categories.FunctionServiceTest;
+import org.apache.geode.test.junit.runners.CategoryWithParameterizedRunnerFactory;
@Category({ClientServerTest.class, FunctionServiceTest.class})
+@RunWith(Parameterized.class)
+@UseParametersRunnerFactory(CategoryWithParameterizedRunnerFactory.class)
public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
extends PRClientServerTestBase {
+ private static final Logger logger = LogService.getLogger();
+
private static final String TEST_FUNCTION7 = TestFunction.TEST_FUNCTION7;
private static final String TEST_FUNCTION2 = TestFunction.TEST_FUNCTION2;
- Boolean isByName = null;
+ private Boolean isByName = null;
private static int retryCount = 0;
@@ -78,7 +84,7 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
}
@Override
- public final void preSetUp() throws Exception {
+ public final void preSetUp() {
// Workaround for bug #52004
IgnoredException.addIgnoredException("InternalFunctionInvocationTargetException");
IgnoredException.addIgnoredException("Connection refused");
@@ -92,7 +98,7 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(false);
+ isByName = Boolean.FALSE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest
.serverAllKeyExecution(isByName));
}
@@ -104,7 +110,7 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
@Test
public void testServerGetAllFunction() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.getAll());
+ client.invoke(PRClientServerRegionFunctionExecutionSingleHopDUnitTest::getAll);
}
/*
@@ -113,7 +119,7 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
@Test
public void testServerPutAllFunction() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.putAll());
+ client.invoke(PRClientServerRegionFunctionExecutionSingleHopDUnitTest::putAll);
}
/*
@@ -125,7 +131,7 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest
.serverSingleKeyExecution(isByName));
}
@@ -138,8 +144,8 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
@Test
public void testserverSingleKeyExecution_FunctionInvocationTargetException() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest
- .serverSingleKeyExecution_FunctionInvocationTargetException());
+ client.invoke(
+ PRClientServerRegionFunctionExecutionSingleHopDUnitTest::serverSingleKeyExecution_FunctionInvocationTargetException);
}
@Test
@@ -168,7 +174,7 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(false);
+ isByName = Boolean.FALSE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest
.serverSingleKeyExecution(isByName));
}
@@ -179,8 +185,8 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
@Test
public void testServerSingleKeyExecution_byInlineFunction() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest
- .serverSingleKeyExecution_Inline());
+ client.invoke(
+ PRClientServerRegionFunctionExecutionSingleHopDUnitTest::serverSingleKeyExecution_Inline);
}
/*
@@ -192,15 +198,15 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest
.serverMultiKeyExecution(isByName));
server1.invoke(
- () -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.checkBucketsOnServer());
+ PRClientServerRegionFunctionExecutionSingleHopDUnitTest::checkBucketsOnServer);
server2.invoke(
- () -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.checkBucketsOnServer());
+ PRClientServerRegionFunctionExecutionSingleHopDUnitTest::checkBucketsOnServer);
server3.invoke(
- () -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.checkBucketsOnServer());
+ PRClientServerRegionFunctionExecutionSingleHopDUnitTest::checkBucketsOnServer);
}
/*
@@ -211,15 +217,17 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
createScenarioForBucketFilter();
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_BUCKET_FILTER);
registerFunctionAtServer(function);
- Set<Integer> bucketFilterSet = new HashSet<Integer>();
+ Set<Integer> bucketFilterSet = new HashSet<>();
bucketFilterSet.add(3);
bucketFilterSet.add(6);
bucketFilterSet.add(8);
- client.invoke(() -> PRClientServerTestBase.serverBucketFilterExecution(bucketFilterSet));
+ final SerializableRunnableIF serverBucketFilterExecution =
+ () -> serverBucketFilterExecution(bucketFilterSet);
+ client.invoke(serverBucketFilterExecution);
bucketFilterSet.clear();
// Test single filter
bucketFilterSet.add(7);
- client.invoke(() -> PRClientServerTestBase.serverBucketFilterExecution(bucketFilterSet));
+ client.invoke(serverBucketFilterExecution);
}
@Test
@@ -228,18 +236,16 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_BUCKET_FILTER);
registerFunctionAtServer(function);
// test multi key filter
- Set<Integer> bucketFilterSet = new HashSet<Integer>();
+ Set<Integer> bucketFilterSet = new HashSet<>();
bucketFilterSet.add(3);
bucketFilterSet.add(6);
bucketFilterSet.add(8);
- Set<Integer> keyFilterSet = new HashSet<Integer>();
+ Set<Integer> keyFilterSet = new HashSet<>();
keyFilterSet.add(75);
keyFilterSet.add(25);
- client.invoke(() -> PRClientServerTestBase.serverBucketFilterOverrideExecution(bucketFilterSet,
- keyFilterSet));
-
+ client.invoke(() -> serverBucketFilterOverrideExecution(bucketFilterSet, keyFilterSet));
}
@Test
@@ -247,7 +253,7 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_SOCKET_TIMEOUT);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest
.serverMultiKeyExecutionSocketTimeOut(isByName));
}
@@ -258,8 +264,8 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
@Test
public void testserverMultiKeyExecution_byInlineFunction() {
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest
- .serverMultiKeyExecution_Inline());
+ client.invoke(
+ PRClientServerRegionFunctionExecutionSingleHopDUnitTest::serverMultiKeyExecution_Inline);
}
/*
@@ -274,8 +280,8 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
IgnoredException
.addIgnoredException("java.net.SocketException: Software caused connection abort");
createScenario();
- client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest
- .serverMultiKeyExecution_FunctionInvocationTargetException());
+ client.invoke(
+ PRClientServerRegionFunctionExecutionSingleHopDUnitTest::serverMultiKeyExecution_FunctionInvocationTargetException);
}
/*
@@ -288,7 +294,7 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
createScenario();
Function function = new TestFunction(false, TEST_FUNCTION7);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest
.serverMultiKeyExecutionNoResult(isByName));
}
@@ -302,7 +308,7 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(false);
+ isByName = Boolean.FALSE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest
.serverMultiKeyExecution(isByName));
}
@@ -316,7 +322,7 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(true);
+ isByName = Boolean.TRUE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest
.serverMultiKeyExecutionOnASingleBucket(isByName));
}
@@ -330,7 +336,7 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
createScenario();
Function function = new TestFunction(true, TEST_FUNCTION2);
registerFunctionAtServer(function);
- isByName = new Boolean(false);
+ isByName = Boolean.FALSE;
client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest
.serverMultiKeyExecutionOnASingleBucket(isByName));
}
@@ -340,25 +346,25 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
* failover to other available server
*/
@Test
- public void testServerFailoverWithTwoServerAliveHA() throws InterruptedException {
+ public void testServerFailoverWithTwoServerAliveHA() {
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 1, 13, null);
+ createCommonServerAttributes("TestPartitionedRegion", null, 1, null);
createClientServerScenarion(commonAttributes, 20, 20, 20);
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_HA);
registerFunctionAtServer(function);
- server2.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.stopServerHA());
- server3.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.stopServerHA());
- client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.putOperation());
+ server2.invoke(PRClientServerRegionFunctionExecutionSingleHopDUnitTest::stopServerHA);
+ server3.invoke(PRClientServerRegionFunctionExecutionSingleHopDUnitTest::stopServerHA);
+ client.invoke(PRClientServerRegionFunctionExecutionSingleHopDUnitTest::putOperation);
int AsyncInvocationArrSize = 1;
AsyncInvocation[] async = new AsyncInvocation[AsyncInvocationArrSize];
async[0] = client.invokeAsync(
- () -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.executeFunctionHA());
- server2.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.startServerHA());
- server3.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.startServerHA());
- server1.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.stopServerHA());
+ PRClientServerRegionFunctionExecutionSingleHopDUnitTest::executeFunctionHA);
+ server2.invoke(PRClientServerRegionFunctionExecutionSingleHopDUnitTest::startServerHA);
+ server3.invoke(PRClientServerRegionFunctionExecutionSingleHopDUnitTest::startServerHA);
+ server1.invoke(PRClientServerRegionFunctionExecutionSingleHopDUnitTest::stopServerHA);
client.invoke(() -> PRClientServerRegionFunctionExecutionDUnitTest
- .verifyDeadAndLiveServers(new Integer(1), new Integer(2)));
+ .verifyDeadAndLiveServers(2));
ThreadUtils.join(async[0], 6 * 60 * 1000);
if (async[0].getException() != null) {
Assert.fail("UnExpected Exception Occurred : ", async[0].getException());
@@ -373,24 +379,24 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
* failover to other available server
*/
@Test
- public void testServerCacheClosedFailoverWithTwoServerAliveHA() throws InterruptedException {
+ public void testServerCacheClosedFailoverWithTwoServerAliveHA() {
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 1, 13, null);
+ createCommonServerAttributes("TestPartitionedRegion", null, 1, null);
createClientServerScenarion(commonAttributes, 20, 20, 20);
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_HA);
registerFunctionAtServer(function);
- server2.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.stopServerHA());
- server3.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.stopServerHA());
- client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.putOperation());
+ server2.invoke(PRClientServerRegionFunctionExecutionSingleHopDUnitTest::stopServerHA);
+ server3.invoke(PRClientServerRegionFunctionExecutionSingleHopDUnitTest::stopServerHA);
+ client.invoke(PRClientServerRegionFunctionExecutionSingleHopDUnitTest::putOperation);
int AsyncInvocationArrSize = 1;
AsyncInvocation[] async = new AsyncInvocation[AsyncInvocationArrSize];
async[0] = client.invokeAsync(
- () -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.executeFunctionHA());
- server2.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.startServerHA());
- server3.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.startServerHA());
- server1.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.closeCacheHA());
+ PRClientServerRegionFunctionExecutionSingleHopDUnitTest::executeFunctionHA);
+ server2.invoke(PRClientServerRegionFunctionExecutionSingleHopDUnitTest::startServerHA);
+ server3.invoke(PRClientServerRegionFunctionExecutionSingleHopDUnitTest::startServerHA);
+ server1.invoke(PRClientServerRegionFunctionExecutionSingleHopDUnitTest::closeCacheHA);
client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest
- .verifyDeadAndLiveServers(new Integer(1), new Integer(2)));
+ .verifyDeadAndLiveServers(2));
ThreadUtils.join(async[0], 5 * 60 * 1000);
if (async[0].getException() != null) {
Assert.fail("UnExpected Exception Occurred : ", async[0].getException());
@@ -403,24 +409,30 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
public void testBug40714() {
createScenario();
server1
- .invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.registerFunction());
+ .invoke(
+ (SerializableRunnableIF) PRClientServerRegionFunctionExecutionSingleHopDUnitTest::registerFunction);
server1
- .invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.registerFunction());
+ .invoke(
+ (SerializableRunnableIF) PRClientServerRegionFunctionExecutionSingleHopDUnitTest::registerFunction);
server1
- .invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.registerFunction());
- client.invoke(() -> PRClientServerRegionFunctionExecutionSingleHopDUnitTest.registerFunction());
+ .invoke(
+ (SerializableRunnableIF) PRClientServerRegionFunctionExecutionSingleHopDUnitTest::registerFunction);
+ client.invoke(
+ (SerializableRunnableIF) PRClientServerRegionFunctionExecutionSingleHopDUnitTest::registerFunction);
client.invoke(
- () -> PRClientServerRegionFunctionExecutionDUnitTest.FunctionExecution_Inline_Bug40714());
+ PRClientServerRegionFunctionExecutionDUnitTest::FunctionExecution_Inline_Bug40714);
}
public static void registerFunction() {
FunctionService.registerFunction(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
} else if (context.getArguments() instanceof Boolean) {
- context.getResultSender().lastResult(Boolean.FALSE);
+ resultSender.lastResult(Boolean.FALSE);
}
}
@@ -436,71 +448,19 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
});
}
- public static void FunctionExecution_Inline_Bug40714() {
- Region region = cache.getRegion(PartitionedRegionName);
- assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 10); i > 0; i--) {
- testKeysSet.add("execKey-" + i);
- }
- int j = 0;
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- region.put(i.next(), val);
- }
- HashMap resultMap = (HashMap) FunctionService.onRegion(region).setArguments(Boolean.TRUE)
- .execute(new FunctionAdapter() {
- @Override
- public void execute(FunctionContext context) {
- if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
- } else if (context.getArguments() instanceof Boolean) {
- context.getResultSender().lastResult(Boolean.TRUE);
- }
- }
-
- @Override
- public String getId() {
- return "Function";
- }
-
- @Override
- public boolean hasResult() {
- return true;
- }
- }).getResult();
-
- assertEquals(3, resultMap.size());
-
- Iterator mapIterator = resultMap.entrySet().iterator();
- Map.Entry entry = null;
- ArrayList resultListForMember = null;
-
- while (mapIterator.hasNext()) {
- entry = (Map.Entry) mapIterator.next();
- resultListForMember = (ArrayList) entry.getValue();
-
- for (Object result : resultListForMember) {
- assertEquals(Boolean.TRUE, result);
- }
- }
-
- }
-
- public static void verifyDeadAndLiveServers(final Integer expectedDeadServers,
- final Integer expectedLiveServers) {
+ public static void verifyDeadAndLiveServers(final Integer expectedLiveServers) {
WaitCriterion wc = new WaitCriterion() {
String excuse;
@Override
public boolean done() {
int sz = pool.getConnectedServerCount();
- LogWriterUtils.getLogWriter().info("Checking for the Live Servers : Expected : "
+ logger.info("Checking for the Live Servers : Expected : "
+ expectedLiveServers + " Available :" + sz);
- if (sz == expectedLiveServers.intValue()) {
+ if (sz == expectedLiveServers) {
return true;
}
- excuse = "Expected " + expectedLiveServers.intValue() + " but found " + sz;
+ excuse = "Expected " + expectedLiveServers + " but found " + sz;
return false;
}
@@ -512,12 +472,12 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
Wait.waitForCriterion(wc, 3 * 60 * 1000, 1000, true);
}
- public static void executeFunction() throws ServerException, InterruptedException {
+ public static void executeFunction() {
Region region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 10); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 10); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -532,8 +492,8 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
assertEquals(3, resultMap.size());
Iterator mapIterator = resultMap.entrySet().iterator();
- Map.Entry entry = null;
- ArrayList resultListForMember = null;
+ Map.Entry entry;
+ ArrayList resultListForMember;
while (mapIterator.hasNext()) {
entry = (Map.Entry) mapIterator.next();
@@ -544,17 +504,15 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
}
}
} catch (Exception e) {
- LogWriterUtils.getLogWriter().info("Got an exception : " + e.getMessage());
- assertTrue(e instanceof EOFException || e instanceof SocketException
- || e instanceof SocketTimeoutException || e instanceof ServerException
- || e instanceof IOException || e instanceof CacheClosedException);
+ logger.info("Got an exception : " + e.getMessage());
+ assertTrue(e instanceof CacheClosedException);
}
}
- public static Object executeFunctionHA() throws Exception {
- Region region = cache.getRegion(PartitionedRegionName);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 10); i > 0; i--) {
+ private static Object executeFunctionHA() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 10); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -564,52 +522,50 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
ResultCollector rc1 =
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(function.getId());
List l = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + l.size());
+ logger.info("Result size : " + l.size());
return l;
}
- public static void putOperation() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void putOperation() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 10); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 10); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String s : testKeysSet) {
+ Integer val = j++;
+ region.put(s, val);
}
}
private void createScenario() {
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 0, 13, null);
+ createCommonServerAttributes("TestPartitionedRegion", null, 0, null);
createClientServerScenarioSingleHop(commonAttributes, 20, 20, 20);
}
private void createScenarioForBucketFilter() {
ArrayList commonAttributes = createCommonServerAttributes("TestPartitionedRegion",
- new BucketFilterPRResolver(), 0, 113, null);
+ new BucketFilterPRResolver(), 0, null);
createClientServerScenarioSingleHop(commonAttributes, 20, 20, 20);
}
- public static void checkBucketsOnServer() {
+ private static void checkBucketsOnServer() {
PartitionedRegion region = (PartitionedRegion) cache.getRegion(PartitionedRegionName);
HashMap localBucket2RegionMap = (HashMap) region.getDataStore().getSizeLocally();
- LogWriterUtils.getLogWriter().info(
+ logger.info(
"Size of the " + PartitionedRegionName + " in this VM :- " + localBucket2RegionMap.size());
Set entrySet = localBucket2RegionMap.entrySet();
assertNotNull(entrySet);
}
- public static void serverAllKeyExecution(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverAllKeyExecution(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() / 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets / 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -618,16 +574,16 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
Execution dataSet = FunctionService.onRegion(region);
try {
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
+ HashSet<Integer> origVals = new HashSet<>();
+ for (String s : testKeysSet) {
+ Integer val = j++;
origVals.add(val);
- region.put(i.next(), val);
+ region.put(s, val);
}
ResultCollector rc1 = executeOnAll(dataSet, Boolean.TRUE, function, isByName);
List resultList = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + resultList.size());
- LogWriterUtils.getLogWriter().info("Result are SSSS : " + resultList);
+ logger.info("Result size : " + resultList.size());
+ logger.info("Result are SSSS : " + resultList);
assertEquals(3, resultList.size());
// while (resultIterator.hasNext()) {
@@ -640,16 +596,16 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
for (Object result : resultList) {
assertEquals(Boolean.TRUE, result);
}
- List l2 = null;
+ List l2;
ResultCollector rc2 = executeOnAll(dataSet, testKeysSet, function, isByName);
l2 = ((List) rc2.getResult());
assertEquals(3, l2.size());
- HashSet foundVals = new HashSet();
- for (Iterator i = l2.iterator(); i.hasNext();) {
- ArrayList subL = (ArrayList) (i.next());
+ HashSet<Object> foundVals = new HashSet<>();
+ for (Object o : l2) {
+ ArrayList subL = (ArrayList) (o);
assertTrue(subL.size() > 0);
- for (Iterator subI = subL.iterator(); subI.hasNext();) {
- assertTrue(foundVals.add(subI.next()));
+ for (Object value : subL) {
+ assertTrue(foundVals.add(value));
}
}
assertEquals(origVals, foundVals);
@@ -662,27 +618,26 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
public static void getAll() {
- Region region = cache.getRegion(PartitionedRegionName);
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final List testKeysList = new ArrayList();
- for (int i = (totalNumBuckets.intValue() * 3); i > 0; i--) {
+ final List<String> testKeysList = new ArrayList<>();
+ for (int i = (totalNumBuckets * 3); i > 0; i--) {
testKeysList.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
try {
int j = 0;
- Map origVals = new HashMap();
- for (Iterator i = testKeysList.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- Object key = i.next();
+ Map<String, Integer> origVals = new HashMap<>();
+ for (String key : testKeysList) {
+ Integer val = j++;
origVals.put(key, val);
region.put(key, val);
}
Map resultMap = region.getAll(testKeysList);
- assertTrue(resultMap.equals(origVals));
+ assertEquals(resultMap, origVals);
Wait.pause(2000);
Map secondResultMap = region.getAll(testKeysList);
- assertTrue(secondResultMap.equals(origVals));
+ assertEquals(secondResultMap, origVals);
} catch (Exception e) {
Assert.fail("Test failed after the put operation", e);
@@ -691,27 +646,26 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
}
public static void putAll() {
- Region region = cache.getRegion(PartitionedRegionName);
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final List testKeysList = new ArrayList();
- for (int i = (totalNumBuckets.intValue() * 3); i > 0; i--) {
+ final List<String> testKeysList = new ArrayList<>();
+ for (int i = (totalNumBuckets * 3); i > 0; i--) {
testKeysList.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
try {
int j = 0;
- Map origVals = new HashMap();
- for (Iterator i = testKeysList.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- Object key = i.next();
+ Map<String, Integer> origVals = new HashMap<>();
+ for (String key : testKeysList) {
+ Integer val = j++;
origVals.put(key, val);
region.put(key, val);
}
Map resultMap = region.getAll(testKeysList);
- assertTrue(resultMap.equals(origVals));
+ assertEquals(resultMap, origVals);
Wait.pause(2000);
Map secondResultMap = region.getAll(testKeysList);
- assertTrue(secondResultMap.equals(origVals));
+ assertEquals(secondResultMap, origVals);
} catch (Exception e) {
Assert.fail("Test failed after the put operation", e);
@@ -721,52 +675,50 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
- public static void serverMultiKeyExecutionOnASingleBucket(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecutionOnASingleBucket(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
int j = 0;
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- region.put(i.next(), val);
+ for (String s : testKeysSet) {
+ Integer val = j++;
+ region.put(s, val);
}
DistributedSystem.setThreadsSocketPolicy(false);
- for (Iterator kiter = testKeysSet.iterator(); kiter.hasNext();) {
+ for (String s : testKeysSet) {
try {
- Set singleKeySet = Collections.singleton(kiter.next());
+ Set<String> singleKeySet = Collections.singleton(s);
Function function = new TestFunction(true, TEST_FUNCTION2);
FunctionService.registerFunction(function);
Execution dataSet = FunctionService.onRegion(region);
ResultCollector rc1 = execute(dataSet, singleKeySet, Boolean.TRUE, function, isByName);
- List l = null;
- l = ((List) rc1.getResult());
+ List l = ((List) rc1.getResult());
assertEquals(1, l.size());
ResultCollector rc2 =
- execute(dataSet, singleKeySet, new HashSet(singleKeySet), function, isByName);
- List l2 = null;
- l2 = ((List) rc2.getResult());
+ execute(dataSet, singleKeySet, new HashSet<>(singleKeySet), function, isByName);
+ List l2 = ((List) rc2.getResult());
assertEquals(1, l2.size());
List subList = (List) l2.iterator().next();
assertEquals(1, subList.size());
assertEquals(region.get(singleKeySet.iterator().next()), subList.iterator().next());
} catch (Exception expected) {
- LogWriterUtils.getLogWriter().info("Exception : " + expected.getMessage());
+ logger.info("Exception : " + expected.getMessage());
expected.printStackTrace();
fail("Test failed after the put operation");
}
}
}
- public static void serverMultiKeyExecution(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecution(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -775,31 +727,29 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
Execution dataSet = FunctionService.onRegion(region);
try {
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
+ HashSet<Integer> origVals = new HashSet<>();
+ for (String s : testKeysSet) {
+ Integer val = j++;
origVals.add(val);
- region.put(i.next(), val);
+ region.put(s, val);
}
- List l = null;
ResultCollector rc1 = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
- l = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + l.size());
+ List l = ((List) rc1.getResult());
+ logger.info("Result size : " + l.size());
assertEquals(3, l.size());
- for (Iterator i = l.iterator(); i.hasNext();) {
- assertEquals(Boolean.TRUE, i.next());
+ for (Object item : l) {
+ assertEquals(Boolean.TRUE, item);
}
- List l2 = null;
ResultCollector rc2 = execute(dataSet, testKeysSet, testKeysSet, function, isByName);
- l2 = ((List) rc2.getResult());
+ List l2 = ((List) rc2.getResult());
assertEquals(3, l2.size());
- HashSet foundVals = new HashSet();
- for (Iterator i = l2.iterator(); i.hasNext();) {
- ArrayList subL = (ArrayList) i.next();
+ HashSet<Object> foundVals = new HashSet<>();
+ for (Object o : l2) {
+ ArrayList subL = (ArrayList) o;
assertTrue(subL.size() > 0);
- for (Iterator subI = subL.iterator(); subI.hasNext();) {
- assertTrue(foundVals.add(subI.next()));
+ for (Object value : subL) {
+ assertTrue(foundVals.add(value));
}
}
assertEquals(origVals, foundVals);
@@ -810,11 +760,11 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
}
}
- public static void serverMultiKeyExecutionSocketTimeOut(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecutionSocketTimeOut(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -823,32 +773,28 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
Execution dataSet = FunctionService.onRegion(region);
try {
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String value : testKeysSet) {
+ Integer val = j++;
+ region.put(value, val);
}
- List l = null;
ResultCollector rc1 = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
- l = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + l.size());
+ List l = ((List) rc1.getResult());
+ logger.info("Result size : " + l.size());
assertEquals(3, l.size());
- for (Iterator i = l.iterator(); i.hasNext();) {
- assertEquals(Boolean.TRUE, i.next());
+ for (Object o : l) {
+ assertEquals(Boolean.TRUE, o);
}
} catch (Exception e) {
Assert.fail("Test failed after the function execution", e);
-
}
}
- public static void serverSingleKeyExecutionSocketTimeOut(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecutionSocketTimeOut(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
@@ -856,7 +802,7 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
FunctionService.registerFunction(function);
Execution dataSet = FunctionService.onRegion(region);
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
try {
ResultCollector rs = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
assertEquals(Boolean.TRUE, ((List) rs.getResult()).get(0));
@@ -866,37 +812,36 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
Assert.fail("Test failed after the put operation", ex);
}
}
- public static void serverMultiKeyExecution_Inline() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecution_Inline() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
Execution dataSet = FunctionService.onRegion(region);
try {
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String value : testKeysSet) {
+ Integer val = j++;
+ region.put(value, val);
}
- List l = null;
ResultCollector rc1 =
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
} else if (context.getArguments() instanceof Boolean) {
- context.getResultSender().lastResult(Boolean.TRUE);
+ resultSender.lastResult(Boolean.TRUE);
}
}
@@ -910,44 +855,41 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
return true;
}
});
- l = ((List) rc1.getResult());
- LogWriterUtils.getLogWriter().info("Result size : " + l.size());
+ List l = ((List) rc1.getResult());
+ logger.info("Result size : " + l.size());
assertEquals(3, l.size());
- for (Iterator i = l.iterator(); i.hasNext();) {
- assertEquals(Boolean.TRUE, i.next());
+ for (Object o : l) {
+ assertEquals(Boolean.TRUE, o);
}
} catch (Exception e) {
- LogWriterUtils.getLogWriter().info("Exception : " + e.getMessage());
+ logger.info("Exception : " + e.getMessage());
e.printStackTrace();
fail("Test failed after the put operation");
}
}
- public static void serverMultiKeyExecution_FunctionInvocationTargetException() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecution_FunctionInvocationTargetException() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
Execution dataSet = FunctionService.onRegion(region);
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String o : testKeysSet) {
+ Integer val = j++;
+ region.put(o, val);
}
- ResultCollector rc1 = null;
try {
- rc1 =
+ ResultCollector rc1 =
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
- if (((RegionFunctionContext) context).isPossibleDuplicate()) {
- context.getResultSender().lastResult(new Integer(retryCount));
+ if (context.isPossibleDuplicate()) {
+ context.getResultSender().lastResult(retryCount);
return;
}
if (context.getArguments() instanceof Boolean) {
@@ -975,11 +917,11 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
}
- public static void serverMultiKeyExecutionNoResult(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverMultiKeyExecutionNoResult(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
- for (int i = (totalNumBuckets.intValue() * 2); i > 0; i--) {
+ final HashSet<String> testKeysSet = new HashSet<>();
+ for (int i = (totalNumBuckets * 2); i > 0; i--) {
testKeysSet.add("execKey-" + i);
}
DistributedSystem.setThreadsSocketPolicy(false);
@@ -990,11 +932,9 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
String msg = "<ExpectedException action=add>" + "FunctionException" + "</ExpectedException>";
cache.getLogger().info(msg);
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (String o : testKeysSet) {
+ Integer val = j++;
+ region.put(o, val);
}
ResultCollector rc1 = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
rc1.getResult();
@@ -1002,7 +942,7 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
fail("Test failed after the put operation");
} catch (FunctionException expected) {
expected.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : " + expected.getMessage());
+ logger.info("Exception : " + expected.getMessage());
assertTrue(expected.getMessage()
.startsWith((String.format("Cannot %s result as the Function#hasResult() is false",
"return any"))));
@@ -1014,11 +954,11 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
}
}
- public static void serverSingleKeyExecution(Boolean isByName) {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecution(Boolean isByName) {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
@@ -1033,36 +973,36 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
|| expected.getMessage().startsWith("Unexpected exception during"));
}
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
try {
ResultCollector rs = execute(dataSet, testKeysSet, Boolean.TRUE, function, isByName);
assertEquals(Boolean.TRUE, ((List) rs.getResult()).get(0));
ResultCollector rs2 = execute(dataSet, testKeysSet, testKey, function, isByName);
- assertEquals(new Integer(1), ((List) rs2.getResult()).get(0));
+ assertEquals(1, ((List) rs2.getResult()).get(0));
- HashMap putData = new HashMap();
- putData.put(testKey + "1", new Integer(2));
- putData.put(testKey + "2", new Integer(3));
+ HashMap<String, Integer> putData = new HashMap<>();
+ putData.put(testKey + "1", 2);
+ putData.put(testKey + "2", 3);
ResultCollector rs1 = execute(dataSet, testKeysSet, putData, function, isByName);
assertEquals(Boolean.TRUE, ((List) rs1.getResult()).get(0));
- assertEquals(new Integer(2), region.get(testKey + "1"));
- assertEquals(new Integer(3), region.get(testKey + "2"));
+ assertEquals((Integer) 2, region.get(testKey + "1"));
+ assertEquals((Integer) 3, region.get(testKey + "2"));
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
Assert.fail("Test failed after the put operation", ex);
}
}
- public static void serverSingleKeyExecution_FunctionInvocationTargetException() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecution_FunctionInvocationTargetException() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
@@ -1070,7 +1010,7 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
FunctionService.registerFunction(function);
Execution dataSet = FunctionService.onRegion(region);
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
try {
ResultCollector rs = execute(dataSet, testKeysSet, Boolean.TRUE, function, false);
ArrayList list = (ArrayList) rs.getResult();
@@ -1081,11 +1021,11 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
}
}
- public static void serverSingleKeyExecution_Inline() {
- Region region = cache.getRegion(PartitionedRegionName);
+ private static void serverSingleKeyExecution_Inline() {
+ Region<String, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
final String testKey = "execKey";
- final Set testKeysSet = new HashSet();
+ final Set<String> testKeysSet = new HashSet<>();
testKeysSet.add(testKey);
DistributedSystem.setThreadsSocketPolicy(false);
@@ -1098,10 +1038,12 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
}
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
}
@Override
@@ -1115,7 +1057,7 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
}
});
} catch (Exception expected) {
- LogWriterUtils.getLogWriter().fine("Exception occurred : " + expected.getMessage());
+ logger.debug("Exception occurred : " + expected.getMessage());
assertTrue(expected.getMessage().contains("No target node found for KEY = " + testKey)
|| expected.getMessage().startsWith("Server could not send the reply")
|| expected.getMessage().startsWith("Unexpected exception during"));
@@ -1126,16 +1068,18 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
+ "</ExpectedException>");
}
- region.put(testKey, new Integer(1));
+ region.put(testKey, 1);
try {
ResultCollector rs =
dataSet.withFilter(testKeysSet).setArguments(Boolean.TRUE).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
} else {
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
}
}
@@ -1155,10 +1099,12 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
dataSet.withFilter(testKeysSet).setArguments(testKey).execute(new FunctionAdapter() {
@Override
public void execute(FunctionContext context) {
+ @SuppressWarnings("unchecked")
+ final ResultSender<Object> resultSender = context.getResultSender();
if (context.getArguments() instanceof String) {
- context.getResultSender().lastResult("Success");
+ resultSender.lastResult("Success");
} else {
- context.getResultSender().lastResult("Failure");
+ resultSender.lastResult("Failure");
}
}
@@ -1176,14 +1122,14 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
} catch (Exception ex) {
ex.printStackTrace();
- LogWriterUtils.getLogWriter().info("Exception : ", ex);
+ logger.info("Exception : ", ex);
Assert.fail("Test failed after the put operation", ex);
}
}
private static ResultCollector execute(Execution dataSet, Set testKeysSet, Serializable args,
- Function function, Boolean isByName) throws Exception {
- if (isByName.booleanValue()) {// by name
+ Function function, Boolean isByName) {
+ if (isByName) {// by name
return dataSet.withFilter(testKeysSet).setArguments(args).execute(function.getId());
} else { // By Instance
return dataSet.withFilter(testKeysSet).setArguments(args).execute(function);
@@ -1191,8 +1137,8 @@ public class PRClientServerRegionFunctionExecutionSingleHopDUnitTest
}
private static ResultCollector executeOnAll(Execution dataSet, Serializable args,
- Function function, Boolean isByName) throws Exception {
- if (isByName.booleanValue()) {// by name
+ Function function, Boolean isByName) {
+ if (isByName) {// by name
return dataSet.setArguments(args).execute(function.getId());
} else { // By Instance
return dataSet.setArguments(args).execute(function);
diff --git a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerTestBase.java b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerTestBase.java
index bbc1d9b..9ba4a12 100755
--- a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerTestBase.java
+++ b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/PRClientServerTestBase.java
@@ -30,6 +30,9 @@ import java.util.List;
import java.util.Properties;
import java.util.Set;
+import org.apache.logging.log4j.Logger;
+import org.junit.runners.Parameterized;
+
import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.Cache;
import org.apache.geode.cache.CacheFactory;
@@ -53,16 +56,18 @@ import org.apache.geode.distributed.DistributedSystem;
import org.apache.geode.internal.AvailablePort;
import org.apache.geode.internal.cache.functions.TestFunction;
import org.apache.geode.internal.cache.tier.sockets.CacheServerTestUtil;
+import org.apache.geode.internal.logging.LogService;
import org.apache.geode.test.dunit.Assert;
import org.apache.geode.test.dunit.Host;
-import org.apache.geode.test.dunit.LogWriterUtils;
import org.apache.geode.test.dunit.NetworkUtils;
+import org.apache.geode.test.dunit.SerializableCallableIF;
import org.apache.geode.test.dunit.SerializableRunnable;
import org.apache.geode.test.dunit.VM;
import org.apache.geode.test.dunit.Wait;
import org.apache.geode.test.dunit.cache.internal.JUnit4CacheTestCase;
public class PRClientServerTestBase extends JUnit4CacheTestCase {
+ private static final Logger logger = LogService.getLogger();
protected VM server1 = null;
@@ -74,40 +79,14 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
protected static Cache cache = null;
- protected static String PartitionedRegionName = "TestPartitionedRegion"; // default name
+ static String PartitionedRegionName = "TestPartitionedRegion"; // default name
protected static String regionName = "TestRegion"; // default name
- private static Region metaDataRegion;
-
- static PartitionResolver partitionResolver = null; // default
-
- static Integer redundancy = new Integer(0); // default
-
- // static Integer localMaxmemory = new Integer(20); //default
-
- static Integer totalNumBuckets = new Integer(13);// default
-
- static String colocatedWith = null;// default
-
- protected static Integer serverPort1 = null;
-
- protected static Integer serverPort2 = null;
-
- protected static Integer serverPort3 = null;
+ static Integer totalNumBuckets = 13; // default
protected static PoolImpl pool = null;
- private boolean isSingleHop = false;
-
- private boolean isSelector = false;
-
- public PRClientServerTestBase(String name, boolean isSingleHop, boolean isSelector) {
- super();
- this.isSingleHop = isSingleHop;
- this.isSelector = isSelector;
- }
-
public PRClientServerTestBase() {
super();
}
@@ -124,13 +103,29 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
protected void postSetUpPRClientServerTestBase() throws Exception {}
- public ArrayList createCommonServerAttributes(String regionName, PartitionResolver pr, int red,
- int numBuckets, String colocatedWithRegion) {
- ArrayList commonAttributes = new ArrayList();
+ private enum ExecuteFunctionMethod {
+ ExecuteFunctionByObject, ExecuteFunctionById
+ }
+
+ @Parameterized.Parameters(name = "{0}")
+ public static ExecuteFunctionMethod[] data() {
+ return ExecuteFunctionMethod.values();
+ }
+
+ @Parameterized.Parameter
+ public ExecuteFunctionMethod functionExecutionType;
+
+ protected boolean shouldRegisterFunctionsOnClient() {
+ return ExecuteFunctionMethod.ExecuteFunctionByObject == functionExecutionType;
+ }
+
+ ArrayList createCommonServerAttributes(String regionName, PartitionResolver pr, int red,
+ String colocatedWithRegion) {
+ ArrayList<Object> commonAttributes = new ArrayList<>();
commonAttributes.add(regionName); // 0
commonAttributes.add(pr); // 1
- commonAttributes.add(new Integer(red)); // 2
- commonAttributes.add(new Integer(totalNumBuckets)); // 3
+ commonAttributes.add(red); // 2
+ commonAttributes.add(totalNumBuckets); // 3
commonAttributes.add(colocatedWithRegion); // 4
return commonAttributes;
}
@@ -140,10 +135,10 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
PartitionAttributesFactory paf = new PartitionAttributesFactory();
paf.setPartitionResolver((PartitionResolver) commonAttributes.get(1));
- paf.setRedundantCopies(((Integer) commonAttributes.get(2)).intValue());
- paf.setTotalNumBuckets(((Integer) commonAttributes.get(3)).intValue());
+ paf.setRedundantCopies((Integer) commonAttributes.get(2));
+ paf.setTotalNumBuckets((Integer) commonAttributes.get(3));
paf.setColocatedWith((String) commonAttributes.get(4));
- paf.setLocalMaxMemory(localMaxMemory.intValue());
+ paf.setLocalMaxMemory(localMaxMemory);
PartitionAttributes partitionAttributes = paf.create();
factory.setDataPolicy(DataPolicy.PARTITION);
factory.setPartitionAttributes(partitionAttributes);
@@ -162,19 +157,19 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
}
assertTrue(server1.isRunning());
- return new Integer(server1.getPort());
+ return server1.getPort();
}
- public static Integer createSelectorCacheServer(ArrayList commonAttributes,
+ private static Integer createSelectorCacheServer(ArrayList commonAttributes,
Integer localMaxMemory) throws Exception {
AttributesFactory factory = new AttributesFactory();
PartitionAttributesFactory paf = new PartitionAttributesFactory();
paf.setPartitionResolver((PartitionResolver) commonAttributes.get(1));
- paf.setRedundantCopies(((Integer) commonAttributes.get(2)).intValue());
- paf.setTotalNumBuckets(((Integer) commonAttributes.get(3)).intValue());
+ paf.setRedundantCopies((Integer) commonAttributes.get(2));
+ paf.setTotalNumBuckets((Integer) commonAttributes.get(3));
paf.setColocatedWith((String) commonAttributes.get(4));
- paf.setLocalMaxMemory(localMaxMemory.intValue());
+ paf.setLocalMaxMemory(localMaxMemory);
PartitionAttributes partitionAttributes = paf.create();
factory.setDataPolicy(DataPolicy.PARTITION);
factory.setPartitionAttributes(partitionAttributes);
@@ -190,19 +185,19 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
server1.start();
assertTrue(server1.isRunning());
- return new Integer(server1.getPort());
+ return server1.getPort();
}
- public static Integer createCacheServerWith2Regions(ArrayList commonAttributes,
+ private static Integer createCacheServerWith2Regions(ArrayList commonAttributes,
Integer localMaxMemory) throws Exception {
AttributesFactory factory = new AttributesFactory();
PartitionAttributesFactory paf = new PartitionAttributesFactory();
paf.setPartitionResolver((PartitionResolver) commonAttributes.get(1));
- paf.setRedundantCopies(((Integer) commonAttributes.get(2)).intValue());
- paf.setTotalNumBuckets(((Integer) commonAttributes.get(3)).intValue());
+ paf.setRedundantCopies((Integer) commonAttributes.get(2));
+ paf.setTotalNumBuckets((Integer) commonAttributes.get(3));
paf.setColocatedWith((String) commonAttributes.get(4));
- paf.setLocalMaxMemory(localMaxMemory.intValue());
+ paf.setLocalMaxMemory(localMaxMemory);
PartitionAttributes partitionAttributes = paf.create();
factory.setDataPolicy(DataPolicy.PARTITION);
factory.setPartitionAttributes(partitionAttributes);
@@ -219,7 +214,7 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
server1.start();
assertTrue(server1.isRunning());
- return new Integer(server1.getPort());
+ return server1.getPort();
}
public static Integer createCacheServer() throws Exception {
@@ -230,10 +225,10 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
server1.start();
assertTrue(server1.isRunning());
- return new Integer(server1.getPort());
+ return server1.getPort();
}
- public static Integer createCacheServerWithDR() throws Exception {
+ private static Integer createCacheServerWithDR() throws Exception {
AttributesFactory factory = new AttributesFactory();
factory.setScope(Scope.DISTRIBUTED_ACK);
factory.setDataPolicy(DataPolicy.REPLICATE);
@@ -248,20 +243,16 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
server1.start();
assertTrue(server1.isRunning());
- return new Integer(server1.getPort());
+ return server1.getPort();
}
- public static void createCacheClient(String host, Integer port1, Integer port2, Integer port3)
- throws Exception {
+ public static void createCacheClient(String host, Integer port1, Integer port2, Integer port3) {
CacheServerTestUtil.disableShufflingOfEndpoints();
Pool p;
- serverPort1 = port1;
- serverPort2 = port2;
- serverPort3 = port3;
try {
- p = PoolManager.createFactory().addServer(host, port1.intValue())
- .addServer(host, port2.intValue()).addServer(host, port3.intValue()).setPingInterval(2000)
+ p = PoolManager.createFactory().addServer(host, port1)
+ .addServer(host, port2).addServer(host, port3).setPingInterval(2000)
.setSubscriptionEnabled(true).setSubscriptionRedundancy(-1).setReadTimeout(2000)
.setSocketBufferSize(1000).setMinConnections(6).setMaxConnections(10).setRetryAttempts(2)
.setPRSingleHopEnabled(false).create("PRClientServerTestBase");
@@ -278,14 +269,12 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
assertNotNull(region);
}
- public static void createCacheClient_SingleConnection(String host, Integer port1)
- throws Exception {
+ private static void createCacheClient_SingleConnection(String host, Integer port1) {
CacheServerTestUtil.disableShufflingOfEndpoints();
Pool p;
- serverPort1 = port1;
try {
- p = PoolManager.createFactory().addServer(host, port1.intValue()).setPingInterval(2000)
+ p = PoolManager.createFactory().addServer(host, port1).setPingInterval(2000)
.setSubscriptionEnabled(true).setSubscriptionRedundancy(-1).setReadTimeout(2000)
.setSocketBufferSize(1000).setMinConnections(0).setMaxConnections(1).setRetryAttempts(0)
.setPRSingleHopEnabled(false).create("PRClientServerTestBase");
@@ -302,17 +291,14 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
assertNotNull(region);
}
- public static void createCacheClientWith2Regions(String host, Integer port1, Integer port2,
- Integer port3) throws Exception {
+ private static void createCacheClientWith2Regions(String host, Integer port1, Integer port2,
+ Integer port3) {
CacheServerTestUtil.disableShufflingOfEndpoints();
Pool p;
- serverPort1 = port1;
- serverPort2 = port2;
- serverPort3 = port3;
try {
- p = PoolManager.createFactory().addServer(host, port1.intValue())
- .addServer(host, port2.intValue()).addServer(host, port3.intValue()).setPingInterval(2000)
+ p = PoolManager.createFactory().addServer(host, port1)
+ .addServer(host, port2).addServer(host, port3).setPingInterval(2000)
.setSubscriptionEnabled(true).setSubscriptionRedundancy(-1).setReadTimeout(2000)
.setSocketBufferSize(1000).setMinConnections(6).setMaxConnections(10).setRetryAttempts(2)
.create("PRClientServerTestBase");
@@ -334,17 +320,14 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
assertNotNull(region2);
}
- public static void createSingleHopCacheClient(String host, Integer port1, Integer port2,
- Integer port3) throws Exception {
+ private static void createSingleHopCacheClient(String host, Integer port1, Integer port2,
+ Integer port3) {
CacheServerTestUtil.disableShufflingOfEndpoints();
- serverPort1 = port1;
- serverPort2 = port2;
- serverPort3 = port3;
Pool p;
try {
- p = PoolManager.createFactory().addServer(host, port1.intValue())
- .addServer(host, port2.intValue()).addServer(host, port3.intValue()).setPingInterval(2000)
+ p = PoolManager.createFactory().addServer(host, port1)
+ .addServer(host, port2).addServer(host, port3).setPingInterval(2000)
.setSubscriptionEnabled(true).setSubscriptionRedundancy(-1).setReadTimeout(2000)
.setSocketBufferSize(1000).setMinConnections(6).setMaxConnections(10).setRetryAttempts(2)
.setPRSingleHopEnabled(true).create("PRClientServerTestBase");
@@ -361,17 +344,14 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
assertNotNull(region);
}
- public static void createNoSingleHopCacheClient(String host, Integer port1, Integer port2,
- Integer port3) throws Exception {
+ private static void createNoSingleHopCacheClient(String host, Integer port1, Integer port2,
+ Integer port3) {
CacheServerTestUtil.disableShufflingOfEndpoints();
- serverPort1 = port1;
- serverPort2 = port2;
- serverPort3 = port3;
Pool p;
try {
- p = PoolManager.createFactory().addServer(host, port1.intValue())
- .addServer(host, port2.intValue()).addServer(host, port3.intValue()).setPingInterval(2000)
+ p = PoolManager.createFactory().addServer(host, port1)
+ .addServer(host, port2).addServer(host, port3).setPingInterval(2000)
.setSubscriptionEnabled(true).setSubscriptionRedundancy(-1).setReadTimeout(2000)
.setSocketBufferSize(1000).setMinConnections(6).setMaxConnections(10).setRetryAttempts(2)
.setPRSingleHopEnabled(false).create("PRClientServerTestBase");
@@ -388,19 +368,16 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
assertNotNull(region);
}
- public static void createCacheClientWithoutRegion(String host, Integer port1, Integer port2,
- Integer port3) throws Exception {
+ private static void createCacheClientWithoutRegion(String host, Integer port1, Integer port2,
+ Integer port3) {
CacheServerTestUtil.disableShufflingOfEndpoints();
- LogWriterUtils.getLogWriter()
+ logger
.info("PRClientServerTestBase#createCacheClientWithoutRegion : creating pool");
- serverPort1 = port1;
- serverPort2 = port2;
- serverPort3 = port3;
Pool p;
try {
- p = PoolManager.createFactory().addServer(host, port1.intValue())
- .addServer(host, port2.intValue()).addServer(host, port3.intValue()).setPingInterval(250)
+ p = PoolManager.createFactory().addServer(host, port1)
+ .addServer(host, port2).addServer(host, port3).setPingInterval(250)
.setSubscriptionEnabled(true).setSubscriptionRedundancy(-1).setReadTimeout(2000)
.setSocketBufferSize(1000).setMinConnections(6).setMaxConnections(10).setRetryAttempts(1)
.create("PRClientServerTestBaseWithoutRegion");
@@ -410,19 +387,16 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
pool = (PoolImpl) p;
}
- public static void createCacheClientWithDistributedRegion(String host, Integer port1,
+ private static void createCacheClientWithDistributedRegion(String host, Integer port1,
Integer port2, Integer port3) throws Exception {
CacheServerTestUtil.disableShufflingOfEndpoints();
- LogWriterUtils.getLogWriter()
+ logger
.info("PRClientServerTestBase#createCacheClientWithoutRegion : creating pool");
- serverPort1 = port1;
- serverPort2 = port2;
- serverPort3 = port3;
Pool p;
try {
- p = PoolManager.createFactory().addServer(host, port1.intValue())
- .addServer(host, port2.intValue()).addServer(host, port3.intValue()).setPingInterval(250)
+ p = PoolManager.createFactory().addServer(host, port1)
+ .addServer(host, port2).addServer(host, port3).setPingInterval(250)
.setSubscriptionEnabled(true).setSubscriptionRedundancy(-1).setReadTimeout(2000)
.setSocketBufferSize(1000).setMinConnections(6).setMaxConnections(10).setRetryAttempts(0)
.create("PRClientServerTestBaseWithoutRegion");
@@ -438,68 +412,61 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
assertNotNull(region);
}
- protected void createClientServerScenarion(ArrayList commonAttributes, int localMaxMemoryServer1,
+ void createClientServerScenarion(ArrayList commonAttributes, int localMaxMemoryServer1,
int localMaxMemoryServer2, int localMaxMemoryServer3) {
createCacheInClientServer();
- Integer port1 = (Integer) server1.invoke(() -> PRClientServerTestBase
- .createCacheServer(commonAttributes, new Integer(localMaxMemoryServer1)));
- Integer port2 = (Integer) server2.invoke(() -> PRClientServerTestBase
- .createCacheServer(commonAttributes, new Integer(localMaxMemoryServer2)));
- Integer port3 = (Integer) server3.invoke(() -> PRClientServerTestBase
- .createCacheServer(commonAttributes, new Integer(localMaxMemoryServer3)));
- serverPort1 = port1;
- serverPort2 = port2;
- serverPort3 = port3;
+ Integer port1 = server1.invoke(() -> PRClientServerTestBase
+ .createCacheServer(commonAttributes, localMaxMemoryServer1));
+ Integer port2 = server2.invoke(() -> PRClientServerTestBase
+ .createCacheServer(commonAttributes, localMaxMemoryServer2));
+ Integer port3 = server3.invoke(() -> PRClientServerTestBase
+ .createCacheServer(commonAttributes, localMaxMemoryServer3));
client.invoke(() -> PRClientServerTestBase
.createCacheClient(NetworkUtils.getServerHostName(server1.getHost()), port1, port2, port3));
}
- protected void createClientServerScenarion_SingleConnection(ArrayList commonAttributes,
- int localMaxMemoryServer1, int localMaxMemoryServer2, int localMaxMemoryServer3) {
+ void createClientServerScenarion_SingleConnection(ArrayList commonAttributes,
+ int localMaxMemoryServer1,
+ int localMaxMemoryServer2) {
createCacheInClientServer();
- Integer port1 = (Integer) server1.invoke(() -> PRClientServerTestBase
- .createCacheServer(commonAttributes, new Integer(localMaxMemoryServer1)));
+ Integer port1 = server1.invoke(() -> PRClientServerTestBase
+ .createCacheServer(commonAttributes, localMaxMemoryServer1));
server2.invoke(() -> PRClientServerTestBase.createCacheServer(commonAttributes,
- new Integer(localMaxMemoryServer2)));
- serverPort1 = port1;
+ localMaxMemoryServer2));
client.invoke(() -> PRClientServerTestBase.createCacheClient_SingleConnection(
NetworkUtils.getServerHostName(server1.getHost()), port1));
}
- protected void createClientServerScenarionWith2Regions(ArrayList commonAttributes,
- int localMaxMemoryServer1, int localMaxMemoryServer2, int localMaxMemoryServer3) {
+ void createClientServerScenarionWith2Regions(ArrayList commonAttributes,
+ int localMaxMemoryServer1, int localMaxMemoryServer2,
+ int localMaxMemoryServer3) {
createCacheInClientServer();
- Integer port1 = (Integer) server1.invoke(() -> PRClientServerTestBase
- .createCacheServerWith2Regions(commonAttributes, new Integer(localMaxMemoryServer1)));
- Integer port2 = (Integer) server2.invoke(() -> PRClientServerTestBase
- .createCacheServerWith2Regions(commonAttributes, new Integer(localMaxMemoryServer2)));
- Integer port3 = (Integer) server3.invoke(() -> PRClientServerTestBase
- .createCacheServerWith2Regions(commonAttributes, new Integer(localMaxMemoryServer3)));
- serverPort1 = port1;
- serverPort2 = port2;
- serverPort3 = port3;
+ Integer port1 = server1.invoke(() -> PRClientServerTestBase
+ .createCacheServerWith2Regions(commonAttributes, localMaxMemoryServer1));
+ Integer port2 = server2.invoke(() -> PRClientServerTestBase
+ .createCacheServerWith2Regions(commonAttributes, localMaxMemoryServer2));
+ Integer port3 = server3.invoke(() -> PRClientServerTestBase
+ .createCacheServerWith2Regions(commonAttributes, localMaxMemoryServer3));
client.invoke(() -> PRClientServerTestBase.createCacheClientWith2Regions(
NetworkUtils.getServerHostName(server1.getHost()), port1, port2, port3));
}
- protected void createClientServerScenarioSingleHop(ArrayList commonAttributes,
- int localMaxMemoryServer1, int localMaxMemoryServer2, int localMaxMemoryServer3) {
+ void createClientServerScenarioSingleHop(ArrayList commonAttributes,
+ int localMaxMemoryServer1, int localMaxMemoryServer2,
+ int localMaxMemoryServer3) {
createCacheInClientServer();
- Integer port1 = (Integer) server1.invoke(() -> PRClientServerTestBase
- .createCacheServer(commonAttributes, new Integer(localMaxMemoryServer1)));
- Integer port2 = (Integer) server2.invoke(() -> PRClientServerTestBase
- .createCacheServer(commonAttributes, new Integer(localMaxMemoryServer2)));
- Integer port3 = (Integer) server3.invoke(() -> PRClientServerTestBase
- .createCacheServer(commonAttributes, new Integer(localMaxMemoryServer3)));
- serverPort1 = port1;
- serverPort2 = port2;
- serverPort3 = port3;
+ Integer port1 = server1.invoke(() -> PRClientServerTestBase
+ .createCacheServer(commonAttributes, localMaxMemoryServer1));
+ Integer port2 = server2.invoke(() -> PRClientServerTestBase
+ .createCacheServer(commonAttributes, localMaxMemoryServer2));
+ Integer port3 = server3.invoke(() -> PRClientServerTestBase
+ .createCacheServer(commonAttributes, localMaxMemoryServer3));
// Workaround for the issue that hostnames returned by the client metadata may
// not match those configured by the pool, leading to multiple copies
// of the endpoint in the client.
- String hostname = (String) server1.invoke(() -> PRClientServerTestBase.getHostname());
+ String hostname = server1.invoke(PRClientServerTestBase::getHostname);
client.invoke(
() -> PRClientServerTestBase.createSingleHopCacheClient(hostname, port1, port2, port3));
}
@@ -508,80 +475,58 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
return cache.getDistributedSystem().getDistributedMember().getHost();
}
- protected void createClientServerScenarioNoSingleHop(ArrayList commonAttributes,
- int localMaxMemoryServer1, int localMaxMemoryServer2, int localMaxMemoryServer3) {
+ void createClientServerScenarioNoSingleHop(ArrayList commonAttributes,
+ int localMaxMemoryServer1, int localMaxMemoryServer2,
+ int localMaxMemoryServer3) {
createCacheInClientServer();
- Integer port1 = (Integer) server1.invoke(() -> PRClientServerTestBase
- .createCacheServer(commonAttributes, new Integer(localMaxMemoryServer1)));
- Integer port2 = (Integer) server2.invoke(() -> PRClientServerTestBase
- .createCacheServer(commonAttributes, new Integer(localMaxMemoryServer2)));
- Integer port3 = (Integer) server3.invoke(() -> PRClientServerTestBase
- .createCacheServer(commonAttributes, new Integer(localMaxMemoryServer3)));
- serverPort1 = port1;
- serverPort2 = port2;
- serverPort3 = port3;
+ Integer port1 = server1.invoke(() -> PRClientServerTestBase
+ .createCacheServer(commonAttributes, localMaxMemoryServer1));
+ Integer port2 = server2.invoke(() -> PRClientServerTestBase
+ .createCacheServer(commonAttributes, localMaxMemoryServer2));
+ Integer port3 = server3.invoke(() -> PRClientServerTestBase
+ .createCacheServer(commonAttributes, localMaxMemoryServer3));
client.invoke(() -> PRClientServerTestBase.createNoSingleHopCacheClient(
NetworkUtils.getServerHostName(server1.getHost()), port1, port2, port3));
}
- protected void createClientServerScenarioSelectorNoSingleHop(ArrayList commonAttributes,
- int localMaxMemoryServer1, int localMaxMemoryServer2, int localMaxMemoryServer3) {
+ void createClientServerScenarioSelectorNoSingleHop(ArrayList commonAttributes,
+ int localMaxMemoryServer1,
+ int localMaxMemoryServer2,
+ int localMaxMemoryServer3) {
createCacheInClientServer();
- Integer port1 = (Integer) server1.invoke(() -> PRClientServerTestBase
- .createSelectorCacheServer(commonAttributes, new Integer(localMaxMemoryServer1)));
- Integer port2 = (Integer) server2.invoke(() -> PRClientServerTestBase
- .createSelectorCacheServer(commonAttributes, new Integer(localMaxMemoryServer2)));
- Integer port3 = (Integer) server3.invoke(() -> PRClientServerTestBase
- .createSelectorCacheServer(commonAttributes, new Integer(localMaxMemoryServer3)));
- serverPort1 = port1;
- serverPort2 = port2;
- serverPort3 = port3;
+ Integer port1 = server1.invoke(() -> PRClientServerTestBase
+ .createSelectorCacheServer(commonAttributes, localMaxMemoryServer1));
+ Integer port2 = server2.invoke(() -> PRClientServerTestBase
+ .createSelectorCacheServer(commonAttributes, localMaxMemoryServer2));
+ Integer port3 = server3.invoke(() -> PRClientServerTestBase
+ .createSelectorCacheServer(commonAttributes, localMaxMemoryServer3));
client.invoke(() -> PRClientServerTestBase.createNoSingleHopCacheClient(
NetworkUtils.getServerHostName(server1.getHost()), port1, port2, port3));
}
- protected void createClientServerScenarionWithoutRegion() {
- LogWriterUtils.getLogWriter().info(
+ void createClientServerScenarionWithoutRegion() {
+ logger.info(
"PRClientServerTestBase#createClientServerScenarionWithoutRegion : creating client server");
createCacheInClientServer();
- Integer port1 = (Integer) server1.invoke(() -> PRClientServerTestBase.createCacheServer());
- Integer port2 = (Integer) server2.invoke(() -> PRClientServerTestBase.createCacheServer());
- Integer port3 = (Integer) server3.invoke(() -> PRClientServerTestBase.createCacheServer());
- serverPort1 = port1;
- serverPort2 = port2;
- serverPort3 = port3;
+ Integer port1 = server1.invoke(
+ (SerializableCallableIF<Integer>) PRClientServerTestBase::createCacheServer);
+ Integer port2 = server2.invoke(
+ (SerializableCallableIF<Integer>) PRClientServerTestBase::createCacheServer);
+ Integer port3 = server3.invoke(
+ (SerializableCallableIF<Integer>) PRClientServerTestBase::createCacheServer);
client.invoke(() -> PRClientServerTestBase.createCacheClientWithoutRegion(
NetworkUtils.getServerHostName(server1.getHost()), port1, port2, port3));
}
- protected void createClientServerScenarionWithDistributedtRegion() {
- LogWriterUtils.getLogWriter().info(
- "PRClientServerTestBase#createClientServerScenarionWithoutRegion : creating client server");
- createCacheInClientServer();
- Integer port1 =
- (Integer) server1.invoke(() -> PRClientServerTestBase.createCacheServerWithDR());
- Integer port2 =
- (Integer) server2.invoke(() -> PRClientServerTestBase.createCacheServerWithDR());
- Integer port3 =
- (Integer) server3.invoke(() -> PRClientServerTestBase.createCacheServerWithDR());
- serverPort1 = port1;
- serverPort2 = port2;
- serverPort3 = port3;
-
-
- client.invoke(() -> PRClientServerTestBase.createCacheClientWithDistributedRegion(
- NetworkUtils.getServerHostName(server1.getHost()), port1, port2, port3));
- }
-
- protected void runOnAllServers(SerializableRunnable runnable) {
+ void runOnAllServers(SerializableRunnable runnable) {
server1.invoke(runnable);
server2.invoke(runnable);
server3.invoke(runnable);
}
- protected void registerFunctionAtServer(Function function) {
+ void registerFunctionAtServer(Function function) {
server1.invoke(PRClientServerTestBase.class, "registerFunction", new Object[] {function});
server2.invoke(PRClientServerTestBase.class, "registerFunction", new Object[] {function});
@@ -626,18 +571,18 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
}
}
- public static void startServerHA() throws Exception {
+ static void startServerHA() throws Exception {
Wait.pause(2000);
Collection bridgeServers = cache.getCacheServers();
- LogWriterUtils.getLogWriter()
+ logger
.info("Start Server cache servers list : " + bridgeServers.size());
Iterator bridgeIterator = bridgeServers.iterator();
CacheServer bridgeServer = (CacheServer) bridgeIterator.next();
- LogWriterUtils.getLogWriter().info("start Server cache server" + bridgeServer);
+ logger.info("start Server cache server" + bridgeServer);
bridgeServer.start();
}
- public static void stopServerHA() throws Exception {
+ static void stopServerHA() {
Wait.pause(1000);
Iterator iter = cache.getCacheServers().iterator();
if (iter.hasNext()) {
@@ -647,48 +592,47 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
}
@Override
- public final void postTearDownCacheTestCase() throws Exception {
+ public final void postTearDownCacheTestCase() {
closeCacheAndDisconnect();
- client.invoke(() -> PRClientServerTestBase.closeCacheAndDisconnect());
- server1.invoke(() -> PRClientServerTestBase.closeCacheAndDisconnect());
- server2.invoke(() -> PRClientServerTestBase.closeCacheAndDisconnect());
- server3.invoke(() -> PRClientServerTestBase.closeCacheAndDisconnect());
+ client.invoke(PRClientServerTestBase::closeCacheAndDisconnect);
+ server1.invoke(PRClientServerTestBase::closeCacheAndDisconnect);
+ server2.invoke(PRClientServerTestBase::closeCacheAndDisconnect);
+ server3.invoke(PRClientServerTestBase::closeCacheAndDisconnect);
}
- public static void closeCacheAndDisconnect() {
+ private static void closeCacheAndDisconnect() {
if (cache != null && !cache.isClosed()) {
cache.close();
cache.getDistributedSystem().disconnect();
}
}
- public static void closeCacheHA() {
+ static void closeCacheHA() {
Wait.pause(1000);
if (cache != null && !cache.isClosed()) {
cache.close();
}
}
- public static void serverBucketFilterExecution(Set<Integer> bucketFilterSet) throws Exception {
- Region region = cache.getRegion(PartitionedRegionName);
+ void serverBucketFilterExecution(Set<Integer> bucketFilterSet) {
+ Region<Integer, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
+ final HashSet<Integer> testKeysSet = new HashSet<>();
for (int i = 150; i > 0; i--) {
testKeysSet.add(i);
}
DistributedSystem.setThreadsSocketPolicy(false);
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_BUCKET_FILTER);
- FunctionService.registerFunction(function);
+ if (shouldRegisterFunctionsOnClient()) {
+ FunctionService.registerFunction(function);
+ }
InternalExecution dataSet = (InternalExecution) FunctionService.onRegion(region);
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (Integer integer : testKeysSet) {
+ Integer val = j++;
+ region.put(integer, val);
}
- List l = null;
ResultCollector<Integer, List<Integer>> rc =
dataSet.withBucketFilter(bucketFilterSet).execute(function.getId());
List<Integer> results = rc.getResult();
@@ -699,32 +643,31 @@ public class PRClientServerTestBase extends JUnit4CacheTestCase {
assertTrue(bucketFilterSet.isEmpty());
}
- public static void serverBucketFilterOverrideExecution(Set<Integer> bucketFilterSet,
- Set<Integer> ketFilterSet) throws Exception {
+ void serverBucketFilterOverrideExecution(Set<Integer> bucketFilterSet,
+ Set<Integer> ketFilterSet) {
- Region region = cache.getRegion(PartitionedRegionName);
+ Region<Integer, Integer> region = cache.getRegion(PartitionedRegionName);
assertNotNull(region);
- final HashSet testKeysSet = new HashSet();
+ final HashSet<Integer> testKeysSet = new HashSet<>();
for (int i = 150; i > 0; i--) {
testKeysSet.add(i);
}
DistributedSystem.setThreadsSocketPolicy(false);
Function function = new TestFunction(true, TestFunction.TEST_FUNCTION_BUCKET_FILTER);
- FunctionService.registerFunction(function);
+ if (shouldRegisterFunctionsOnClient()) {
+ FunctionService.registerFunction(function);
+ }
InternalExecution dataSet = (InternalExecution) FunctionService.onRegion(region);
- Set<Integer> expectedBucketSet = new HashSet<Integer>();
+ Set<Integer> expectedBucketSet = new HashSet<>();
for (Integer key : ketFilterSet) {
expectedBucketSet.add(BucketFilterPRResolver.getBucketID(key));
}
int j = 0;
- HashSet origVals = new HashSet();
- for (Iterator i = testKeysSet.iterator(); i.hasNext();) {
- Integer val = new Integer(j++);
- origVals.add(val);
- region.put(i.next(), val);
+ for (Integer integer : testKeysSet) {
+ Integer val = j++;
+ region.put(integer, val);
}
- List l = null;
ResultCollector<Integer, List<Integer>> rc = dataSet.withBucketFilter(bucketFilterSet)
.withFilter(ketFilterSet).execute(function.getId());
List<Integer> results = rc.getResult();
diff --git a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/SingleHopGetAllPutAllDUnitTest.java b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/SingleHopGetAllPutAllDUnitTest.java
index 39ab678..4d19d0c 100644
--- a/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/SingleHopGetAllPutAllDUnitTest.java
+++ b/geode-core/src/distributedTest/java/org/apache/geode/internal/cache/execute/SingleHopGetAllPutAllDUnitTest.java
@@ -55,7 +55,7 @@ public class SingleHopGetAllPutAllDUnitTest extends PRClientServerTestBase {
@Before
public void createScenario() {
ArrayList commonAttributes =
- createCommonServerAttributes("TestPartitionedRegion", null, 2, 13, null);
+ createCommonServerAttributes("TestPartitionedRegion", null, 2, null);
createClientServerScenarioSingleHop(commonAttributes, 20, 20, 20);
}
diff --git a/geode-core/src/main/java/org/apache/geode/cache/client/internal/ServerRegionProxy.java b/geode-core/src/main/java/org/apache/geode/cache/client/internal/ServerRegionProxy.java
index 198b9d0..e4e764c 100644
--- a/geode-core/src/main/java/org/apache/geode/cache/client/internal/ServerRegionProxy.java
+++ b/geode-core/src/main/java/org/apache/geode/cache/client/internal/ServerRegionProxy.java
@@ -15,8 +15,9 @@
package org.apache.geode.cache.client.internal;
+import static java.util.Collections.emptySet;
+
import java.util.Collection;
-import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
@@ -686,7 +687,7 @@ public class ServerRegionProxy extends ServerProxy implements ServerRegionDataAc
ExecuteRegionFunctionOp.execute(pool, resultCollector, retryAttempts, function.isHA(),
(ExecuteRegionFunctionOp.ExecuteRegionFunctionOpImpl) executeRegionFunctionOpSupplier
.get(),
- false, Collections.EMPTY_SET);
+ false, emptySet());
cms.scheduleGetPRMetaData(region, false);
@@ -695,7 +696,7 @@ public class ServerRegionProxy extends ServerProxy implements ServerRegionDataAc
final java.util.function.Function<ServerRegionFunctionExecutor, AbstractOp> regionFunctionSingleHopOpFunction =
executor -> new ExecuteRegionFunctionSingleHopOp.ExecuteRegionFunctionSingleHopOpImpl(
region.getFullPath(), function, executor, resultCollector,
- hasResult, Collections.EMPTY_SET, true, timeoutMs);
+ hasResult, emptySet(), true, timeoutMs);
ExecuteRegionFunctionSingleHopOp.execute(pool, region, serverRegionExecutor,
resultCollector, serverToBuckets, retryAttempts, function.isHA(),
@@ -712,7 +713,7 @@ public class ServerRegionProxy extends ServerProxy implements ServerRegionDataAc
ExecuteRegionFunctionOp.execute(pool, resultCollector, retryAttempts, function.isHA(),
(ExecuteRegionFunctionOp.ExecuteRegionFunctionOpImpl) executeRegionFunctionOpSupplier
.get(),
- false, Collections.EMPTY_SET);
+ false, emptySet());
cms.scheduleGetPRMetaData(region, false);
@@ -721,7 +722,7 @@ public class ServerRegionProxy extends ServerProxy implements ServerRegionDataAc
final java.util.function.Function<ServerRegionFunctionExecutor, AbstractOp> regionFunctionSingleHopOpFunction =
executor -> new ExecuteRegionFunctionSingleHopOp.ExecuteRegionFunctionSingleHopOpImpl(
region.getFullPath(), function, executor, resultCollector,
- hasResult, Collections.EMPTY_SET, isBucketFilter, timeoutMs);
+ hasResult, emptySet(), isBucketFilter, timeoutMs);
ExecuteRegionFunctionSingleHopOp.execute(pool, region,
serverRegionExecutor, resultCollector, serverToFilterMap, retryAttempts,
@@ -734,14 +735,14 @@ public class ServerRegionProxy extends ServerProxy implements ServerRegionDataAc
ExecuteRegionFunctionOp.execute(pool, resultCollector, retryAttempts, function.isHA(),
(ExecuteRegionFunctionOp.ExecuteRegionFunctionOpImpl) executeRegionFunctionOpSupplier
.get(),
- false, Collections.EMPTY_SET);
+ false, emptySet());
}
} else {
ExecuteRegionFunctionOp.execute(pool,
resultCollector, retryAttempts, function.isHA(),
(ExecuteRegionFunctionOp.ExecuteRegionFunctionOpImpl) executeRegionFunctionOpSupplier
.get(),
- false, Collections.EMPTY_SET);
+ false, emptySet());
}
}
@@ -775,14 +776,14 @@ public class ServerRegionProxy extends ServerProxy implements ServerRegionDataAc
ExecuteRegionFunctionOp.execute(pool, resultCollector, retryAttempts, isHA,
(ExecuteRegionFunctionOp.ExecuteRegionFunctionOpImpl) executeRegionFunctionOpSupplier
.get(),
- false, Collections.EMPTY_SET);
+ false, emptySet());
cms.scheduleGetPRMetaData(region, false);
} else {
final java.util.function.Function<ServerRegionFunctionExecutor, AbstractOp> regionFunctionSingleHopOpFunction =
executor1 -> new ExecuteRegionFunctionSingleHopOp.ExecuteRegionFunctionSingleHopOpImpl(
region.getFullPath(), functionId, executor1, resultCollector, hasResult,
- Collections.EMPTY_SET, true, isHA, optimizeForWrite, timeoutMs);
+ emptySet(), true, isHA, optimizeForWrite, timeoutMs);
ExecuteRegionFunctionSingleHopOp.execute(pool, region,
serverRegionExecutor, resultCollector, serverToBuckets, retryAttempts, isHA,
@@ -798,7 +799,7 @@ public class ServerRegionProxy extends ServerProxy implements ServerRegionDataAc
ExecuteRegionFunctionOp.execute(pool, resultCollector, retryAttempts, isHA,
(ExecuteRegionFunctionOp.ExecuteRegionFunctionOpImpl) executeRegionFunctionOpSupplier
.get(),
- false, Collections.EMPTY_SET);
+ false, emptySet());
cms.scheduleGetPRMetaData(region, false);
} else {
@@ -806,7 +807,7 @@ public class ServerRegionProxy extends ServerProxy implements ServerRegionDataAc
final java.util.function.Function<ServerRegionFunctionExecutor, AbstractOp> regionFunctionSingleHopOpFunction =
executor -> new ExecuteRegionFunctionSingleHopOp.ExecuteRegionFunctionSingleHopOpImpl(
region.getFullPath(), functionId, executor, resultCollector, hasResult,
- Collections.EMPTY_SET, false, isHA, optimizeForWrite, timeoutMs);
+ emptySet(), isBucketsAsFilter, isHA, optimizeForWrite, timeoutMs);
ExecuteRegionFunctionSingleHopOp.execute(pool, region,
serverRegionExecutor, resultCollector, serverToFilterMap, retryAttempts,
@@ -819,14 +820,14 @@ public class ServerRegionProxy extends ServerProxy implements ServerRegionDataAc
resultCollector, retryAttempts, isHA,
(ExecuteRegionFunctionOp.ExecuteRegionFunctionOpImpl) executeRegionFunctionOpSupplier
.get(),
- false, Collections.EMPTY_SET);
+ false, emptySet());
}
} else {
ExecuteRegionFunctionOp.execute(pool,
resultCollector, retryAttempts, isHA,
(ExecuteRegionFunctionOp.ExecuteRegionFunctionOpImpl) executeRegionFunctionOpSupplier
.get(),
- false, Collections.EMPTY_SET);
+ false, emptySet());
}
}