geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jensde...@apache.org
Subject [11/33] incubator-geode git commit: GEM-164: move the security tests in gemfire-test module inside the com.gemstone.gemfire.security packages to the open side.
Date Wed, 30 Dec 2015 00:28:11 GMT
GEM-164: move the security tests in gemfire-test module inside the com.gemstone.gemfire.security packages to the open side.

GEM-164: remove the pivotal license header

GEM-164: add ASF license headers and have RAT ignore all subprojects' IDE files when checking license

GEM-164: remove the duplicate license


Project: http://git-wip-us.apache.org/repos/asf/incubator-geode/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-geode/commit/a622d6ec
Tree: http://git-wip-us.apache.org/repos/asf/incubator-geode/tree/a622d6ec
Diff: http://git-wip-us.apache.org/repos/asf/incubator-geode/diff/a622d6ec

Branch: refs/heads/feature/GEODE-14
Commit: a622d6ec7f8228443bb99249e08766bd74337c10
Parents: 51ce64d
Author: Jinmei Liao <jiliao@pivotal.io>
Authored: Thu Dec 10 15:14:19 2015 -0800
Committer: Jens Deppe <jdeppe@pivotal.io>
Committed: Mon Dec 21 08:51:59 2015 -0800

----------------------------------------------------------------------
 .../security/ClientAuthenticationDUnitTest.java |  969 +++++++++
 .../ClientAuthenticationPart2DUnitTest.java     |   88 +
 .../security/ClientAuthorizationDUnitTest.java  |  798 ++++++++
 .../security/ClientAuthorizationTestBase.java   | 1384 +++++++++++++
 .../security/ClientMultiUserAuthzDUnitTest.java |  537 +++++
 .../DeltaClientAuthorizationDUnitTest.java      |  336 ++++
 .../DeltaClientPostAuthorizationDUnitTest.java  |  541 +++++
 .../security/P2PAuthenticationDUnitTest.java    |  622 ++++++
 .../gemfire/security/SecurityTestUtil.java      | 1871 ++++++++++++++++++
 .../security/AuthzCredentialGenerator.java      |  465 +++++
 .../templates/security/CredentialGenerator.java |  343 ++++
 .../security/DummyAuthzCredentialGenerator.java |  142 ++
 .../security/DummyCredentialGenerator.java      |   90 +
 .../security/LdapUserCredentialGenerator.java   |  158 ++
 .../security/PKCSCredentialGenerator.java       |  110 +
 .../security/SSLCredentialGenerator.java        |  116 ++
 .../UserPasswordWithExtraPropsAuthInit.java     |   76 +
 .../security/XmlAuthzCredentialGenerator.java   |  262 +++
 .../src/test/resources/lib/authz-dummy.xml      |  126 ++
 .../src/test/resources/lib/authz-ldap.xml       |   85 +
 .../resources/lib/authz-multiUser-dummy.xml     |  106 +
 .../test/resources/lib/authz-multiUser-ldap.xml |   83 +
 .../test/resources/lib/keys/gemfire1.keystore   |  Bin 0 -> 1536 bytes
 .../test/resources/lib/keys/gemfire10.keystore  |  Bin 0 -> 1546 bytes
 .../test/resources/lib/keys/gemfire11.keystore  |  Bin 0 -> 1546 bytes
 .../test/resources/lib/keys/gemfire2.keystore   |  Bin 0 -> 1536 bytes
 .../test/resources/lib/keys/gemfire3.keystore   |  Bin 0 -> 1536 bytes
 .../test/resources/lib/keys/gemfire4.keystore   |  Bin 0 -> 1536 bytes
 .../test/resources/lib/keys/gemfire5.keystore   |  Bin 0 -> 1536 bytes
 .../test/resources/lib/keys/gemfire6.keystore   |  Bin 0 -> 1536 bytes
 .../test/resources/lib/keys/gemfire7.keystore   |  Bin 0 -> 1536 bytes
 .../test/resources/lib/keys/gemfire8.keystore   |  Bin 0 -> 1536 bytes
 .../test/resources/lib/keys/gemfire9.keystore   |  Bin 0 -> 1536 bytes
 .../resources/lib/keys/ibm/gemfire1.keystore    |  Bin 0 -> 1426 bytes
 .../resources/lib/keys/ibm/gemfire10.keystore   |  Bin 0 -> 1434 bytes
 .../resources/lib/keys/ibm/gemfire11.keystore   |  Bin 0 -> 1434 bytes
 .../resources/lib/keys/ibm/gemfire2.keystore    |  Bin 0 -> 1434 bytes
 .../resources/lib/keys/ibm/gemfire3.keystore    |  Bin 0 -> 1426 bytes
 .../resources/lib/keys/ibm/gemfire4.keystore    |  Bin 0 -> 1434 bytes
 .../resources/lib/keys/ibm/gemfire5.keystore    |  Bin 0 -> 1434 bytes
 .../resources/lib/keys/ibm/gemfire6.keystore    |  Bin 0 -> 1434 bytes
 .../resources/lib/keys/ibm/gemfire7.keystore    |  Bin 0 -> 1426 bytes
 .../resources/lib/keys/ibm/gemfire8.keystore    |  Bin 0 -> 1434 bytes
 .../resources/lib/keys/ibm/gemfire9.keystore    |  Bin 0 -> 1426 bytes
 .../test/resources/lib/keys/ibm/publickeyfile   |  Bin 0 -> 4535 bytes
 .../src/test/resources/lib/keys/publickeyfile   |  Bin 0 -> 4535 bytes
 .../src/test/resources/ssl/untrusted.keystore   |  Bin 0 -> 1181 bytes
 gradle/rat.gradle                               |    2 +-
 48 files changed, 9309 insertions(+), 1 deletion(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/a622d6ec/gemfire-core/src/test/java/com/gemstone/gemfire/security/ClientAuthenticationDUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/security/ClientAuthenticationDUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/security/ClientAuthenticationDUnitTest.java
new file mode 100644
index 0000000..2fdbc05
--- /dev/null
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/security/ClientAuthenticationDUnitTest.java
@@ -0,0 +1,969 @@
+package com.gemstone.gemfire.security;
+
+/*
+ * 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.
+ */
+
+
+import java.io.IOException;
+import java.util.Properties;
+
+import javax.net.ssl.SSLException;
+import javax.net.ssl.SSLHandshakeException;
+
+import templates.security.CredentialGenerator;
+import templates.security.CredentialGenerator.ClassCode;
+
+import com.gemstone.gemfire.cache.Region;
+import com.gemstone.gemfire.distributed.internal.DistributionConfig;
+import com.gemstone.gemfire.internal.AvailablePort;
+
+import dunit.DistributedTestCase;
+import dunit.Host;
+import dunit.VM;
+import templates.security.DummyCredentialGenerator;
+
+/**
+ * Test for authentication from client to server. This tests for both valid and
+ * invalid credentials/modules. It also checks for authentication
+ * success/failure in case of failover and for the notification channel.
+ * 
+ * @author sumedh
+ * @since 5.5
+ */
+public class ClientAuthenticationDUnitTest extends DistributedTestCase {
+
+  /** constructor */
+  public ClientAuthenticationDUnitTest(String name) {
+    super(name);
+  }
+
+  private VM server1 = null;
+
+  private VM server2 = null;
+
+  private VM client1 = null;
+
+  private VM client2 = null;
+
+  private static final String[] serverExpectedExceptions = {
+      AuthenticationRequiredException.class.getName(),
+      AuthenticationFailedException.class.getName(),
+      GemFireSecurityException.class.getName(),
+      ClassNotFoundException.class.getName(), IOException.class.getName(),
+      SSLException.class.getName(), SSLHandshakeException.class.getName() };
+
+  private static final String[] clientExpectedExceptions = {
+      AuthenticationRequiredException.class.getName(),
+      AuthenticationFailedException.class.getName(),
+      SSLHandshakeException.class.getName() };
+
+  @Override
+  public void setUp() throws Exception {
+
+    super.setUp();
+    final Host host = Host.getHost(0);
+    server1 = host.getVM(0);
+    server2 = host.getVM(1);
+    client1 = host.getVM(2);
+    client2 = host.getVM(3);
+    
+    addExpectedException("Connection refused: connect");
+
+    server1.invoke(SecurityTestUtil.class, "registerExpectedExceptions",
+        new Object[] { serverExpectedExceptions });
+    server2.invoke(SecurityTestUtil.class, "registerExpectedExceptions",
+        new Object[] { serverExpectedExceptions });
+    client1.invoke(SecurityTestUtil.class, "registerExpectedExceptions",
+        new Object[] { clientExpectedExceptions });
+    client2.invoke(SecurityTestUtil.class, "registerExpectedExceptions",
+        new Object[] { clientExpectedExceptions });
+  }
+
+  // Region: Utility and static functions invoked by the tests
+
+  public static Integer createCacheServer(Object dsPort, Object locatorString,
+      Object authenticator, Object extraProps, Object javaProps) {
+
+    Properties authProps;
+    if (extraProps == null) {
+      authProps = new Properties();
+    }
+    else {
+      authProps = (Properties)extraProps;
+    }
+    if (authenticator != null) {
+      authProps.setProperty(
+          DistributionConfig.SECURITY_CLIENT_AUTHENTICATOR_NAME, authenticator
+              .toString());
+    }
+    return SecurityTestUtil.createCacheServer(authProps, javaProps,
+        (Integer)dsPort, (String)locatorString, null, new Integer(
+            SecurityTestUtil.NO_EXCEPTION));
+  }
+
+  public static void createCacheServer(Object dsPort, Object locatorString,
+      Integer serverPort, Object authenticator, Object extraProps,
+      Object javaProps) {
+
+    Properties authProps;
+    if (extraProps == null) {
+      authProps = new Properties();
+    }
+    else {
+      authProps = (Properties)extraProps;
+    }
+    if (authenticator != null) {
+      authProps.setProperty(
+          DistributionConfig.SECURITY_CLIENT_AUTHENTICATOR_NAME, authenticator
+              .toString());
+    }
+    SecurityTestUtil.createCacheServer(authProps, javaProps, (Integer)dsPort,
+        (String)locatorString, serverPort, new Integer(
+            SecurityTestUtil.NO_EXCEPTION));
+  }
+
+  private static void createCacheClient(Object authInit, Properties authProps,
+      Properties javaProps, Integer[] ports, Object numConnections,
+      Boolean multiUserMode, Boolean subscriptionEnabled, Integer expectedResult) {
+
+    String authInitStr = (authInit == null ? null : authInit.toString());
+    SecurityTestUtil.createCacheClient(authInitStr, authProps, javaProps,
+        ports, (Integer)numConnections, Boolean.FALSE,
+        multiUserMode.toString(), subscriptionEnabled, expectedResult);
+  }
+
+  public static void createCacheClient(Object authInit, Object authProps,
+      Object javaProps, Integer[] ports, Object numConnections,
+      Boolean multiUserMode, Integer expectedResult) {
+
+    createCacheClient(authInit, (Properties)authProps, (Properties)javaProps,
+        ports, numConnections, multiUserMode, Boolean.TRUE, expectedResult);
+  }
+
+  public static void createCacheClient(Object authInit, Object authProps,
+      Object javaProps, Integer port1, Object numConnections,
+      Integer expectedResult) {
+
+    createCacheClient(authInit, (Properties)authProps, (Properties)javaProps,
+        new Integer[] { port1 }, numConnections, Boolean.FALSE, Boolean.TRUE,
+        expectedResult);
+  }
+
+  public static void createCacheClient(Object authInit, Object authProps,
+      Object javaProps, Integer port1, Integer port2, Object numConnections,
+      Integer expectedResult) {
+    createCacheClient(authInit, authProps, javaProps, port1, port2,
+        numConnections, Boolean.FALSE, expectedResult);
+  }
+
+  public static void createCacheClient(Object authInit, Object authProps,
+      Object javaProps, Integer port1, Integer port2, Object numConnections,
+      Boolean multiUserMode, Integer expectedResult) {
+
+    createCacheClient(authInit, authProps, javaProps,
+        port1, port2, numConnections, multiUserMode, Boolean.TRUE,
+        expectedResult);
+  }
+
+  public static void createCacheClient(Object authInit, Object authProps,
+      Object javaProps, Integer port1, Integer port2, Object numConnections,
+      Boolean multiUserMode, Boolean subscriptionEnabled,
+      Integer expectedResult) {
+
+    createCacheClient(authInit, (Properties)authProps, (Properties)javaProps,
+        new Integer[] { port1, port2 }, numConnections, multiUserMode,
+        subscriptionEnabled, expectedResult);
+  }
+
+  public static void registerAllInterest() {
+
+    Region region = SecurityTestUtil.getCache().getRegion(
+        SecurityTestUtil.regionName);
+    assertNotNull(region);
+    region.registerInterestRegex(".*");
+  }
+
+  // End Region: Utility and static functions invoked by the tests
+
+  // Region: Tests
+
+  public void testValidCredentials() {
+    itestValidCredentials(Boolean.FALSE);
+  }
+
+  public void itestValidCredentials(Boolean multiUser) {
+      CredentialGenerator gen = new DummyCredentialGenerator();
+      Properties extraProps = gen.getSystemProperties();
+      Properties javaProps = gen.getJavaProperties();
+      String authenticator = gen.getAuthenticator();
+      String authInit = gen.getAuthInit();
+
+      getLogWriter().info(
+          "testValidCredentials: Using scheme: " + gen.classCode());
+      getLogWriter().info(
+          "testValidCredentials: Using authenticator: " + authenticator);
+      getLogWriter().info("testValidCredentials: Using authinit: " + authInit);
+
+      // Start the servers
+      Integer locPort1 = SecurityTestUtil.getLocatorPort();
+      Integer locPort2 = SecurityTestUtil.getLocatorPort();
+      String locString = SecurityTestUtil.getLocatorString();
+      Integer port1 = (Integer)server1.invoke(
+          ClientAuthenticationDUnitTest.class, "createCacheServer",
+          new Object[] { locPort1, locString, authenticator, extraProps,
+              javaProps });
+      Integer port2 = (Integer)server2.invoke(
+          ClientAuthenticationDUnitTest.class, "createCacheServer",
+          new Object[] { locPort2, locString, authenticator, extraProps,
+              javaProps });
+
+      // Start the clients with valid credentials
+      Properties credentials1 = gen.getValidCredentials(1);
+      Properties javaProps1 = gen.getJavaProperties();
+      getLogWriter().info(
+          "testValidCredentials: For first client credentials: " + credentials1
+              + " : " + javaProps1);
+      Properties credentials2 = gen.getValidCredentials(2);
+      Properties javaProps2 = gen.getJavaProperties();
+      getLogWriter().info(
+          "testValidCredentials: For second client credentials: "
+              + credentials2 + " : " + javaProps2);
+      client1.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { authInit, credentials1, javaProps1, port1, port2,
+              null, multiUser, new Integer(SecurityTestUtil.NO_EXCEPTION) });
+      client2.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { authInit, credentials2, javaProps2, port1, port2,
+              null, multiUser, new Integer(SecurityTestUtil.NO_EXCEPTION) });
+
+      // Perform some put operations from client1
+      client1.invoke(SecurityTestUtil.class, "doPuts",
+          new Object[] { new Integer(2) });
+
+      // Verify that the puts succeeded
+      client2.invoke(SecurityTestUtil.class, "doGets",
+          new Object[] { new Integer(2) });
+      
+      if (multiUser) {
+        client1.invoke(SecurityTestUtil.class, "doProxyCacheClose");
+        client2.invoke(SecurityTestUtil.class, "doProxyCacheClose");
+        client1.invoke(SecurityTestUtil.class, "doSimplePut",
+            new Object[] {"CacheClosedException"});
+        client2.invoke(SecurityTestUtil.class, "doSimpleGet",
+            new Object[] {"CacheClosedException"});
+      }
+  }
+
+  public void testNoCredentials() {
+    itestNoCredentials(Boolean.FALSE);
+  }
+
+  public void itestNoCredentials(Boolean multiUser) {
+      CredentialGenerator gen = new DummyCredentialGenerator();
+      Properties extraProps = gen.getSystemProperties();
+      Properties javaProps = gen.getJavaProperties();
+      String authenticator = gen.getAuthenticator();
+      String authInit = gen.getAuthInit();
+
+      getLogWriter()
+          .info("testNoCredentials: Using scheme: " + gen.classCode());
+      getLogWriter().info(
+          "testNoCredentials: Using authenticator: " + authenticator);
+      getLogWriter().info("testNoCredentials: Using authinit: " + authInit);
+
+      // Start the servers
+      Integer locPort1 = SecurityTestUtil.getLocatorPort();
+      Integer locPort2 = SecurityTestUtil.getLocatorPort();
+      String locString = SecurityTestUtil.getLocatorString();
+      Integer port1 = ((Integer)server1.invoke(
+          ClientAuthenticationDUnitTest.class, "createCacheServer",
+          new Object[] { locPort1, locString, authenticator, extraProps,
+              javaProps }));
+      Integer port2 = ((Integer)server2.invoke(
+          ClientAuthenticationDUnitTest.class, "createCacheServer",
+          new Object[] { locPort2, locString, authenticator, extraProps,
+              javaProps }));
+
+      // Start first client with valid credentials
+      Properties credentials1 = gen.getValidCredentials(1);
+      Properties javaProps1 = gen.getJavaProperties();
+      getLogWriter().info(
+          "testNoCredentials: For first client credentials: " + credentials1
+              + " : " + javaProps1);
+      client1.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { authInit, credentials1, javaProps1, port1, port2,
+              null, multiUser, new Integer(SecurityTestUtil.NO_EXCEPTION) });
+
+      // Perform some put operations from client1
+      client1.invoke(SecurityTestUtil.class, "doPuts",
+          new Object[] { new Integer(2) });
+
+      // Trying to create the region on client2 
+      if (gen.classCode().equals(ClassCode.SSL)) {
+        // For SSL the exception may not come since the server can close socket
+        // before handshake message is sent from client. However exception
+        // should come in any region operations.
+        client2
+            .invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+                new Object[] { null, null, null, port1, port2, null, multiUser,
+                    new Integer(SecurityTestUtil.NO_EXCEPTION) });
+        client2.invoke(SecurityTestUtil.class, "doPuts", new Object[] {
+            new Integer(2), new Integer(SecurityTestUtil.OTHER_EXCEPTION) });
+      }
+      else {
+        client2.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheClient", new Object[] { null, null, null, port1, port2,
+                null, multiUser, new Integer(SecurityTestUtil.AUTHREQ_EXCEPTION) });
+      }
+  }
+
+  public void testInvalidCredentials() {
+    itestInvalidCredentials(Boolean.FALSE);
+  }
+
+  public void itestInvalidCredentials(Boolean multiUser) {
+
+
+      CredentialGenerator gen = new DummyCredentialGenerator();
+      Properties extraProps = gen.getSystemProperties();
+      Properties javaProps = gen.getJavaProperties();
+      String authenticator = gen.getAuthenticator();
+      String authInit = gen.getAuthInit();
+
+      getLogWriter().info(
+          "testInvalidCredentials: Using scheme: " + gen.classCode());
+      getLogWriter().info(
+          "testInvalidCredentials: Using authenticator: " + authenticator);
+      getLogWriter()
+          .info("testInvalidCredentials: Using authinit: " + authInit);
+
+      // Start the servers
+      Integer locPort1 = SecurityTestUtil.getLocatorPort();
+      Integer locPort2 = SecurityTestUtil.getLocatorPort();
+      String locString = SecurityTestUtil.getLocatorString();
+      Integer port1 = ((Integer)server1.invoke(
+          ClientAuthenticationDUnitTest.class, "createCacheServer",
+          new Object[] { locPort1, locString, authenticator, extraProps,
+              javaProps }));
+      Integer port2 = ((Integer)server2.invoke(
+          ClientAuthenticationDUnitTest.class, "createCacheServer",
+          new Object[] { locPort2, locString, authenticator, extraProps,
+              javaProps }));
+
+      // Start first client with valid credentials
+      Properties credentials1 = gen.getValidCredentials(1);
+      Properties javaProps1 = gen.getJavaProperties();
+      getLogWriter().info(
+          "testInvalidCredentials: For first client credentials: "
+              + credentials1 + " : " + javaProps1);
+      client1.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { authInit, credentials1, javaProps1, port1, port2,
+              null, multiUser, new Integer(SecurityTestUtil.NO_EXCEPTION) });
+
+      // Perform some put operations from client1
+      client1.invoke(SecurityTestUtil.class, "doPuts",
+          new Object[] { new Integer(2) });
+
+      // Start second client with invalid credentials
+      // Trying to create the region on client2 should throw a security
+      // exception
+      Properties credentials2 = gen.getInvalidCredentials(1);
+      Properties javaProps2 = gen.getJavaProperties();
+      getLogWriter().info(
+          "testInvalidCredentials: For second client credentials: "
+              + credentials2 + " : " + javaProps2);
+      client2.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { authInit, credentials2, javaProps2, port1, port2,
+              null, multiUser, new Integer(SecurityTestUtil.AUTHFAIL_EXCEPTION) });
+  }
+
+  public void testInvalidAuthInit() {
+    itestInvalidAuthInit(Boolean.FALSE);
+  }
+
+  public void itestInvalidAuthInit(Boolean multiUser) {
+
+      CredentialGenerator gen = new DummyCredentialGenerator();
+      Properties extraProps = gen.getSystemProperties();
+      Properties javaProps = gen.getJavaProperties();
+      String authenticator = gen.getAuthenticator();
+
+      getLogWriter().info(
+          "testInvalidAuthInit: Using scheme: " + gen.classCode());
+      getLogWriter().info(
+          "testInvalidAuthInit: Using authenticator: " + authenticator);
+
+      // Start the server
+      Integer locPort1 = SecurityTestUtil.getLocatorPort();
+      String locString = SecurityTestUtil.getLocatorString();
+      Integer port1 = ((Integer)server1.invoke(
+          ClientAuthenticationDUnitTest.class, "createCacheServer",
+          new Object[] { locPort1, locString, authenticator, extraProps,
+              javaProps }));
+
+      Properties credentials = gen.getValidCredentials(1);
+      javaProps = gen.getJavaProperties();
+      getLogWriter().info(
+          "testInvalidAuthInit: For first client credentials: " + credentials
+              + " : " + javaProps);
+      client1.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { "com.gemstone.none", credentials, javaProps,
+            new Integer[] { port1 }, null, multiUser,
+            Integer.valueOf(SecurityTestUtil.AUTHREQ_EXCEPTION) });
+  }
+
+  public void testNoAuthInitWithCredentials() {
+    itestNoAuthInitWithCredentials(Boolean.FALSE);
+  }
+
+  public void itestNoAuthInitWithCredentials(Boolean multiUser) {
+
+      CredentialGenerator gen = new DummyCredentialGenerator();
+      Properties extraProps = gen.getSystemProperties();
+      Properties javaProps = gen.getJavaProperties();
+      String authenticator = gen.getAuthenticator();
+
+
+      getLogWriter().info(
+          "testNoAuthInitWithCredentials: Using scheme: " + gen.classCode());
+      getLogWriter().info(
+          "testNoAuthInitWithCredentials: Using authenticator: "
+              + authenticator);
+
+      // Start the servers
+      Integer locPort1 = SecurityTestUtil.getLocatorPort();
+      Integer locPort2 = SecurityTestUtil.getLocatorPort();
+      String locString = SecurityTestUtil.getLocatorString();
+      Integer port1 = ((Integer)server1.invoke(
+          ClientAuthenticationDUnitTest.class, "createCacheServer",
+          new Object[] { locPort1, locString, authenticator, extraProps,
+              javaProps }));
+      Integer port2 = ((Integer)server2.invoke(
+          ClientAuthenticationDUnitTest.class, "createCacheServer",
+          new Object[] { locPort2, locString, authenticator, extraProps,
+              javaProps }));
+
+      // Start the clients with valid credentials
+      Properties credentials1 = gen.getValidCredentials(1);
+      Properties javaProps1 = gen.getJavaProperties();
+      getLogWriter().info(
+          "testNoAuthInitWithCredentials: For first client credentials: "
+              + credentials1 + " : " + javaProps1);
+      Properties credentials2 = gen.getValidCredentials(2);
+      Properties javaProps2 = gen.getJavaProperties();
+      getLogWriter().info(
+          "testNoAuthInitWithCredentials: For second client credentials: "
+              + credentials2 + " : " + javaProps2);
+      client1.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { null, credentials1, javaProps1, port1, port2, null,
+          multiUser, new Integer(SecurityTestUtil.AUTHREQ_EXCEPTION) });
+      client2.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { null, credentials2, javaProps2, port1, port2, null,
+          multiUser, new Integer(SecurityTestUtil.AUTHREQ_EXCEPTION) });
+      client2.invoke(SecurityTestUtil.class, "closeCache");
+      
+
+      // Now also try with invalid credentials
+      credentials2 = gen.getInvalidCredentials(5);
+      javaProps2 = gen.getJavaProperties();
+      client2.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { null, credentials2, javaProps2, port1, port2, null,
+          multiUser, new Integer(SecurityTestUtil.AUTHREQ_EXCEPTION) });
+  }
+
+  public void testInvalidAuthenticator() {
+    itestInvalidAuthenticator(Boolean.FALSE);
+  }
+
+  public void itestInvalidAuthenticator(Boolean multiUser) {
+
+      CredentialGenerator gen = new DummyCredentialGenerator();
+      Properties extraProps = gen.getSystemProperties();
+      Properties javaProps = gen.getJavaProperties();
+      String authInit = gen.getAuthInit();
+
+      getLogWriter().info(
+          "testInvalidAuthenticator: Using scheme: " + gen.classCode());
+      getLogWriter().info(
+          "testInvalidAuthenticator: Using authinit: " + authInit);
+
+      // Start the server with invalid authenticator
+      Integer locPort1 = SecurityTestUtil.getLocatorPort();
+      String locString = SecurityTestUtil.getLocatorString();
+      Integer port1 = (Integer)server1.invoke(
+          ClientAuthenticationDUnitTest.class, "createCacheServer",
+          new Object[] { locPort1, locString, "com.gemstone.gemfire.none",
+              extraProps, javaProps });
+
+      // Trying to create the region on client should throw a security exception
+      Properties credentials = gen.getValidCredentials(1);
+      javaProps = gen.getJavaProperties();
+      getLogWriter().info(
+          "testInvalidAuthenticator: For first client credentials: "
+              + credentials + " : " + javaProps);
+      client1.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { authInit, credentials, javaProps, port1, null,
+              new Integer(SecurityTestUtil.AUTHFAIL_EXCEPTION) });
+      client1.invoke(SecurityTestUtil.class, "closeCache");
+      
+
+      // Also test with invalid credentials
+      credentials = gen.getInvalidCredentials(1);
+      javaProps = gen.getJavaProperties();
+      getLogWriter().info(
+          "testInvalidAuthenticator: For first client credentials: "
+              + credentials + " : " + javaProps);
+      client1.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { authInit, credentials, javaProps, port1, null,
+              new Integer(SecurityTestUtil.AUTHFAIL_EXCEPTION) });
+  }
+
+  public void testNoAuthenticatorWithCredentials() {
+    itestNoAuthenticatorWithCredentials(Boolean.FALSE);
+  }
+
+  public void itestNoAuthenticatorWithCredentials(Boolean multiUser) {
+
+      CredentialGenerator gen = new DummyCredentialGenerator();
+      Properties extraProps = gen.getSystemProperties();
+      Properties javaProps = gen.getJavaProperties();
+      String authenticator = gen.getAuthenticator();
+      String authInit = gen.getAuthInit();
+
+      getLogWriter().info(
+          "testNoAuthenticatorWithCredentials: Using scheme: "
+              + gen.classCode());
+      getLogWriter().info(
+          "testNoAuthenticatorWithCredentials: Using authinit: " + authInit);
+
+      // Start the servers with no authenticator
+      Integer locPort1 = SecurityTestUtil.getLocatorPort();
+      Integer locPort2 = SecurityTestUtil.getLocatorPort();
+      String locString = SecurityTestUtil.getLocatorString();
+      Integer port1 = (Integer)server1.invoke(
+          ClientAuthenticationDUnitTest.class, "createCacheServer",
+          new Object[] { locPort1, locString, null, extraProps, javaProps });
+      Integer port2 = (Integer)server2.invoke(
+          ClientAuthenticationDUnitTest.class, "createCacheServer",
+          new Object[] { locPort2, locString, null, extraProps, javaProps });
+
+      // Clients should connect successfully and work properly with
+      // valid/invalid credentials when none are required on the server side
+      Properties credentials1 = gen.getValidCredentials(3);
+      Properties javaProps1 = gen.getJavaProperties();
+      getLogWriter().info(
+          "testNoAuthenticatorWithCredentials: For first client credentials: "
+              + credentials1 + " : " + javaProps1);
+      Properties credentials2 = gen.getInvalidCredentials(5);
+      Properties javaProps2 = gen.getJavaProperties();
+      getLogWriter().info(
+          "testNoAuthenticatorWithCredentials: For second client credentials: "
+              + credentials2 + " : " + javaProps2);
+      client1.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { authInit, credentials1, javaProps1, port1, port2,
+              null, multiUser, new Integer(SecurityTestUtil.NO_EXCEPTION) });
+      client2.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { authInit, credentials2, javaProps2, port1, port2,
+              null, multiUser, new Integer(SecurityTestUtil.NO_EXCEPTION) });
+
+      // Perform some put operations from client1
+      client1.invoke(SecurityTestUtil.class, "doPuts",
+          new Object[] { new Integer(2) });
+
+      // Verify that the puts succeeded
+      client2.invoke(SecurityTestUtil.class, "doGets",
+          new Object[] { new Integer(2) });
+  }
+
+  public void testCredentialsWithFailover() {
+    itestCredentialsWithFailover(Boolean.FALSE);
+  }
+
+  public void itestCredentialsWithFailover(Boolean multiUser) {
+      CredentialGenerator gen = new DummyCredentialGenerator();
+      Properties extraProps = gen.getSystemProperties();
+      Properties javaProps = gen.getJavaProperties();
+      String authenticator = gen.getAuthenticator();
+      String authInit = gen.getAuthInit();
+
+      getLogWriter().info(
+          "testCredentialsWithFailover: Using scheme: " + gen.classCode());
+      getLogWriter().info(
+          "testCredentialsWithFailover: Using authenticator: " + authenticator);
+      getLogWriter().info(
+          "testCredentialsWithFailover: Using authinit: " + authInit);
+
+      // Start the first server
+      Integer locPort1 = SecurityTestUtil.getLocatorPort();
+      Integer locPort2 = SecurityTestUtil.getLocatorPort();
+      String locString = SecurityTestUtil.getLocatorString();
+      Integer port1 = (Integer)server1.invoke(
+          ClientAuthenticationDUnitTest.class, "createCacheServer",
+          new Object[] { locPort1, locString, authenticator, extraProps,
+              javaProps });
+      // Get a port for second server but do not start it
+      // This forces the clients to connect to the first server
+      Integer port2 = new Integer(AvailablePort
+          .getRandomAvailablePort(AvailablePort.SOCKET));
+
+      // Start the clients with valid credentials
+      Properties credentials1 = gen.getValidCredentials(5);
+      Properties javaProps1 = gen.getJavaProperties();
+      getLogWriter().info(
+          "testCredentialsWithFailover: For first client credentials: "
+              + credentials1 + " : " + javaProps1);
+      Properties credentials2 = gen.getValidCredentials(6);
+      Properties javaProps2 = gen.getJavaProperties();
+      getLogWriter().info(
+          "testCredentialsWithFailover: For second client credentials: "
+              + credentials2 + " : " + javaProps2);
+      client1.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { authInit, credentials1, javaProps1, port1, port2,
+              null, multiUser, new Integer(SecurityTestUtil.NO_EXCEPTION) });
+      client2.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { authInit, credentials2, javaProps2, port1, port2,
+              null, multiUser, new Integer(SecurityTestUtil.NO_EXCEPTION) });
+
+      // Perform some put operations from client1
+      client1.invoke(SecurityTestUtil.class, "doPuts",
+          new Object[] { new Integer(2) });
+      // Verify that the puts succeeded
+      client2.invoke(SecurityTestUtil.class, "doGets",
+          new Object[] { new Integer(2) });
+
+      // start the second one and stop the first server to force a failover
+      server2.invoke(ClientAuthenticationDUnitTest.class, "createCacheServer",
+          new Object[] { locPort2, locString, port2, authenticator, extraProps,
+              javaProps });
+      server1.invoke(SecurityTestUtil.class, "closeCache");
+
+      // Perform some create/update operations from client1
+      client1.invoke(SecurityTestUtil.class, "doNPuts",
+          new Object[] { new Integer(4) });
+      // Verify that the creates/updates succeeded
+      client2.invoke(SecurityTestUtil.class, "doNGets",
+          new Object[] { new Integer(4) });
+
+      // Try to connect client2 with no credentials
+      // Verify that the creation of region throws security exception
+      if (gen.classCode().equals(ClassCode.SSL)) {
+        // For SSL the exception may not come since the server can close socket
+        // before handshake message is sent from client. However exception
+        // should come in any region operations.
+        client2
+            .invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+                new Object[] { null, null, null, port1, port2, null, multiUser,
+                    new Integer(SecurityTestUtil.NOFORCE_AUTHREQ_EXCEPTION) });
+        client2.invoke(SecurityTestUtil.class, "doPuts", new Object[] {
+            new Integer(2), new Integer(SecurityTestUtil.OTHER_EXCEPTION) });
+      }
+      else {
+        client2.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheClient", new Object[] { null, null, null, port1, port2,
+                null, multiUser, new Integer(SecurityTestUtil.AUTHREQ_EXCEPTION) });
+      }
+
+      // Now try to connect client1 with invalid credentials
+      // Verify that the creation of region throws security exception
+      credentials1 = gen.getInvalidCredentials(7);
+      javaProps1 = gen.getJavaProperties();
+      getLogWriter().info(
+          "testCredentialsWithFailover: For first client invalid credentials: "
+              + credentials1 + " : " + javaProps1);
+      client1.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { authInit, credentials1, javaProps1, port1, port2,
+              null, multiUser, new Integer(SecurityTestUtil.AUTHFAIL_EXCEPTION) });
+
+      if (multiUser) {
+        client1.invoke(SecurityTestUtil.class, "doProxyCacheClose");
+        client2.invoke(SecurityTestUtil.class, "doProxyCacheClose");
+        client1.invoke(SecurityTestUtil.class, "doSimplePut",
+            new Object[] {"CacheClosedException"});
+        client2.invoke(SecurityTestUtil.class, "doSimpleGet",
+            new Object[] {"CacheClosedException"});
+      }
+  }
+
+  public void testCredentialsForNotifications() {
+    itestCredentialsForNotifications(Boolean.FALSE);
+  }
+
+  public void itestCredentialsForNotifications(Boolean multiUser) {
+      CredentialGenerator gen = new DummyCredentialGenerator();
+      Properties extraProps = gen.getSystemProperties();
+      Properties javaProps = gen.getJavaProperties();
+      String authenticator = gen.getAuthenticator();
+      String authInit = gen.getAuthInit();
+
+      getLogWriter().info(
+          "testCredentialsForNotifications: Using scheme: " + gen.classCode());
+      getLogWriter().info(
+          "testCredentialsForNotifications: Using authenticator: "
+              + authenticator);
+      getLogWriter().info(
+          "testCredentialsForNotifications: Using authinit: " + authInit);
+
+      // Start the first server
+      Integer locPort1 = SecurityTestUtil.getLocatorPort();
+      Integer locPort2 = SecurityTestUtil.getLocatorPort();
+      String locString = SecurityTestUtil.getLocatorString();
+      Integer port1 = (Integer)server1.invoke(
+          ClientAuthenticationDUnitTest.class, "createCacheServer",
+          new Object[] { locPort1, locString, authenticator, extraProps,
+              javaProps });
+      // Get a port for second server but do not start it
+      // This forces the clients to connect to the first server
+      Integer port2 = new Integer(AvailablePort
+          .getRandomAvailablePort(AvailablePort.SOCKET));
+
+      // Start the clients with valid credentials
+      Properties credentials1 = gen.getValidCredentials(3);
+      Properties javaProps1 = gen.getJavaProperties();
+      getLogWriter().info(
+          "testCredentialsForNotifications: For first client credentials: "
+              + credentials1 + " : " + javaProps1);
+      Properties credentials2 = gen.getValidCredentials(4);
+      Properties javaProps2 = gen.getJavaProperties();
+      getLogWriter().info(
+          "testCredentialsForNotifications: For second client credentials: "
+              + credentials2 + " : " + javaProps2);
+      client1.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { authInit, credentials1, javaProps1, port1, port2,
+              null, multiUser, new Integer(SecurityTestUtil.NO_EXCEPTION) });
+      // Set up zero forward connections to check notification handshake only
+      Object zeroConns = new Integer(0);
+      client2.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { authInit, credentials2, javaProps2, port1, port2,
+              zeroConns, multiUser, new Integer(SecurityTestUtil.NO_EXCEPTION) });
+
+      // Register interest on all keys on second client
+      client2
+          .invoke(ClientAuthenticationDUnitTest.class, "registerAllInterest");
+
+      // Perform some put operations from client1
+      client1.invoke(SecurityTestUtil.class, "doPuts",
+          new Object[] { new Integer(2) });
+
+      // Verify that the puts succeeded
+      client2.invoke(SecurityTestUtil.class, "doLocalGets",
+          new Object[] { new Integer(2) });
+
+      // start the second one and stop the first server to force a failover
+      server2.invoke(ClientAuthenticationDUnitTest.class, "createCacheServer",
+          new Object[] { locPort2, locString, port2, authenticator, extraProps,
+              javaProps });
+      server1.invoke(SecurityTestUtil.class, "closeCache");
+
+      // Wait for failover to complete
+      pause(500);
+
+      // Perform some create/update operations from client1
+      client1.invoke(SecurityTestUtil.class, "doNPuts",
+          new Object[] { new Integer(4) });
+      // Verify that the creates/updates succeeded
+      client2.invoke(SecurityTestUtil.class, "doNLocalGets",
+          new Object[] { new Integer(4) });
+
+      // Try to connect client1 with no credentials
+      // Verify that the creation of region throws security exception
+      server1.invoke(ClientAuthenticationDUnitTest.class, "createCacheServer",
+          new Object[] { locPort1, locString, port1, authenticator, extraProps,
+              javaProps });
+      if (gen.classCode().equals(ClassCode.SSL)) {
+        // For SSL the exception may not come since the server can close socket
+        // before handshake message is sent from client. However exception
+        // should come in any region operations.
+        client1.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheClient", new Object[] { null, null, null, port1, port2,
+                zeroConns, multiUser,
+                new Integer(SecurityTestUtil.NOFORCE_AUTHREQ_EXCEPTION) });
+        client1.invoke(SecurityTestUtil.class, "doPuts", new Object[] {
+            new Integer(2), new Integer(SecurityTestUtil.OTHER_EXCEPTION) });
+      }
+      else {
+        client1.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheClient", new Object[] { null, null, null, port1, port2,
+                zeroConns, multiUser, new Integer(SecurityTestUtil.AUTHREQ_EXCEPTION) });
+      }
+
+      // Now try to connect client2 with invalid credentials
+      // Verify that the creation of region throws security exception
+      credentials2 = gen.getInvalidCredentials(3);
+      javaProps2 = gen.getJavaProperties();
+      getLogWriter().info(
+          "testCredentialsForNotifications: For second client invalid credentials: "
+              + credentials2 + " : " + javaProps2);
+      client2.invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+          new Object[] { authInit, credentials2, javaProps2, port1, port2,
+              zeroConns, multiUser, new Integer(SecurityTestUtil.AUTHFAIL_EXCEPTION) });
+
+      // Now try to connect client2 with invalid auth-init method
+      // Trying to create the region on client with valid credentials should
+      // throw a security exception
+      client2
+          .invoke(ClientAuthenticationDUnitTest.class, "createCacheClient",
+              new Object[] { "com.gemstone.none", credentials1, javaProps1,
+                  port1, port2, zeroConns, multiUser, 
+                  new Integer(SecurityTestUtil.AUTHREQ_EXCEPTION) });
+
+      // Now start the servers with invalid authenticator method.
+      // Skip this test for a scheme which does not have an authInit in the
+      // first place (e.g. SSL) since that will fail with AuthReqEx before
+      // authenticator is even invoked.
+      if (authInit != null && authInit.length() > 0) {
+        server1.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheServer", new Object[] { locPort1, locString, port1,
+                "com.gemstone.gemfire.none", extraProps, javaProps });
+        server2.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheServer", new Object[] { locPort2, locString, port2,
+                "com.gemstone.gemfire.none", extraProps, javaProps });
+
+        // Trying to create the region on client with valid/invalid credentials
+        // should throw a security exception
+        client2.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheClient", new Object[] { authInit, credentials1,
+                javaProps1, port1, port2, zeroConns, multiUser,
+                new Integer(SecurityTestUtil.AUTHFAIL_EXCEPTION) });
+        client1.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheClient", new Object[] { authInit, credentials2,
+                javaProps2, port1, port2, zeroConns, multiUser,
+                new Integer(SecurityTestUtil.AUTHFAIL_EXCEPTION) });
+      }
+      else {
+        getLogWriter().info(
+            "testCredentialsForNotifications: Skipping invalid authenticator for scheme ["
+                + gen.classCode() + "] which has no authInit");
+      }
+
+      // Try connection with null auth-init on clients.
+      // Skip this test for a scheme which does not have an authInit in the
+      // first place (e.g. SSL).
+      if (authInit != null && authInit.length() > 0) {
+        server1.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheServer", new Object[] { locPort1, locString, port1,
+                authenticator, extraProps, javaProps });
+        server2.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheServer", new Object[] { locPort2, locString, port2,
+                authenticator, extraProps, javaProps });
+        client1.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheClient", new Object[] { null, credentials1, javaProps1,
+                port1, port2, null, multiUser,
+                new Integer(SecurityTestUtil.AUTHREQ_EXCEPTION) });
+        client2.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheClient", new Object[] { null, credentials2, javaProps2,
+                port1, port2, zeroConns, multiUser,
+                new Integer(SecurityTestUtil.AUTHREQ_EXCEPTION) });
+
+        // Now also try with invalid credentials on client2
+        client2.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheClient", new Object[] { null, credentials2, javaProps2,
+                port1, port2, zeroConns, multiUser,
+                new Integer(SecurityTestUtil.AUTHREQ_EXCEPTION) });
+      }
+      else {
+        getLogWriter().info(
+            "testCredentialsForNotifications: Skipping null authInit for scheme ["
+                + gen.classCode() + "] which has no authInit");
+      }
+
+      // Try connection with null authenticator on server and sending
+      // valid/invalid credentials.
+      // If the scheme does not have an authenticator in the first place (e.g.
+      // SSL) then skip it since this test is useless.
+      if (authenticator != null && authenticator.length() > 0) {
+        server1.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheServer", new Object[] { locPort1, locString, port1,
+                null, extraProps, javaProps });
+        server2.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheServer", new Object[] { locPort2, locString, port2,
+                null, extraProps, javaProps });
+        client1.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheClient", new Object[] { authInit, credentials1,
+                javaProps1, port1, port2, null, multiUser,
+                new Integer(SecurityTestUtil.NO_EXCEPTION) });
+        client2.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheClient", new Object[] { authInit, credentials2,
+                javaProps2, port1, port2, zeroConns, multiUser,
+                new Integer(SecurityTestUtil.NO_EXCEPTION) });
+
+        // Register interest on all keys on second client
+        client2.invoke(ClientAuthenticationDUnitTest.class,
+            "registerAllInterest");
+
+        // Perform some put operations from client1
+        client1.invoke(SecurityTestUtil.class, "doPuts",
+            new Object[] { new Integer(4) });
+
+        // Verify that the puts succeeded
+        client2.invoke(SecurityTestUtil.class, "doLocalGets",
+            new Object[] { new Integer(4) });
+
+        // Now also try with valid credentials on client2
+        client1.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheClient", new Object[] { authInit, credentials2,
+                javaProps2, port1, port2, null, multiUser,
+                new Integer(SecurityTestUtil.NO_EXCEPTION) });
+        client2.invoke(ClientAuthenticationDUnitTest.class,
+            "createCacheClient", new Object[] { authInit, credentials1,
+                javaProps1, port1, port2, zeroConns, multiUser,
+                new Integer(SecurityTestUtil.NO_EXCEPTION) });
+
+        // Register interest on all keys on second client
+        client2.invoke(ClientAuthenticationDUnitTest.class,
+            "registerAllInterest");
+
+        // Perform some put operations from client1
+        client1.invoke(SecurityTestUtil.class, "doNPuts",
+            new Object[] { new Integer(4) });
+
+        // Verify that the puts succeeded
+        client2.invoke(SecurityTestUtil.class, "doNLocalGets",
+            new Object[] { new Integer(4) });
+      }
+      else {
+        getLogWriter().info(
+            "testCredentialsForNotifications: Skipping scheme ["
+                + gen.classCode() + "] which has no authenticator");
+      }
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Tests for MULTI_USER_MODE start here
+  //////////////////////////////////////////////////////////////////////////////
+
+  public void xtestValidCredentialsForMultipleUsers() {
+    itestValidCredentials(Boolean.TRUE);
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Tests for MULTI_USER_MODE end here
+  //////////////////////////////////////////////////////////////////////////////
+  
+  @Override
+  public void tearDown2() throws Exception {
+
+    super.tearDown2();
+    // close the clients first
+    client1.invoke(SecurityTestUtil.class, "closeCache");
+    client2.invoke(SecurityTestUtil.class, "closeCache");
+    // then close the servers
+    server1.invoke(SecurityTestUtil.class, "closeCache");
+    server2.invoke(SecurityTestUtil.class, "closeCache");
+  }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/a622d6ec/gemfire-core/src/test/java/com/gemstone/gemfire/security/ClientAuthenticationPart2DUnitTest.java
----------------------------------------------------------------------
diff --git a/gemfire-core/src/test/java/com/gemstone/gemfire/security/ClientAuthenticationPart2DUnitTest.java b/gemfire-core/src/test/java/com/gemstone/gemfire/security/ClientAuthenticationPart2DUnitTest.java
new file mode 100644
index 0000000..138114a
--- /dev/null
+++ b/gemfire-core/src/test/java/com/gemstone/gemfire/security/ClientAuthenticationPart2DUnitTest.java
@@ -0,0 +1,88 @@
+
+package com.gemstone.gemfire.security;
+
+/*
+ * 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.
+ */
+
+
+/**
+ * this class contains test methods that used to be in its superclass but
+ * that test started taking too long and caused dunit runs to hang
+ */
+public class ClientAuthenticationPart2DUnitTest extends
+    ClientAuthenticationDUnitTest {
+
+  /** constructor */
+  public ClientAuthenticationPart2DUnitTest(String name) {
+    super(name);
+  }
+
+  // override inherited tests so they aren't executed again
+  
+  @Override
+  public void testValidCredentials() {  }
+  @Override
+  public void testNoCredentials() {  }
+  @Override
+  public void testInvalidCredentials() {  }
+  @Override
+  public void testInvalidAuthInit() {  }
+  @Override
+  public void testNoAuthInitWithCredentials() {  }
+  @Override
+  public void testInvalidAuthenticator() {  }
+  @Override
+  public void testNoAuthenticatorWithCredentials() {  }
+  @Override
+  public void testCredentialsWithFailover() {  }
+  @Override
+  public void testCredentialsForNotifications() {  }
+  //@Override
+  public void testValidCredentialsForMultipleUsers() {  }
+
+
+  
+  
+  
+  public void testNoCredentialsForMultipleUsers() {
+    itestNoCredentials(Boolean.TRUE);
+  }
+  public void testInvalidCredentialsForMultipleUsers() {
+    itestInvalidCredentials(Boolean.TRUE);
+  }
+  public void testInvalidAuthInitForMultipleUsers() {
+    itestInvalidAuthInit(Boolean.TRUE);
+  }
+  public void testNoAuthInitWithCredentialsForMultipleUsers() {
+    itestNoAuthInitWithCredentials(Boolean.TRUE);
+  }
+  public void testInvalidAuthenitcatorForMultipleUsers() {
+    itestInvalidAuthenticator(Boolean.TRUE);
+  }
+  public void testNoAuthenticatorWithCredentialsForMultipleUsers() {
+    itestNoAuthenticatorWithCredentials(Boolean.TRUE);
+  }
+  public void disabled_testCredentialsWithFailoverForMultipleUsers() {
+    itestCredentialsWithFailover(Boolean.TRUE);
+  }
+  public void __testCredentialsForNotificationsForMultipleUsers() {
+    itestCredentialsForNotifications(Boolean.TRUE);
+  }
+
+}


Mime
View raw message