[04/15] incubator-geode git commit: GEODE-37 Renamed security related stuff

[hi...@apache.org]

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/9d7a6960/geode-core/src/test/java/org/apache/geode/security/PDXPostProcessorDUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/org/apache/geode/security/PDXPostProcessorDUnitTest.java b/geode-core/src/test/java/org/apache/geode/security/PDXPostProcessorDUnitTest.java
new file mode 100644
index 0000000..1e87952
--- /dev/null
+++ b/geode-core/src/test/java/org/apache/geode/security/PDXPostProcessorDUnitTest.java
@@ -0,0 +1,233 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.gemstone.gemfire.security;
+
+import static org.junit.Assert.*;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.concurrent.TimeUnit;
+
+import com.jayway.awaitility.Awaitility;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import com.gemstone.gemfire.cache.EntryEvent;
+import com.gemstone.gemfire.cache.Region;
+import com.gemstone.gemfire.cache.client.ClientCache;
+import com.gemstone.gemfire.cache.client.ClientCacheFactory;
+import com.gemstone.gemfire.cache.client.ClientRegionFactory;
+import com.gemstone.gemfire.cache.client.ClientRegionShortcut;
+import com.gemstone.gemfire.cache.query.SelectResults;
+import com.gemstone.gemfire.cache.util.CacheListenerAdapter;
+import com.gemstone.gemfire.internal.AvailablePortHelper;
+import com.gemstone.gemfire.internal.cache.EntryEventImpl;
+import com.gemstone.gemfire.internal.security.SecurityService;
+import com.gemstone.gemfire.management.cli.Result.Status;
+import com.gemstone.gemfire.management.internal.cli.CliUtil;
+import com.gemstone.gemfire.management.internal.cli.HeadlessGfsh;
+import com.gemstone.gemfire.management.internal.cli.i18n.CliStrings;
+import com.gemstone.gemfire.management.internal.cli.result.CommandResult;
+import com.gemstone.gemfire.management.internal.cli.util.CommandStringBuilder;
+import com.gemstone.gemfire.pdx.SimpleClass;
+import com.gemstone.gemfire.test.junit.categories.DistributedTest;
+import com.gemstone.gemfire.test.junit.categories.SecurityTest;
+import com.gemstone.gemfire.test.junit.runners.CategoryWithParameterizedRunnerFactory;
+
+@Category({ DistributedTest.class, SecurityTest.class })
+@RunWith(Parameterized.class)
+@Parameterized.UseParametersRunnerFactory(CategoryWithParameterizedRunnerFactory.class)
+public class PDXPostProcessorDUnitTest extends AbstractSecureServerDUnitTest {
+  private static byte[] BYTES = PDXPostProcessor.BYTES;
+
+  @Parameterized.Parameters
+  public static Collection<Object[]> parameters(){
+    Object[][] params = {{true}, {false}};
+    return Arrays.asList(params);
+  }
+
+  public PDXPostProcessorDUnitTest(boolean pdxPersistent){
+    this.postProcessor = PDXPostProcessor.class;
+    this.pdxPersistent = pdxPersistent;
+    this.jmxPort = AvailablePortHelper.getRandomAvailableTCPPort();
+    values = new HashMap();
+  }
+
+  @Test
+  public void testRegionGet(){
+    client2.invoke(()->{
+      ClientCache cache = createClientCache("super-user", "1234567", serverPort);
+      Region region = cache.getRegion(REGION_NAME);
+      // put in a value that's a domain object
+      region.put("key1", new SimpleClass(1, (byte) 1));
+      // put in a byte value
+      region.put("key2", BYTES);
+    });
+
+    client1.invoke(()->{
+      ClientCache cache = createClientCache("super-user", "1234567", serverPort);
+      Region region = cache.getRegion(REGION_NAME);
+
+      // post process for get the client domain object
+      Object value = region.get("key1");
+      assertTrue(value instanceof SimpleClass);
+
+      // post process for get the raw byte value
+      value = region.get("key2");
+      assertTrue(Arrays.equals(BYTES, (byte[])value));
+    });
+
+    // this makes sure PostProcessor is getting called
+    PDXPostProcessor pp = (PDXPostProcessor) SecurityService.getSecurityService().getPostProcessor();
+    assertEquals(pp.getCount(), 2);
+  }
+
+  @Test
+  public void testQuery(){
+    client2.invoke(()->{
+      ClientCache cache = createClientCache("super-user", "1234567", serverPort);
+      Region region = cache.getRegion(REGION_NAME);
+      // put in a value that's a domain object
+      region.put("key1", new SimpleClass(1, (byte) 1));
+      region.put("key2", BYTES);
+    });
+
+    client1.invoke(()->{
+      ClientCache cache = createClientCache("super-user", "1234567", serverPort);
+      Region region = cache.getRegion(REGION_NAME);
+
+      // post process for query
+      String query = "select * from /AuthRegion";
+      SelectResults result = region.query(query);
+
+      Iterator itr = result.iterator();
+      while (itr.hasNext()) {
+        Object obj = itr.next();
+        if(obj instanceof byte[]){
+          assertTrue(Arrays.equals(BYTES, (byte[])obj));
+        }
+        else{
+          assertTrue(obj instanceof SimpleClass);
+        }
+      }
+    });
+
+    // this makes sure PostProcessor is getting called
+    PDXPostProcessor pp = (PDXPostProcessor) SecurityService.getSecurityService().getPostProcessor();
+    assertEquals(pp.getCount(), 2);
+  }
+
+  @Test
+  public void testRegisterInterest(){
+    client1.invoke(()->{
+      ClientCache cache = new ClientCacheFactory(createClientProperties("super-user", "1234567"))
+        .setPoolSubscriptionEnabled(true)
+        .addPoolServer("localhost", serverPort)
+        .create();
+
+      ClientRegionFactory factory =  cache.createClientRegionFactory(ClientRegionShortcut.PROXY);
+      factory.addCacheListener(new CacheListenerAdapter() {
+        @Override
+        public void afterUpdate(EntryEvent event) {
+          Object key = event.getKey();
+          Object value = ((EntryEventImpl) event).getDeserializedValue();
+          if(key.equals("key1")) {
+            assertTrue(value instanceof SimpleClass);
+          }
+          else if(key.equals("key2")){
+            assertTrue(Arrays.equals(BYTES, (byte[])value));
+          }
+        }
+      });
+
+      Region region = factory.create(REGION_NAME);
+      region.put("key1", "value1");
+      region.registerInterest("key1");
+      region.registerInterest("key2");
+    });
+
+    client2.invoke(()->{
+      ClientCache cache = createClientCache("dataUser", "1234567", serverPort);
+      Region region = cache.getRegion(REGION_NAME);
+      // put in a value that's a domain object
+      region.put("key1", new SimpleClass(1, (byte) 1));
+      region.put("key2", BYTES);
+    });
+
+    // wait for events to fire
+    Awaitility.await().atMost(1, TimeUnit.SECONDS);
+    PDXPostProcessor pp = (PDXPostProcessor) SecurityService.getSecurityService().getPostProcessor();
+    assertEquals(pp.getCount(), 2);
+  }
+
+  @Test
+  public void testGfshCommand(){
+    // have client2 input some domain data into the region
+    client2.invoke(()->{
+      ClientCache cache = createClientCache("super-user", "1234567", serverPort);
+      Region region = cache.getRegion(REGION_NAME);
+      // put in a value that's a domain object
+      region.put("key1", new SimpleClass(1, (byte) 1));
+      // put in a byte value
+      region.put("key2", BYTES);
+    });
+
+    client1.invoke(()->{
+      CliUtil.isGfshVM = true;
+      String shellId = getClass().getSimpleName();
+      HeadlessGfsh gfsh = new HeadlessGfsh(shellId, 30, "gfsh_files");
+
+      // connect to the jmx server
+      final CommandStringBuilder connectCommand = new CommandStringBuilder(CliStrings.CONNECT);
+      connectCommand.addOption(CliStrings.CONNECT__USERNAME, "dataUser");
+      connectCommand.addOption(CliStrings.CONNECT__PASSWORD, "1234567");
+
+      String endpoint = "localhost[" + jmxPort + "]";
+      connectCommand.addOption(CliStrings.CONNECT__JMX_MANAGER, endpoint);
+
+      gfsh.executeCommand(connectCommand.toString());
+      CommandResult result = (CommandResult) gfsh.getResult();
+
+      // get command
+      gfsh.executeCommand("get --key=key1 --region=AuthRegion");
+      result = (CommandResult) gfsh.getResult();
+      assertEquals(result.getStatus(), Status.OK);
+      if(pdxPersistent)
+        assertTrue(result.getContent().toString().contains("com.gemstone.gemfire.pdx.internal.PdxInstanceImpl"));
+      else
+        assertTrue(result.getContent().toString().contains("SimpleClass"));
+
+      gfsh.executeCommand("get --key=key2 --region=AuthRegion");
+      result = (CommandResult)gfsh.getResult();
+      assertEquals(result.getStatus(), Status.OK);
+      assertTrue(result.getContent().toString().contains("byte[]"));
+
+      gfsh.executeCommand("query --query=\"select * from /AuthRegion\"");
+      result = (CommandResult)gfsh.getResult();
+      System.out.println("gfsh result: " + result);
+    });
+
+    PDXPostProcessor pp = (PDXPostProcessor) SecurityService.getSecurityService().getPostProcessor();
+    assertEquals(pp.getCount(), 4);
+  }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/9d7a6960/geode-core/src/test/java/org/apache/geode/security/PostProcessorDUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/org/apache/geode/security/PostProcessorDUnitTest.java b/geode-core/src/test/java/org/apache/geode/security/PostProcessorDUnitTest.java
new file mode 100644
index 0000000..4a546e2
--- /dev/null
+++ b/geode-core/src/test/java/org/apache/geode/security/PostProcessorDUnitTest.java
@@ -0,0 +1,126 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.gemstone.gemfire.security;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.geode.security.templates.SamplePostProcessor;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import com.gemstone.gemfire.cache.EntryEvent;
+import com.gemstone.gemfire.cache.Region;
+import com.gemstone.gemfire.cache.client.ClientCache;
+import com.gemstone.gemfire.cache.client.ClientCacheFactory;
+import com.gemstone.gemfire.cache.client.ClientRegionFactory;
+import com.gemstone.gemfire.cache.client.ClientRegionShortcut;
+import com.gemstone.gemfire.cache.client.Pool;
+import com.gemstone.gemfire.cache.client.PoolManager;
+import com.gemstone.gemfire.cache.query.SelectResults;
+import com.gemstone.gemfire.cache.util.CacheListenerAdapter;
+import com.gemstone.gemfire.test.junit.categories.DistributedTest;
+import com.gemstone.gemfire.test.junit.categories.SecurityTest;
+
+@Category({ DistributedTest.class, SecurityTest.class })
+public class PostProcessorDUnitTest extends AbstractSecureServerDUnitTest {
+
+  public PostProcessorDUnitTest(){
+    this.postProcessor = SamplePostProcessor.class;
+  }
+
+  @Test
+  public void testPostProcessRegionGet(){
+    List<String> keys = new ArrayList<>();
+    keys.add("key1");
+    keys.add("key2");
+
+    client1.invoke(()->{
+      ClientCache cache = createClientCache("super-user", "1234567", serverPort);
+      Region region = cache.getRegion(REGION_NAME);
+
+      // post process for get
+      Object value = region.get("key3");
+      assertEquals("super-user/AuthRegion/key3/value3", value);
+
+      // post processs for getAll
+      Map values = region.getAll(keys);
+      assertEquals(2, values.size());
+      assertEquals("super-user/AuthRegion/key1/value1", values.get("key1"));
+      assertEquals("super-user/AuthRegion/key2/value2", values.get("key2"));
+    });
+  }
+
+  @Test
+  public void testPostProcessQuery(){
+    client1.invoke(()->{
+      ClientCache cache = createClientCache("super-user", "1234567", serverPort);
+      Region region = cache.getRegion(REGION_NAME);
+
+      // post process for query
+      String query = "select * from /AuthRegion";
+      SelectResults result = region.query(query);
+      assertEquals(5, result.size());
+
+      assertTrue(result.contains("super-user/null/null/value0"));
+      assertTrue(result.contains("super-user/null/null/value1"));
+      assertTrue(result.contains("super-user/null/null/value2"));
+      assertTrue(result.contains("super-user/null/null/value3"));
+      assertTrue(result.contains("super-user/null/null/value4"));
+
+      Pool pool = PoolManager.find(region);
+      result =  (SelectResults)pool.getQueryService().newQuery(query).execute();
+      assertTrue(result.contains("super-user/null/null/value0"));
+      assertTrue(result.contains("super-user/null/null/value1"));
+      assertTrue(result.contains("super-user/null/null/value2"));
+      assertTrue(result.contains("super-user/null/null/value3"));
+      assertTrue(result.contains("super-user/null/null/value4"));
+    });
+  }
+
+  @Test
+  public void testRegisterInterestPostProcess(){
+    client1.invoke(()->{
+      ClientCache cache = new ClientCacheFactory(createClientProperties("super-user", "1234567"))
+        .setPoolSubscriptionEnabled(true)
+        .addPoolServer("localhost", serverPort)
+        .create();
+
+      ClientRegionFactory factory =  cache.createClientRegionFactory(ClientRegionShortcut.PROXY);
+      factory.addCacheListener(new CacheListenerAdapter() {
+        @Override
+        public void afterUpdate(EntryEvent event) {
+          assertEquals("super-user/AuthRegion/key1/value2", event.getSerializedNewValue().getDeserializedValue());
+        }
+      });
+
+      Region region = factory.create(REGION_NAME);
+      region.put("key1", "value1");
+      region.registerInterest("key1");
+    });
+
+    client2.invoke(()->{
+      ClientCache cache = createClientCache("dataUser", "1234567", serverPort);
+      Region region = cache.getRegion(REGION_NAME);
+      region.put("key1", "value2");
+    });
+  }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/9d7a6960/geode-core/src/test/java/org/apache/geode/security/SecurityTestUtils.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/org/apache/geode/security/SecurityTestUtils.java b/geode-core/src/test/java/org/apache/geode/security/SecurityTestUtils.java
new file mode 100644
index 0000000..3a469ec
--- /dev/null
+++ b/geode-core/src/test/java/org/apache/geode/security/SecurityTestUtils.java
@@ -0,0 +1,1930 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package com.gemstone.gemfire.security;
+
+import static com.gemstone.gemfire.cache30.ClientServerTestCase.*;
+import static com.gemstone.gemfire.distributed.ConfigurationProperties.*;
+import static com.gemstone.gemfire.internal.AvailablePort.*;
+import static com.gemstone.gemfire.test.dunit.Assert.*;
+import static com.gemstone.gemfire.test.dunit.DistributedTestUtils.*;
+import static com.gemstone.gemfire.test.dunit.LogWriterUtils.*;
+import static com.gemstone.gemfire.test.dunit.NetworkUtils.*;
+import static com.gemstone.gemfire.test.dunit.Wait.*;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.concurrent.Callable;
+
+import javax.net.ServerSocketFactory;
+import javax.net.SocketFactory;
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLContextSpi;
+import javax.net.ssl.SSLServerSocketFactory;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManager;
+
+import com.gemstone.gemfire.cache.AttributesFactory;
+import com.gemstone.gemfire.cache.Cache;
+import com.gemstone.gemfire.cache.CacheFactory;
+import com.gemstone.gemfire.cache.DataPolicy;
+import com.gemstone.gemfire.cache.DynamicRegionFactory;
+import com.gemstone.gemfire.cache.Region;
+import com.gemstone.gemfire.cache.RegionAttributes;
+import com.gemstone.gemfire.cache.Scope;
+import com.gemstone.gemfire.cache.client.NoAvailableServersException;
+import com.gemstone.gemfire.cache.client.Pool;
+import com.gemstone.gemfire.cache.client.PoolFactory;
+import com.gemstone.gemfire.cache.client.PoolManager;
+import com.gemstone.gemfire.cache.client.ServerConnectivityException;
+import com.gemstone.gemfire.cache.client.ServerOperationException;
+import com.gemstone.gemfire.cache.client.ServerRefusedConnectionException;
+import com.gemstone.gemfire.cache.client.internal.PoolImpl;
+import com.gemstone.gemfire.cache.client.internal.ProxyCache;
+import com.gemstone.gemfire.cache.execute.Execution;
+import com.gemstone.gemfire.cache.execute.Function;
+import com.gemstone.gemfire.cache.execute.FunctionException;
+import com.gemstone.gemfire.cache.execute.FunctionService;
+import com.gemstone.gemfire.cache.query.Query;
+import com.gemstone.gemfire.cache.query.QueryInvocationTargetException;
+import com.gemstone.gemfire.cache.query.SelectResults;
+import com.gemstone.gemfire.cache.server.CacheServer;
+import com.gemstone.gemfire.distributed.DistributedSystem;
+import com.gemstone.gemfire.distributed.Locator;
+import com.gemstone.gemfire.distributed.internal.DistributionConfig;
+import com.gemstone.gemfire.pdx.PdxReader;
+import com.gemstone.gemfire.pdx.PdxSerializable;
+import com.gemstone.gemfire.pdx.PdxWriter;
+import com.gemstone.gemfire.test.dunit.WaitCriterion;
+import com.gemstone.gemfire.test.dunit.internal.JUnit4DistributedTestCase;
+
+/**
+ * Contains utility methods for setting up servers/clients for authentication
+ * and authorization tests.
+ *
+ * @since GemFire 5.5
+ *
+ * @deprecated in favor of just writing a test without this class
+ */
+@Deprecated
+public final class SecurityTestUtils {
+
+  private final JUnit4DistributedTestCase distributedTestCase = new JUnit4DistributedTestCase() {};
+
+  protected static final int NO_EXCEPTION = 0;
+  protected static final int AUTHREQ_EXCEPTION = 1;
+  protected static final int AUTHFAIL_EXCEPTION = 2;
+  protected static final int CONNREFUSED_EXCEPTION = 3;
+  protected static final int NOTAUTHZ_EXCEPTION = 4;
+  protected static final int OTHER_EXCEPTION = 5;
+  protected static final int NO_AVAILABLE_SERVERS = 6;
+  protected static final int SECURITY_EXCEPTION = 7;
+  // Indicates that AuthReqException may not necessarily be thrown
+  protected static final int NOFORCE_AUTHREQ_EXCEPTION = 16;
+
+  protected static final String REGION_NAME = "AuthRegion";
+  protected static final String[] KEYS = { "key1", "key2", "key3", "key4", "key5", "key6", "key7", "key8" };
+  protected static final String[] VALUES = { "value1", "value2", "value3", "value4", "value5", "value6", "value7", "value8" };
+  protected static final String[] NVALUES = { "nvalue1", "nvalue2", "nvalue3", "nvalue4", "nvalue5", "nvalue6", "nvalue7", "nvalue8" };
+
+  private static final int NUMBER_OF_USERS = 1;
+
+  private static String[] ignoredExceptions = null;
+
+  private static Locator locator = null;
+  private static Cache cache = null;
+  private static Properties currentJavaProps = null;
+  private static String locatorString = null;
+
+  private static Pool pool = null;
+  private static boolean multiUserAuthMode = false;
+
+  private static ProxyCache[] proxyCaches = new ProxyCache[NUMBER_OF_USERS];
+
+  private static Region regionRef = null;
+
+  public SecurityTestUtils(String name) { // TODO: delete
+  }
+
+  /**
+   * @deprecated Please use {@link com.gemstone.gemfire.test.dunit.IgnoredException} instead
+   */
+  private static void addIgnoredExceptions(final String[] expectedExceptions) { // TODO: delete
+    if (expectedExceptions != null) {
+      for (int index = 0; index < expectedExceptions.length; index++) {
+        getLogWriter().info("<ExpectedException action=add>" + expectedExceptions[index] + "</ExpectedException>");
+      }
+    }
+  }
+
+  /**
+   * @deprecated Please use {@link com.gemstone.gemfire.test.dunit.IgnoredException} instead
+   */
+  private static void removeExpectedExceptions(final String[] expectedExceptions) { // TODO: delete
+    if (expectedExceptions != null) {
+      for (int index = 0; index < expectedExceptions.length; index++) {
+        getLogWriter().info("<ExpectedException action=remove>" + expectedExceptions[index] + "</ExpectedException>");
+      }
+    }
+  }
+
+  protected static void setJavaProps(final Properties javaProps) {
+    removeJavaProperties(currentJavaProps);
+    addJavaProperties(javaProps);
+    currentJavaProps = javaProps;
+  }
+
+  protected static ProxyCache getProxyCaches(final int index) {
+    return proxyCaches[index];
+  }
+
+  protected static void initDynamicRegionFactory() {
+    DynamicRegionFactory.get().open(new DynamicRegionFactory.Config(null, null, false, true));
+  }
+
+  protected static int getLocatorPort() {
+    int locatorPort = getRandomAvailablePort(SOCKET);
+    String addr = getIPLiteral();
+    if (locatorString == null) {
+      locatorString = addr + "[" + locatorPort + ']';
+    }
+    else {
+      locatorString += "," + addr + "[" + locatorPort + ']';
+    }
+    return locatorPort;
+  }
+
+  /**
+   * Note that this clears the string after returning for convenience in reusing
+   * for other tests. Hence it should normally be invoked only once for a test.
+   */
+  protected static String getAndClearLocatorString() {
+    String locString = locatorString;
+    locatorString = null;
+    return locString;
+  }
+
+  protected static Properties concatProperties(final Properties[] propsList) {
+    Properties props = new Properties();
+    for (int index = 0; index < propsList.length; ++index) {
+      if (propsList[index] != null) {
+        props.putAll(propsList[index]);
+      }
+    }
+    return props;
+  }
+
+  protected static void registerExpectedExceptions(final String[] expectedExceptions) { // TODO: delete
+    SecurityTestUtils.ignoredExceptions = expectedExceptions;
+  }
+
+  protected static int createCacheServer(String authenticatorFactoryMethodName){
+    Properties authProps = new Properties();
+    authProps.setProperty(SECURITY_CLIENT_AUTHENTICATOR, authenticatorFactoryMethodName);
+    return createCacheServer(authProps, null, 0, null, 0, false, NO_EXCEPTION);
+  }
+
+  protected static int createCacheServer(final Properties authProps,
+                                         final Properties javaProps,
+                                         final int locatorPort,
+                                         final String locatorString,
+                                         final int serverPort,
+                                         final int expectedResult)
+  {
+    return createCacheServer(authProps, javaProps, locatorPort, locatorString, serverPort, false, expectedResult);
+  }
+
+  protected static int createCacheServer(Properties authProps,
+                                         final Properties javaProps,
+                                         final int locatorPort,
+                                         final String locatorString,
+                                         final int serverPort,
+                                         final boolean setupDynamicRegionFactory,
+                                         final int expectedResult)
+  {
+    if (authProps == null) {
+      authProps = new Properties();
+    }
+    authProps.setProperty(MCAST_PORT, "0");
+    if (locatorString != null && locatorString.length() > 0) {
+      authProps.setProperty(LOCATORS, locatorString);
+      authProps.setProperty(START_LOCATOR, getIPLiteral() + "[" + locatorPort + ']');
+    }
+    else {
+      authProps.setProperty(LOCATORS, "localhost[" + getDUnitLocatorPort() + "]");
+    }
+    authProps.setProperty(SECURITY_LOG_LEVEL, "finest");
+
+    getLogWriter().info("Set the server properties to: " + authProps);
+    getLogWriter().info("Set the java properties to: " + javaProps);
+
+    SecurityTestUtils tmpInstance = new SecurityTestUtils("temp");
+    try {
+      tmpInstance.createSystem(authProps, javaProps);
+    }
+    catch (AuthenticationRequiredException ex) {
+      if (expectedResult == AUTHREQ_EXCEPTION) {
+        getLogWriter().info("Got expected exception when starting peer: " + ex);
+        return 0;
+      }
+      else {
+        fail("Got unexpected exception when starting peer", ex);
+      }
+
+    }
+    catch (AuthenticationFailedException ex) {
+      if (expectedResult == AUTHFAIL_EXCEPTION) {
+        getLogWriter().info("Got expected exception when starting peer: " + ex);
+        return 0;
+      }
+      else {
+        fail("Got unexpected exception when starting peer", ex);
+      }
+
+    }
+    catch (Exception ex) {
+      fail("Got unexpected exception when starting peer", ex);
+    }
+
+    if (setupDynamicRegionFactory) {
+      initDynamicRegionFactory();
+    }
+
+    tmpInstance.openCache();
+
+    AttributesFactory factory = new AttributesFactory();
+    factory.setScope(Scope.DISTRIBUTED_ACK);
+    factory.setDataPolicy(DataPolicy.REPLICATE);
+
+    RegionAttributes attrs = factory.create();
+
+    Region region = cache.createRegion(REGION_NAME, attrs);
+    int port = serverPort <= 0 ? 0 : serverPort;
+
+    CacheServer server1 = cache.addCacheServer();
+
+    server1.setPort(port);
+    server1.setNotifyBySubscription(true);
+    try {
+      server1.start();
+    }
+    catch (AuthenticationRequiredException ex) {
+      if (expectedResult == AUTHREQ_EXCEPTION) {
+        getLogWriter().info("Got expected exception when starting server: " + ex);
+        return 0;
+      }
+      else {
+        fail("Got unexpected exception when starting server", ex);
+      }
+    }
+    catch (Exception ex) {
+      fail("Got unexpected exception when starting server", ex);
+    }
+
+    return server1.getPort();
+  }
+
+  // 1
+  protected static void createCacheClient(final String authInitModule,
+                                          final Properties authProps,
+                                          final Properties javaProps,
+                                          final int[] ports,
+                                          final int numConnections,
+                                          final int expectedResult)
+  {
+    createCacheClient(authInitModule, authProps, javaProps, ports, numConnections, false, expectedResult);
+  }
+
+  // 2 a
+  protected static void createCacheClient(final String authInitModule,
+                                          final Properties authProps,
+                                          final Properties javaProps,
+                                          final int[] ports,
+                                          final int numConnections,
+                                          final boolean multiUserMode,
+                                          final int expectedResult)
+  {
+    createCacheClient(authInitModule, authProps, javaProps, ports, numConnections, false, multiUserMode, expectedResult);
+  }
+
+  // 3
+  protected static void createCacheClientWithDynamicRegion(final String authInitModule,
+                                                           final Properties authProps,
+                                                           final Properties javaProps,
+                                                           final int[] ports,
+                                                           final int numConnections,
+                                                           final boolean setupDynamicRegionFactory,
+                                                           final int expectedResult)
+  {
+     createCacheClient(authInitModule, authProps, javaProps, ports, numConnections, setupDynamicRegionFactory, false, expectedResult);
+  }
+
+  // 4
+  protected static void createCacheClient(final String authInitModule,
+                                          final Properties authProps,
+                                          final Properties javaProps,
+                                          final int[] ports,
+                                          final int numConnections,
+                                          final boolean setupDynamicRegionFactory,
+                                          final boolean multiUserMode,
+                                          final int expectedResult)
+  {
+    createCacheClient(authInitModule, authProps, javaProps, ports, numConnections, setupDynamicRegionFactory, multiUserMode, true, expectedResult);
+  }
+
+  // 5
+  protected static void createCacheClient(final String authInitModule,
+                                          Properties authProps,
+                                          final Properties javaProps,
+                                          int[] ports,
+                                          final int numConnections,
+                                          final boolean setupDynamicRegionFactory,
+                                          final boolean multiUserMode,
+                                          final boolean subscriptionEnabled,
+                                          final int expectedResult)
+  {
+    multiUserAuthMode = multiUserMode;
+
+    if (authProps == null) {
+      authProps = new Properties();
+    }
+    authProps.setProperty(MCAST_PORT, "0");
+    authProps.setProperty(LOCATORS, "");
+    authProps.setProperty(SECURITY_LOG_LEVEL, "finest");
+    // TODO (ashetkar) Add " && (!multiUserAuthMode)" below.
+    if (authInitModule != null) {
+      authProps.setProperty(SECURITY_CLIENT_AUTH_INIT, authInitModule);
+    }
+
+    SecurityTestUtils tmpInstance = new SecurityTestUtils("temp");
+    tmpInstance.createSystem(authProps, javaProps);
+
+    AttributesFactory factory = new AttributesFactory();
+
+    int[] portsI = new int[ports.length];
+    for (int z = 0; z < ports.length; z++) {
+      portsI[z] = ports[z];
+    }
+
+    try {
+      PoolFactory poolFactory = PoolManager.createFactory();
+      poolFactory.setRetryAttempts(200);
+
+      if (multiUserAuthMode) {
+        poolFactory.setMultiuserAuthentication(multiUserAuthMode);
+        // [sumedh] Why is this false here only to be overridden in ClientServerTestCase.configureConnectionPoolWithNameAndFactory below?
+        // Actually setting it to false causes MultiUserAPIDUnitTest to fail.
+        //poolFactory.setSubscriptionEnabled(false);
+      }
+
+      pool = configureConnectionPoolWithNameAndFactory(factory, getIPLiteral(), portsI, subscriptionEnabled, 0, numConnections, null, null, poolFactory);
+
+      if (setupDynamicRegionFactory) {
+        initClientDynamicRegionFactory(pool.getName());
+      }
+
+      tmpInstance.openCache();
+      try {
+        getLogWriter().info("multi-user mode " + multiUserAuthMode);
+        proxyCaches[0] = (ProxyCache) ((PoolImpl) pool).createAuthenticatedCacheView(authProps);
+        if (!multiUserAuthMode) {
+          fail("Expected a UnsupportedOperationException but got none in single-user mode");
+        }
+
+      }
+      catch (UnsupportedOperationException uoe) {
+        if (!multiUserAuthMode) {
+          getLogWriter().info("Got expected UnsupportedOperationException in single-user mode");
+        }
+        else {
+          fail("Got unexpected exception in multi-user mode ", uoe);
+        }
+      }
+
+      factory.setScope(Scope.LOCAL);
+      if (multiUserAuthMode) {
+        factory.setDataPolicy(DataPolicy.EMPTY);
+      }
+
+      RegionAttributes attrs = factory.create();
+
+      cache.createRegionFactory(attrs).create(REGION_NAME);
+
+//      if (expectedResult != NO_EXCEPTION && expectedResult != NOFORCE_AUTHREQ_EXCEPTION) {
+//        if (!multiUserAuthMode) {
+//          fail("Expected an exception when starting client");
+//        }
+//      }
+
+    }
+    catch (AuthenticationRequiredException ex) {
+      if (expectedResult == AUTHREQ_EXCEPTION || expectedResult == NOFORCE_AUTHREQ_EXCEPTION) {
+        getLogWriter().info("Got expected exception when starting client: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when starting client", ex);
+      }
+
+    }
+    catch (AuthenticationFailedException ex) {
+      if (expectedResult == AUTHFAIL_EXCEPTION) {
+        getLogWriter().info("Got expected exception when starting client: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when starting client", ex);
+      }
+
+    }
+    catch (ServerRefusedConnectionException ex) {
+      if (expectedResult == CONNREFUSED_EXCEPTION) {
+        getLogWriter().info("Got expected exception when starting client: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when starting client", ex);
+      }
+
+    }
+    catch (GemFireSecurityException ex){
+      if(expectedResult == SECURITY_EXCEPTION){
+        getLogWriter().info("Got expected exception when starting client: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when starting client", ex);
+      }
+    }
+    catch (Exception ex) {
+      fail("Got unexpected exception when starting client", ex);
+    }
+  }
+
+  protected static void createCacheClientForMultiUserMode(final int numOfUsers,
+                                                          final String authInitModule,
+                                                          final Properties[] authProps,
+                                                          final Properties javaProps,
+                                                          final int[] ports,
+                                                          final int numConnections,
+                                                          final boolean setupDynamicRegionFactory,
+                                                          final int expectedResult)
+  {
+    createCacheClientForMultiUserMode(numOfUsers, authInitModule, authProps, javaProps, ports, numConnections, setupDynamicRegionFactory, null, expectedResult);
+  }
+
+  protected static void createCacheClientForMultiUserMode(final int numOfUsers,
+                                                          final String authInitModule,
+                                                          final Properties[] authProps,
+                                                          final Properties javaProps,
+                                                          final int[] ports,
+                                                          final int numConnections,
+                                                          final boolean setupDynamicRegionFactory,
+                                                          final String durableClientId,
+                                                          final int expectedResult)
+  {
+    if (numOfUsers < 1) {
+      fail("Number of users cannot be less than one");
+    }
+
+    multiUserAuthMode = true;
+
+    if (numOfUsers != authProps.length) {
+      fail("Number of authProps provided does not match with numOfUsers specified, " + authProps.length);
+    }
+
+    if (authProps[0] == null) {
+      authProps[0] = new Properties();
+    }
+    authProps[0].setProperty(MCAST_PORT, "0");
+    authProps[0].setProperty(LOCATORS, "");
+    authProps[0].setProperty(SECURITY_LOG_LEVEL, "finest");
+
+    Properties props = new Properties();
+
+    if (authInitModule != null) {
+      authProps[0].setProperty(SECURITY_CLIENT_AUTH_INIT, authInitModule);
+      props.setProperty(SECURITY_CLIENT_AUTH_INIT, authInitModule);
+    }
+
+    if (durableClientId != null) {
+      props.setProperty(DURABLE_CLIENT_ID, durableClientId);
+      props.setProperty(DURABLE_CLIENT_TIMEOUT, String.valueOf(DistributionConfig.DEFAULT_DURABLE_CLIENT_TIMEOUT));
+    }
+
+    SecurityTestUtils tmpInstance = new SecurityTestUtils("temp");
+    tmpInstance.createSystem(props, javaProps);
+
+    AttributesFactory factory = new AttributesFactory();
+
+    int[] portsI = new int[ports.length];
+    for (int z = 0; z < ports.length; z++) {
+      portsI[z] = ports[z];
+    }
+
+    try {
+      tmpInstance.openCache();
+
+      PoolFactory poolFactory = PoolManager.createFactory();
+      poolFactory.setRetryAttempts(200);
+      poolFactory.setMultiuserAuthentication(multiUserAuthMode);
+      poolFactory.setSubscriptionEnabled(true);
+
+      pool = configureConnectionPoolWithNameAndFactory(factory, getIPLiteral(), portsI, true, 1, numConnections, null, null, poolFactory);
+
+      if (setupDynamicRegionFactory) {
+        initClientDynamicRegionFactory(pool.getName());
+      }
+
+      proxyCaches = new ProxyCache[numOfUsers];
+      for (int i = 0; i < numOfUsers; i++) {
+        proxyCaches[i] = (ProxyCache) ((PoolImpl) pool).createAuthenticatedCacheView(authProps[i]);
+      }
+
+      factory.setScope(Scope.LOCAL);
+      factory.setDataPolicy(DataPolicy.EMPTY);
+      RegionAttributes attrs = factory.create();
+
+      cache.createRegion(REGION_NAME, attrs);
+
+      if (expectedResult != NO_EXCEPTION && expectedResult != NOFORCE_AUTHREQ_EXCEPTION) {
+        if (!multiUserAuthMode) {
+          fail("Expected an exception when starting client");
+        }
+      }
+
+    }
+    catch (AuthenticationRequiredException ex) {
+      if (expectedResult == AUTHREQ_EXCEPTION || expectedResult == NOFORCE_AUTHREQ_EXCEPTION) {
+        getLogWriter().info("Got expected exception when starting client: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when starting client", ex);
+      }
+
+    }
+    catch (AuthenticationFailedException ex) {
+      if (expectedResult == AUTHFAIL_EXCEPTION) {
+        getLogWriter().info("Got expected exception when starting client: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when starting client", ex);
+      }
+
+    }
+    catch (ServerRefusedConnectionException ex) {
+      if (expectedResult == CONNREFUSED_EXCEPTION) {
+        getLogWriter().info("Got expected exception when starting client: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when starting client", ex);
+      }
+
+    }
+    catch (Exception ex) {
+      fail("Got unexpected exception when starting client", ex);
+    }
+  }
+
+  protected static void createProxyCache(final int[] userIndices, final Properties[] props) {
+    int j = 0;
+    for (int i : userIndices) {
+      proxyCaches[i] = (ProxyCache) ((PoolImpl) pool).createAuthenticatedCacheView(props[j]);
+      j++;
+    }
+  }
+
+  protected static void startLocator(final String name, int port, final Properties extraProps, final Properties javaProps, final String[] expectedExceptions) {
+    try {
+      Properties authProps = new Properties();
+
+      if (extraProps != null) {
+        authProps.putAll(extraProps);
+      }
+      authProps.setProperty(MCAST_PORT, "0");
+      authProps.setProperty(LOCATORS, getIPLiteral() + "[" + port + "]");
+      authProps.setProperty(ENABLE_CLUSTER_CONFIGURATION, "false");
+
+      clearStaticSSLContext();
+
+      setJavaProps(javaProps);
+
+      File logFile = new File(name + "-locator" + port + ".log");
+      FileOutputStream logOut = new FileOutputStream(logFile);
+      PrintStream logStream = new PrintStream(logOut);
+      addIgnoredExceptions(expectedExceptions);
+      logStream.flush();
+
+      locator = Locator.startLocatorAndDS(port, logFile, null, authProps);
+
+    }
+    catch (IOException ex) {
+      fail("While starting locator on port " + port, ex);
+    }
+  }
+
+  protected static void stopLocator(final int port, final String[] expectedExceptions) {
+    try {
+      locator.stop();
+      removeExpectedExceptions(expectedExceptions);
+
+    }
+    catch (Exception ex) {
+      fail("While stopping locator on port " + port, ex);
+    }
+  }
+
+  protected static Cache getCache() {
+    return cache;
+  }
+
+  protected static void waitForCondition(final Callable<Boolean> condition) {
+    waitForCondition(condition, 100, 120);
+  }
+
+  protected static void waitForCondition(final Callable<Boolean> condition, final int sleepMillis, final int numTries) {
+    WaitCriterion ev = new WaitCriterion() {
+      @Override
+      public boolean done() {
+        try {
+          return condition.call();
+        }
+        catch (Exception e) {
+          fail("Unexpected exception", e);
+        }
+        return false; // NOTREACHED
+      }
+
+      @Override
+      public String description() {
+        return null;
+      }
+    };
+    waitForCriterion(ev, sleepMillis * numTries, 200, true);
+  }
+
+  protected static Object getLocalValue(final Region region, final Object key) {
+    Region.Entry entry = region.getEntry(key);
+    return (entry != null ? entry.getValue() : null);
+  }
+
+  protected static void doProxyCacheClose() {
+    for (int i = 0; i < proxyCaches.length; i++) {
+      proxyCaches[i].close();
+    }
+  }
+
+  protected static void doPutAllP() throws Exception {
+    Region region = getCache().getRegion(REGION_NAME);
+    assertNotNull(region);
+
+    Map<String, Employee> map = new LinkedHashMap<>();
+    map.put("1010L", new Employee(1010L, "John", "Doe"));
+
+    region.putAll(map);
+  }
+
+  protected static void doPuts(final int num) {
+    doPutsP(num, NO_EXCEPTION, false);
+  }
+
+  protected static void doPuts(final int num, final int expectedResult) {
+    doPutsP(num, expectedResult, false);
+  }
+
+  protected static void doMultiUserPuts(final int num, final int numOfUsers, final int[] expectedResults) {
+    if (numOfUsers != expectedResults.length) {
+      fail("SecurityTestUtils.doMultiUserPuts(): numOfUsers = " + numOfUsers + ", but expected results " + expectedResults.length);
+    }
+
+    for (int i = 0; i < numOfUsers; i++) {
+      getLogWriter().info("PUT: MultiUser# " + i);
+      doPutsP(num, i, expectedResults[i], false);
+    }
+  }
+
+  protected static void doGets(final int num) {
+    doGetsP(num, NO_EXCEPTION, false);
+  }
+
+  protected static void doGets(final int num, final int expectedResult) {
+    doGetsP(num, expectedResult, false);
+  }
+
+  protected static void doMultiUserGetAll(final int numOfUsers, final int[] expectedResults) {
+    doMultiUserGetAll(numOfUsers, expectedResults, false);
+  }
+
+  protected static void doMultiUserGetAll(final int numOfUsers, final int[] expectedResults, final boolean useTX) {
+    if (numOfUsers != expectedResults.length) {
+      fail("SecurityTestUtils.doMultiUserGetAll(): numOfUsers = " + numOfUsers + ", but expected results " + expectedResults.length);
+    }
+
+    for (int i = 0; i < numOfUsers; i++) {
+      getLogWriter().info("GET_ALL" + (useTX ? " in TX" : "") + ": MultiUser# " + i);
+      doGetAllP(i, expectedResults[i], useTX);
+    }
+  }
+
+  protected static void doMultiUserGets(final int num, final int numOfUsers, final int[] expectedResults) {
+    if (numOfUsers != expectedResults.length) {
+      fail("SecurityTestUtils.doMultiUserGets(): numOfUsers = " + numOfUsers + ", but expected results " + expectedResults.length);
+    }
+
+    for (int i = 0; i < numOfUsers; i++) {
+      getLogWriter().info("GET: MultiUser# " + i);
+      doGetsP(num, i, expectedResults[i], false);
+    }
+  }
+
+  protected static void doMultiUserRegionDestroys(final int numOfUsers, final int[] expectedResults) {
+    if (numOfUsers != expectedResults.length) {
+      fail("SecurityTestUtils.doMultiUserRegionDestroys(): numOfUsers = " + numOfUsers + ", but expected results " + expectedResults.length);
+    }
+
+    for (int i = numOfUsers - 1; i >= 0; i--) {
+      getLogWriter().info("DESTROY: MultiUser# " + i);
+      doRegionDestroysP(i, expectedResults[i]);
+    }
+  }
+
+  protected static void doMultiUserDestroys(final int num, final int numOfUsers, final int[] expectedResults) {
+    if (numOfUsers != expectedResults.length) {
+      fail("SecurityTestUtils.doMultiUserDestroys(): numOfUsers = " + numOfUsers + ", but expected results " + expectedResults.length);
+    }
+
+    for (int i = 0; i < numOfUsers; i++) {
+      getLogWriter().info("DESTROY: MultiUser# " + i);
+      doDestroysP(num, i, expectedResults[i]);
+    }
+  }
+
+  protected static void doMultiUserInvalidates(final int num, final int numOfUsers, final int[] expectedResults) {
+    if (numOfUsers != expectedResults.length) {
+      fail("SecurityTestUtils.doMultiUserInvalidates(): numOfUsers = " + numOfUsers + ", but expected results " + expectedResults.length);
+    }
+
+    for (int i = 0; i < numOfUsers; i++) {
+      getLogWriter().info("INVALIDATE: MultiUser# " + i);
+      doInvalidatesP(num, i, expectedResults[i]);
+    }
+  }
+
+  protected static void doMultiUserContainsKeys(final int num, final int numOfUsers, final int[] expectedResults, final boolean[] results) {
+    if (numOfUsers != expectedResults.length) {
+      fail("SecurityTestUtils.doMultiUserContainsKeys(): numOfUsers = " + numOfUsers + ", but #expected results " + expectedResults.length);
+    }
+
+    if (numOfUsers != results.length) {
+      fail("SecurityTestUtils.doMultiUserContainsKeys(): numOfUsers = " + numOfUsers + ", but #expected output " + results.length);
+    }
+
+    for (int i = 0; i < numOfUsers; i++) {
+      getLogWriter().info("CONTAINS_KEY: MultiUser# " + i);
+      doContainsKeysP(num, i, expectedResults[i], results[i]);
+    }
+  }
+
+  protected static void doMultiUserQueries(final int numOfUsers, final int[] expectedResults, final int valueSize) {
+    if (numOfUsers != expectedResults.length) {
+      fail("SecurityTestUtils.doMultiUserQueries(): numOfUsers = " + numOfUsers + ", but #expected results " + expectedResults.length);
+    }
+
+    for (int i = 0; i < numOfUsers; i++) {
+      getLogWriter().info("QUERY: MultiUser# " + i);
+      doQueriesP(i, expectedResults[i], valueSize);
+    }
+  }
+
+  protected static void doMultiUserFE(final int numOfUsers, final Function function, final int[] expectedResults, final boolean isFailOverCase) {
+    if (numOfUsers != expectedResults.length) {
+      fail("SecurityTestUtils.doMultiUserFE(): numOfUsers = " + numOfUsers + ", but #expected results " + expectedResults.length);
+    }
+
+    for (int i = 0; i < numOfUsers; i++) {
+      getLogWriter().info("FunctionExecute:onRegion MultiUser# " + i);
+      doFunctionExecuteP(i, function, expectedResults[i], "region");
+    }
+
+    for (int i = 0; i < numOfUsers; i++) {
+      getLogWriter().info("FunctionExecute:onServer MultiUser# " + i);
+      doFunctionExecuteP(i, function, expectedResults[i], "server");
+    }
+
+    if (!isFailOverCase) {
+      for (int i = 0; i < numOfUsers; i++) {
+        getLogWriter().info("FunctionExecute:onServers MultiUser# " + i);
+        doFunctionExecuteP(i, function, expectedResults[i], "servers");
+      }
+    }
+  }
+
+  protected static void doMultiUserQueryExecute(final int numOfUsers, final int[] expectedResults, final int result) {
+    if (numOfUsers != expectedResults.length) {
+      fail("SecurityTestUtils.doMultiUserFE(): numOfUsers = " + numOfUsers + ", but #expected results " + expectedResults.length);
+    }
+
+    for (int i = 0; i < numOfUsers; i++) {
+      getLogWriter().info("QueryExecute: MultiUser# " + i);
+      doQueryExecuteP(i, expectedResults[i], result);
+    }
+  }
+
+  protected static void doLocalGets(final int num) {
+    doLocalGetsP(num, false);
+  }
+
+  protected static void doNPuts(final int num) {
+    doPutsP(num, NO_EXCEPTION, true);
+  }
+
+  protected static void doNPuts(final int num, final int expectedResult) {
+    doPutsP(num, expectedResult, true);
+  }
+
+  protected static void doNGets(final int num) {
+    doGetsP(num, NO_EXCEPTION, true);
+  }
+
+  protected static void doNGets(final int num, final int expectedResult) {
+    doGetsP(num, expectedResult, true);
+  }
+
+  protected static void doNLocalGets(final int num) {
+    doLocalGetsP(num, true);
+  }
+
+  protected static void doSimpleGet(final String expectedResult) {
+    if (regionRef != null) {
+      try {
+        regionRef.get("KEY");
+        if (expectedResult != null && expectedResult.endsWith("Exception")) {
+          fail("Expected " + expectedResult + " but found none in doSimpleGet()");
+        }
+
+      }
+      catch (Exception e) {
+        if (!e.getClass().getSimpleName().endsWith(expectedResult)) {
+          fail("Expected " + expectedResult + " but found " + e.getClass().getSimpleName() + " in doSimpleGet()");
+        }
+        else {
+          getLogWriter().fine("Got expected " + e.getClass().getSimpleName() + " in doSimpleGet()");
+        }
+      }
+    }
+  }
+
+  protected static void doSimplePut(final String expectedResult) {
+    if (regionRef != null) {
+      try {
+        regionRef.put("KEY", "VALUE");
+        if (expectedResult != null && expectedResult.endsWith("Exception")) {
+          fail("Expected " + expectedResult + " but found none in doSimplePut()");
+        }
+
+      }
+      catch (Exception e) {
+        if (!e.getClass().getSimpleName().endsWith(expectedResult)) {
+          fail("Expected " + expectedResult + " but found " + e.getClass().getSimpleName() + " in doSimplePut()", e);
+        }
+        else {
+          getLogWriter().fine("Got expected " + e.getClass().getSimpleName() + " in doSimplePut()");
+        }
+      }
+    }
+  }
+
+  /**
+   * This is a hack using reflection to clear the static objects in JSSE since
+   * otherwise changing the javax.* store related properties has no effect
+   * during the course of running dunit suite unless the VMs are restarted.
+   */
+  protected static void clearStaticSSLContext() {
+    ServerSocketFactory defaultServerFact = SSLServerSocketFactory.getDefault();
+
+    // Get the class of this and use reflection to blank out any static SSLContext objects inside
+    Map<Field, Object> contextMap = getSSLFields(defaultServerFact, new Class[] { SSLContext.class, SSLContextSpi.class });
+    makeNullSSLFields(defaultServerFact, contextMap);
+
+    for (Iterator contextObjsIter = contextMap.values().iterator(); contextObjsIter.hasNext(); ) {
+      Object contextObj = contextObjsIter.next();
+      Map<Field, Object> contextObjsMap = getSSLFields(contextObj,
+        new Class[] { TrustManager.class, KeyManager.class, TrustManager[].class, KeyManager[].class });
+      makeNullSSLFields(contextObj, contextObjsMap);
+    }
+
+    makeNullStaticField(SSLServerSocketFactory.class);
+
+    // Do the same for normal SSL socket factory
+    SocketFactory defaultFact = SSLSocketFactory.getDefault();
+    contextMap = getSSLFields(defaultFact, new Class[] { SSLContext.class, SSLContextSpi.class });
+    makeNullSSLFields(defaultFact, contextMap);
+
+    for (Iterator contextObjsIter = contextMap.values().iterator(); contextObjsIter.hasNext(); ) {
+      Object contextObj = contextObjsIter.next();
+      Map<Field, Object> contextObjsMap = getSSLFields(contextObj,
+        new Class[] { TrustManager.class, KeyManager.class, TrustManager[].class, KeyManager[].class });
+      makeNullSSLFields(contextObj, contextObjsMap);
+    }
+
+    makeNullStaticField(SSLSocketFactory.class);
+    makeNullStaticField(SSLContext.class);
+  }
+
+  protected static void closeCache() {
+    removeExpectedExceptions(ignoredExceptions);
+
+    if (cache != null && !cache.isClosed()) {
+      DistributedSystem sys = cache.getDistributedSystem();
+      cache.close();
+      sys.disconnect();
+      cache = null;
+    }
+
+    disconnectFromDS();
+  }
+
+  protected static void closeCache(final Boolean keepAlive) {
+    removeExpectedExceptions(ignoredExceptions);
+
+    if (cache != null && !cache.isClosed()) {
+      DistributedSystem sys = cache.getDistributedSystem();
+      cache.close(keepAlive);
+      sys.disconnect();
+      cache = null;
+    }
+
+    disconnectFromDS();
+  }
+
+  // ------------------------- private static methods -------------------------
+
+  private static void initClientDynamicRegionFactory(final String poolName) {
+    DynamicRegionFactory.get().open(new DynamicRegionFactory.Config(null, poolName, false, true));
+  }
+
+  private static void addJavaProperties(final Properties javaProps) {
+    if (javaProps != null) {
+      for (Iterator iter = javaProps.entrySet().iterator(); iter.hasNext(); ) {
+        Map.Entry entry = (Map.Entry) iter.next();
+        System.setProperty((String) entry.getKey(), (String) entry.getValue());
+      }
+    }
+  }
+
+  private static void removeJavaProperties(final Properties javaProps) {
+    if (javaProps != null) {
+      Properties props = System.getProperties();
+
+      for (Iterator iter = javaProps.keySet().iterator(); iter.hasNext(); ) {
+        props.remove(iter.next());
+      }
+
+      System.setProperties(props);
+    }
+  }
+
+  private static void doPutsP(final int num, final int expectedResult, final boolean newVals) {
+    doPutsP(num, 0, expectedResult, newVals);
+  }
+
+  private static void doPutsP(final int num, final int multiUserIndex, final int expectedResult, final boolean newVals) {
+    assertTrue(num <= KEYS.length);
+    Region region = null;
+
+    try {
+      if (multiUserAuthMode) {
+        region = proxyCaches[multiUserIndex].getRegion(REGION_NAME);
+        regionRef = region;
+      }
+      else {
+        region = getCache().getRegion(REGION_NAME);
+      }
+      assertNotNull(region);
+
+    }
+    catch (Exception ex) {
+      if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when doing puts: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when doing puts", ex);
+      }
+    }
+
+    for (int index = 0; index < num; ++index) {
+      try {
+        if (newVals) {
+          region.put(KEYS[index], NVALUES[index]);
+        }
+        else {
+          region.put(KEYS[index], VALUES[index]);
+        }
+        if (expectedResult != NO_EXCEPTION) {
+          fail("Expected a NotAuthorizedException while doing puts");
+        }
+
+      }
+      catch (NoAvailableServersException ex) {
+        if (expectedResult == NO_AVAILABLE_SERVERS) {
+          getLogWriter().info("Got expected NoAvailableServers when doing puts: " + ex.getCause());
+          continue;
+        }
+        else {
+          fail("Got unexpected exception when doing puts", ex);
+        }
+
+      }
+      catch (ServerConnectivityException ex) {
+        if ((expectedResult == NOTAUTHZ_EXCEPTION) && (ex.getCause() instanceof NotAuthorizedException)) {
+          getLogWriter().info("Got expected NotAuthorizedException when doing puts: " + ex.getCause());
+          continue;
+        }
+
+        if ((expectedResult == AUTHREQ_EXCEPTION) && (ex.getCause() instanceof AuthenticationRequiredException)) {
+          getLogWriter().info("Got expected AuthenticationRequiredException when doing puts: " + ex.getCause());
+          continue;
+        }
+
+        if ((expectedResult == AUTHFAIL_EXCEPTION) && (ex.getCause() instanceof AuthenticationFailedException)) {
+          getLogWriter().info("Got expected AuthenticationFailedException when doing puts: " + ex.getCause());
+          continue;
+        }
+        else if (expectedResult == OTHER_EXCEPTION) {
+          getLogWriter().info("Got expected exception when doing puts: " + ex);
+        }
+        else {
+          fail("Got unexpected exception when doing puts", ex);
+        }
+
+      }
+      catch (Exception ex) {
+        if (expectedResult == OTHER_EXCEPTION) {
+          getLogWriter().info("Got expected exception when doing puts: " + ex);
+        }
+        else {
+          fail("Got unexpected exception when doing puts", ex);
+        }
+      }
+    }
+  }
+
+  private static Map<Field, Object> getSSLFields(final Object obj, final Class[] classes) {
+    Map<Field, Object> resultFields = new HashMap<>();
+    Field[] fields = obj.getClass().getDeclaredFields();
+
+    for (int index = 0; index < fields.length; ++index) {
+      Field field = fields[index];
+
+      try {
+        field.setAccessible(true);
+        Object fieldObj = field.get(obj);
+        boolean isInstance = false;
+
+        for (int classIndex = 0; classIndex < classes.length; ++classIndex) {
+          if ((isInstance = classes[classIndex].isInstance(fieldObj)) == true) {
+            break;
+          }
+        }
+
+        if (isInstance) {
+          resultFields.put(field, fieldObj);
+        }
+
+      }
+      catch (IllegalAccessException ex) {
+        getLogWriter().warning("Exception while getting SSL fields.", ex);
+      }
+    }
+    return resultFields;
+  }
+
+  private static void makeNullSSLFields(final Object obj, final Map<Field, Object> fieldMap) {
+    for (Iterator<Map.Entry<Field, Object>> fieldIter = fieldMap.entrySet().iterator(); fieldIter.hasNext(); ) {
+      Map.Entry<Field, Object> entry = fieldIter.next();
+      Field field = entry.getKey();
+      Object fieldObj = entry.getValue();
+
+      try {
+        field.setAccessible(true);
+        makeNullStaticField(fieldObj.getClass());
+        field.set(obj, null);
+        assertNull(field.get(obj));
+
+      }
+      catch (IllegalAccessException ex) {
+        getLogWriter().warning("Exception while clearing SSL fields.", ex);
+      }
+    }
+  }
+
+  /**
+   * Deal with javax SSL properties
+   */
+  private static void makeNullStaticField(final Class sslClass) {
+    Field[] fields = sslClass.getDeclaredFields();
+    for (int index = 0; index < fields.length; ++index) {
+      Field field = fields[index];
+
+      try {
+        if (Modifier.isStatic(field.getModifiers())) {
+          field.setAccessible(true);
+          if (field.getClass().equals(boolean.class)) {
+            field.setBoolean(null, false);
+            assertFalse(field.getBoolean(null));
+
+          }
+          else if (sslClass.isInstance(field.get(null))) {
+            field.set(null, null);
+            assertNull(field.get(null));
+          }
+        }
+
+      }
+      catch (IllegalAccessException ex) {
+        getLogWriter().warning("Exception while clearing static SSL field.", ex);
+      }
+      catch (ClassCastException ex) {
+        getLogWriter().warning("Exception while clearing static SSL field.", ex);
+      }
+    }
+  }
+
+  private static void doQueryExecuteP(final int multiUserIndex, final int expectedResult, final int expectedValue) {
+    Region region = null;
+    try {
+      if (multiUserAuthMode) {
+        region = proxyCaches[multiUserIndex].getRegion(REGION_NAME);
+      }
+      else {
+        region = getCache().getRegion(REGION_NAME);
+      }
+      assertNotNull(region);
+
+    }
+    catch (Exception ex) {
+      if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when executing query: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when executing query", ex);
+      }
+    }
+
+    try {
+      String queryString = "SELECT DISTINCT * FROM " + region.getFullPath();
+      Query query = null;
+
+      if (multiUserAuthMode) {
+        query = proxyCaches[multiUserIndex].getQueryService().newQuery(queryString);
+      }
+      else {
+        region.getCache().getQueryService().newQuery(queryString);
+      }
+
+      SelectResults result = (SelectResults) query.execute();
+      if (expectedResult != NO_EXCEPTION) {
+        fail("Expected a NotAuthorizedException while executing function");
+      }
+      assertEquals(expectedValue, result.asList().size());
+
+    }
+    catch (NoAvailableServersException ex) {
+      if (expectedResult == NO_AVAILABLE_SERVERS) {
+        getLogWriter().info("Got expected NoAvailableServers when executing query: " + ex.getCause());
+      }
+      else {
+        fail("Got unexpected exception when executing query", ex);
+      }
+
+    }
+    catch (ServerConnectivityException ex) {
+      if ((expectedResult == NOTAUTHZ_EXCEPTION) && (ex.getCause() instanceof NotAuthorizedException)) {
+        getLogWriter().info("Got expected NotAuthorizedException when executing query: " + ex.getCause());
+      }
+      else if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when executing query: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when executing query", ex);
+      }
+
+    }
+    catch (Exception ex) {
+      if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when executing query: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when executing query", ex);
+      }
+    }
+  }
+
+  private static void doFunctionExecuteP(final int multiUserIndex, final Function function, int expectedResult, final String method) {
+    Region region = null;
+    try {
+      if (multiUserAuthMode) {
+        region = proxyCaches[multiUserIndex].getRegion(REGION_NAME);
+      }
+      else {
+        region = getCache().getRegion(REGION_NAME);
+      }
+      assertNotNull(region);
+
+    }
+    catch (Exception ex) {
+      if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when executing function: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when executing function", ex);
+      }
+    }
+
+    try {
+      FunctionService.registerFunction(function);
+      Execution execution = null;
+
+      if ("region".equals(method)) {
+        execution = FunctionService.onRegion(region);
+
+      }
+      else if ("server".equals(method)) {
+        if (multiUserAuthMode) {
+          execution = FunctionService.onServer(proxyCaches[multiUserIndex]);
+        }
+        else {
+          execution = FunctionService.onServer(pool);
+        }
+
+      }
+      else { // if ("servers".equals(method)) {
+        if (multiUserAuthMode) {
+          execution = FunctionService.onServers(proxyCaches[multiUserIndex]);
+        }
+        else {
+          execution = FunctionService.onServers(pool);
+        }
+      }
+
+      execution.execute(function.getId());
+      if (expectedResult != NO_EXCEPTION) {
+        fail("Expected a NotAuthorizedException while executing function");
+      }
+
+    }
+    catch (NoAvailableServersException ex) {
+      if (expectedResult == NO_AVAILABLE_SERVERS) {
+        getLogWriter().info("Got expected NoAvailableServers when executing function: " + ex.getCause());
+      }
+      else {
+        fail("Got unexpected exception when executing function", ex);
+      }
+
+    }
+    catch (ServerConnectivityException ex) {
+      if ((expectedResult == NOTAUTHZ_EXCEPTION) && (ex.getCause() instanceof NotAuthorizedException)) {
+        getLogWriter().info("Got expected NotAuthorizedException when executing function: " + ex.getCause());
+      }
+      else if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when executing function: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when executing function", ex);
+      }
+
+    }
+    catch (FunctionException ex) {
+      // if NOTAUTHZ_EXCEPTION AND (cause is NotAuthorizedException OR (cause is ServerOperationException AND cause.cause is NotAuthorizedException))
+      if (expectedResult == NOTAUTHZ_EXCEPTION && (ex.getCause() instanceof NotAuthorizedException || (ex.getCause() instanceof ServerOperationException && ex
+        .getCause().getCause() instanceof NotAuthorizedException))) {
+        getLogWriter().info("Got expected NotAuthorizedException when executing function: " + ex.getCause());
+      }
+      else if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when executing function: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when executing function", ex);
+      }
+
+    }
+    catch (Exception ex) {
+      if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when executing function: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when executing function", ex);
+      }
+    }
+  }
+
+  private static void doQueriesP(final int multiUserIndex, final int expectedResult, final int expectedValue) {
+    Region region = null;
+    try {
+      if (multiUserAuthMode) {
+        region = proxyCaches[multiUserIndex].getRegion(REGION_NAME);
+      }
+      else {
+        region = getCache().getRegion(REGION_NAME);
+      }
+      assertNotNull(region);
+
+    }
+    catch (Exception ex) {
+      if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when doing queries: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when doing queries", ex);
+      }
+    }
+
+    String queryStr = "SELECT DISTINCT * FROM " + region.getFullPath();
+    try {
+      SelectResults queryResults = region.query(queryStr);
+      Set resultSet = queryResults.asSet();
+      assertEquals(expectedValue, resultSet.size());
+      if (expectedResult != NO_EXCEPTION) {
+        fail("Expected a NotAuthorizedException while doing queries");
+      }
+
+    }
+    catch (NoAvailableServersException ex) {
+      if (expectedResult == NO_AVAILABLE_SERVERS) {
+        getLogWriter().info("Got expected NoAvailableServers when doing queries: " + ex.getCause());
+      }
+      else {
+        fail("Got unexpected exception when doing queries", ex);
+      }
+
+    }
+    catch (ServerConnectivityException ex) {
+      if ((expectedResult == NOTAUTHZ_EXCEPTION) && (ex.getCause() instanceof NotAuthorizedException)) {
+        getLogWriter().info("Got expected NotAuthorizedException when doing queries: " + ex.getCause());
+      }
+      else if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when doing queries: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when doing queries", ex);
+      }
+
+    }
+    catch (QueryInvocationTargetException qite) {
+      if ((expectedResult == NOTAUTHZ_EXCEPTION) && (qite.getCause() instanceof NotAuthorizedException)) {
+        getLogWriter().info("Got expected NotAuthorizedException when doing queries: " + qite.getCause());
+      }
+      else if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when doing queries: " + qite);
+      }
+      else {
+        fail("Got unexpected exception when doing queries", qite);
+      }
+
+    }
+    catch (Exception ex) {
+      if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when doing queries: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when doing queries", ex);
+      }
+    }
+  }
+
+  private static void doContainsKeysP(final int num, final int multiUserIndex, final int expectedResult, final boolean expectedValue) {
+    assertTrue(num <= KEYS.length);
+
+    Region region = null;
+    try {
+      if (multiUserAuthMode) {
+        region = proxyCaches[multiUserIndex].getRegion(REGION_NAME);
+      }
+      else {
+        region = getCache().getRegion(REGION_NAME);
+      }
+      assertNotNull(region);
+
+    }
+    catch (Exception ex) {
+      if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when doing containsKey: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when doing containsKey", ex);
+      }
+    }
+
+    for (int index = 0; index < num; ++index) {
+      boolean result = false;
+
+      try {
+        result = region.containsKeyOnServer(KEYS[index]);
+        if (expectedResult != NO_EXCEPTION) {
+          fail("Expected a NotAuthorizedException while doing containsKey");
+        }
+
+      }
+      catch (NoAvailableServersException ex) {
+        if (expectedResult == NO_AVAILABLE_SERVERS) {
+          getLogWriter().info("Got expected NoAvailableServers when doing containsKey: " + ex.getCause());
+          continue;
+        }
+        else {
+          fail("Got unexpected exception when doing containsKey", ex);
+        }
+
+      }
+      catch (ServerConnectivityException ex) {
+        if ((expectedResult == NOTAUTHZ_EXCEPTION) && (ex.getCause() instanceof NotAuthorizedException)) {
+          getLogWriter().info("Got expected NotAuthorizedException when doing containsKey: " + ex.getCause());
+          continue;
+        }
+        else if (expectedResult == OTHER_EXCEPTION) {
+          getLogWriter().info("Got expected exception when doing containsKey: " + ex);
+        }
+        else {
+          fail("Got unexpected exception when doing containsKey", ex);
+        }
+
+      }
+      catch (Exception ex) {
+        if (expectedResult == OTHER_EXCEPTION) {
+          getLogWriter().info("Got expected exception when doing containsKey: " + ex);
+        }
+        else {
+          fail("Got unexpected exception when doing containsKey", ex);
+        }
+      }
+
+      assertEquals(expectedValue, result);
+    }
+  }
+
+  private static void doInvalidatesP(final int num, final int multiUserIndex, final int expectedResult) {
+    assertTrue(num <= KEYS.length);
+
+    Region region = null;
+    try {
+      if (multiUserAuthMode) {
+        region = proxyCaches[multiUserIndex].getRegion(REGION_NAME);
+      }
+      else {
+        region = getCache().getRegion(REGION_NAME);
+      }
+      assertNotNull(region);
+
+    }
+    catch (Exception ex) {
+      if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when doing invalidates: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when doing invalidates", ex);
+      }
+    }
+
+    for (int index = 0; index < num; ++index) {
+      try {
+        region.invalidate(KEYS[index]);
+        if (expectedResult != NO_EXCEPTION) {
+          fail("Expected a NotAuthorizedException while doing invalidates");
+        }
+
+      }
+      catch (NoAvailableServersException ex) {
+        if (expectedResult == NO_AVAILABLE_SERVERS) {
+          getLogWriter().info("Got expected NoAvailableServers when doing invalidates: " + ex.getCause());
+          continue;
+        }
+        else {
+          fail("Got unexpected exception when doing invalidates", ex);
+        }
+
+      }
+      catch (ServerConnectivityException ex) {
+        if ((expectedResult == NOTAUTHZ_EXCEPTION) && (ex.getCause() instanceof NotAuthorizedException)) {
+          getLogWriter().info("Got expected NotAuthorizedException when doing invalidates: " + ex.getCause());
+          continue;
+        }
+        else if (expectedResult == OTHER_EXCEPTION) {
+          getLogWriter().info("Got expected exception when doing invalidates: " + ex);
+        }
+        else {
+          fail("Got unexpected exception when doing invalidates", ex);
+        }
+
+      }
+      catch (Exception ex) {
+        if (expectedResult == OTHER_EXCEPTION) {
+          getLogWriter().info("Got expected exception when doing invalidates: " + ex);
+        }
+        else {
+          fail("Got unexpected exception when doing invalidates", ex);
+        }
+      }
+    }
+  }
+
+  private static void doDestroysP(final int num, final int multiUserIndex, final int expectedResult) {
+    assertTrue(num <= KEYS.length);
+
+    Region region = null;
+    try {
+      if (multiUserAuthMode) {
+        region = proxyCaches[multiUserIndex].getRegion(REGION_NAME);
+      }
+      else {
+        region = getCache().getRegion(REGION_NAME);
+      }
+      assertNotNull(region);
+
+    }
+    catch (Exception ex) {
+      if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when doing destroys: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when doing destroys", ex);
+      }
+    }
+
+    for (int index = 0; index < num; ++index) {
+      try {
+        region.destroy(KEYS[index]);
+        if (expectedResult != NO_EXCEPTION) {
+          fail("Expected a NotAuthorizedException while doing destroys");
+        }
+
+      }
+      catch (NoAvailableServersException ex) {
+        if (expectedResult == NO_AVAILABLE_SERVERS) {
+          getLogWriter().info("Got expected NoAvailableServers when doing destroys: " + ex.getCause());
+          continue;
+        }
+        else {
+          fail("Got unexpected exception when doing destroys", ex);
+        }
+
+      }
+      catch (ServerConnectivityException ex) {
+        if ((expectedResult == NOTAUTHZ_EXCEPTION) && (ex.getCause() instanceof NotAuthorizedException)) {
+          getLogWriter().info("Got expected NotAuthorizedException when doing destroys: " + ex.getCause());
+          continue;
+        }
+        else if (expectedResult == OTHER_EXCEPTION) {
+          getLogWriter().info("Got expected exception when doing destroys: " + ex);
+        }
+        else {
+          fail("Got unexpected exception when doing destroys", ex);
+        }
+
+      }
+      catch (Exception ex) {
+        if (expectedResult == OTHER_EXCEPTION) {
+          getLogWriter().info("Got expected exception when doing destroys: " + ex);
+        }
+        else {
+          fail("Got unexpected exception when doing destroys", ex);
+        }
+      }
+    }
+  }
+
+  private static void doRegionDestroysP(final int multiUserIndex, final int expectedResult) {
+    Region region = null;
+    try {
+      if (multiUserAuthMode) {
+        region = proxyCaches[multiUserIndex].getRegion(REGION_NAME);
+      }
+      else {
+        region = getCache().getRegion(REGION_NAME);
+      }
+      assertNotNull(region);
+
+    }
+    catch (Exception ex) {
+      if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when doing region destroy: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when doing region destroy", ex);
+      }
+    }
+
+    try {
+      region.destroyRegion();
+      if (expectedResult != NO_EXCEPTION) {
+        fail("Expected a NotAuthorizedException while doing region destroy");
+      }
+
+      if (multiUserAuthMode) {
+        region = proxyCaches[multiUserIndex].getRegion(REGION_NAME);
+      }
+      else {
+        region = getCache().getRegion(REGION_NAME);
+      }
+      assertNull(region);
+
+    }
+    catch (NoAvailableServersException ex) {
+      if (expectedResult == NO_AVAILABLE_SERVERS) {
+        getLogWriter().info("Got expected NoAvailableServers when doing region destroy: " + ex.getCause());
+      }
+      else {
+        fail("Got unexpected exception when doing region destroy", ex);
+      }
+
+    }
+    catch (ServerConnectivityException ex) {
+      if ((expectedResult == NOTAUTHZ_EXCEPTION) && (ex.getCause() instanceof NotAuthorizedException)) {
+        getLogWriter().info("Got expected NotAuthorizedException when doing region destroy: " + ex.getCause());
+      }
+      else if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when doing region destroy: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when doing region destroy", ex);
+      }
+
+    }
+    catch (Exception ex) {
+      if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when doing region destroy: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when doing region destroy", ex);
+      }
+    }
+  }
+
+  private static void doLocalGetsP(final int num, final boolean checkNVals) {
+    assertTrue(num <= KEYS.length);
+
+    String[] vals = VALUES;
+    if (checkNVals) {
+      vals = NVALUES;
+    }
+
+    final Region region = getCache().getRegion(REGION_NAME);
+    assertNotNull(region);
+
+    for (int index = 0; index < num; ++index) {
+      final String key = KEYS[index];
+      final String expectedVal = vals[index];
+      waitForCondition(() -> expectedVal.equals(getLocalValue(region, key)), 1000, 30 / num);
+    }
+
+    for (int index = 0; index < num; ++index) {
+      Region.Entry entry = region.getEntry(KEYS[index]);
+      assertNotNull(entry);
+      assertEquals(vals[index], entry.getValue());
+    }
+  }
+
+  private static void doGetAllP(final int multiUserIndex, final int expectedResult, final boolean useTX) {
+    Region region = null;
+    try {
+      if (multiUserAuthMode) {
+        region = proxyCaches[multiUserIndex].getRegion(REGION_NAME);
+      }
+      else {
+        region = getCache().getRegion(REGION_NAME);
+      }
+      assertNotNull(region);
+
+    }
+    catch (Exception ex) {
+      if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when doing getAll: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when doing getAll", ex);
+      }
+    }
+
+    try {
+      List keys = new ArrayList();
+      keys.add("key1");
+      keys.add("key2");
+
+      if (useTX) {
+        getCache().getCacheTransactionManager().begin();
+      }
+
+      Map entries = region.getAll(keys);
+
+      // Also check getEntry()
+      region.getEntry("key1");
+
+      if (useTX) {
+        getCache().getCacheTransactionManager().commit();
+      }
+
+      assertNotNull(entries);
+
+      if ((expectedResult == NOTAUTHZ_EXCEPTION)) {
+        assertEquals(0, entries.size());
+      }
+      else if ((expectedResult == NO_EXCEPTION)) {
+        assertEquals(2, entries.size());
+        assertEquals("value1", entries.get("key1"));
+        assertEquals("value2", entries.get("key2"));
+      }
+
+    }
+    catch (NoAvailableServersException ex) {
+      if (expectedResult == NO_AVAILABLE_SERVERS) {
+        getLogWriter().info("Got expected NoAvailableServers when doing getAll: " + ex.getCause());
+      }
+      else {
+        fail("Got unexpected exception when doing getAll", ex);
+      }
+
+    }
+    catch (ServerConnectivityException ex) {
+      if ((expectedResult == NOTAUTHZ_EXCEPTION) && (ex.getCause() instanceof NotAuthorizedException)) {
+        getLogWriter().info("Got expected NotAuthorizedException when doing getAll: " + ex.getCause());
+      }
+      else if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when doing getAll: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when doing getAll", ex);
+      }
+
+    }
+    catch (Exception ex) {
+      if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when doing getAll: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when doing getAll", ex);
+      }
+    }
+  }
+
+  private static void doGetsP(final int num, final int expectedResult, final boolean newVals) {
+    doGetsP(num, 0, expectedResult, newVals);
+  }
+
+  private static void doGetsP(final int num, final int multiUserIndex, final int expectedResult, final boolean newVals) {
+    assertTrue(num <= KEYS.length);
+
+    Region region = null;
+    try {
+      if (multiUserAuthMode) {
+        region = proxyCaches[multiUserIndex].getRegion(REGION_NAME);
+      }
+      else {
+        region = getCache().getRegion(REGION_NAME);
+      }
+      assertNotNull(region);
+
+    }
+    catch (Exception ex) {
+      if (expectedResult == OTHER_EXCEPTION) {
+        getLogWriter().info("Got expected exception when doing gets: " + ex);
+      }
+      else {
+        fail("Got unexpected exception when doing gets", ex);
+      }
+    }
+
+    for (int index = 0; index < num; ++index) {
+      Object value = null;
+      try {
+
+        try {
+          region.localInvalidate(KEYS[index]);
+        }
+        catch (Exception ex) {
+        }
+
+        value = region.get(KEYS[index]);
+        if (expectedResult != NO_EXCEPTION) {
+          fail("Expected a NotAuthorizedException while doing gets");
+        }
+
+      }
+      catch (NoAvailableServersException ex) {
+        if (expectedResult == NO_AVAILABLE_SERVERS) {
+          getLogWriter().info("Got expected NoAvailableServers when doing gets: " + ex.getCause());
+          continue;
+        }
+        else {
+          fail("Got unexpected exception when doing gets", ex);
+        }
+
+      }
+      catch (ServerConnectivityException ex) {
+        if ((expectedResult == NOTAUTHZ_EXCEPTION) && (ex.getCause() instanceof NotAuthorizedException)) {
+          getLogWriter().info("Got expected NotAuthorizedException when doing gets: " + ex.getCause());
+          continue;
+        }
+        else if (expectedResult == OTHER_EXCEPTION) {
+          getLogWriter().info("Got expected exception when doing gets: " + ex);
+        }
+        else {
+          fail("Got unexpected exception when doing gets", ex);
+        }
+
+      }
+      catch (Exception ex) {
+        if (expectedResult == OTHER_EXCEPTION) {
+          getLogWriter().info("Got expected exception when doing gets: " + ex);
+        }
+        else {
+          fail("Got unexpected exception when doing gets", ex);
+        }
+      }
+
+      assertNotNull(value);
+
+      if (newVals) {
+        assertEquals(NVALUES[index], value);
+      }
+      else {
+        assertEquals(VALUES[index], value);
+      }
+    }
+  }
+
+  // ----------------------------- member methods -----------------------------
+
+  public DistributedSystem createSystem(final Properties sysProps, final Properties javaProps) {
+    closeCache();
+    clearStaticSSLContext();
+    setJavaProps(javaProps);
+
+    DistributedSystem dsys = distributedTestCase.getSystem(sysProps);
+    assertNotNull(dsys);
+    addIgnoredExceptions(ignoredExceptions);
+    return dsys;
+  }
+
+  private void openCache() {
+    assertNotNull(distributedTestCase.basicGetSystem());
+    assertTrue(distributedTestCase.basicGetSystem().isConnected());
+    cache = CacheFactory.create(distributedTestCase.basicGetSystem());
+    assertNotNull(cache);
+  }
+
+  // ------------------------------- inner classes ----------------------------
+
+  private static class Employee implements PdxSerializable {
+
+    private Long Id;
+    private String fname;
+    private String lname;
+
+    public Employee() {
+    }
+
+    public Employee(Long id, String fn, String ln) {
+      this.Id = id;
+      this.fname = fn;
+      this.lname = ln;
+    }
+
+    /**
+     * For test purpose, to make sure
+     * the object is not deserialized
+     */
+    @Override
+    public void fromData(PdxReader in) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void toData(PdxWriter out) {
+      out.writeLong("Id", Id);
+      out.writeString("fname", fname);
+      out.writeString("lname", lname);
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/9d7a6960/geode-core/src/test/java/org/apache/geode/security/SpySecurityManager.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/org/apache/geode/security/SpySecurityManager.java b/geode-core/src/test/java/org/apache/geode/security/SpySecurityManager.java
new file mode 100644
index 0000000..91d25f0
--- /dev/null
+++ b/geode-core/src/test/java/org/apache/geode/security/SpySecurityManager.java
@@ -0,0 +1,42 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.gemstone.gemfire.security;
+
+import java.util.Properties;
+
+import org.apache.geode.security.SecurityManager;
+
+public class SpySecurityManager implements SecurityManager {
+
+  public int initInvoked = 0;
+  public int closeInvoked = 0;
+
+  @Override
+  public void init(final Properties securityProps) {
+    initInvoked++;
+  }
+
+  @Override
+  public Object authenticate(final Properties props) throws AuthenticationFailedException {
+    return null;
+  }
+
+  @Override
+  public void close() {
+    closeInvoked++;
+  }
+}