jdk/test/com/sun/jndi/ldap/LdapTimeoutTest.java - edge/openjdk - Git at Google

 /*
  * Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 /**
  * @test
  * @run main/othervm LdapTimeoutTest
  * @bug 7094377 8000487 6176036 7056489
  * @summary Timeout tests for ldap
  */

 import java.net.Socket;
 import java.net.ServerSocket;
 import java.net.SocketTimeoutException;
 import java.io.*;
 import javax.naming.*;
 import javax.naming.directory.*;
 import java.util.List;
 import java.util.Hashtable;
 import java.util.ArrayList;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.TimeUnit;
 import javax.net.ssl.SSLHandshakeException;

 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.concurrent.TimeUnit.NANOSECONDS;


 abstract class LdapTest implements Callable {

     Hashtable env;
     TestServer server;
     ScheduledExecutorService killSwitchPool;
     boolean passed = false;
     private int HANGING_TEST_TIMEOUT = 20_000;

     public LdapTest (TestServer server, Hashtable env) {
         this.server = server;
         this.env = env;
     }

     public LdapTest(TestServer server, Hashtable env,
             ScheduledExecutorService killSwitchPool)
     {
         this(server, env);
         this.killSwitchPool = killSwitchPool;
     }

     public abstract void performOp(InitialContext ctx) throws NamingException;
     public abstract void handleNamingException(
         NamingException e, long start, long end);

     public void pass() {
         this.passed = true;
     }

     public void fail() {
         throw new RuntimeException("Test failed");
     }

     public void fail(Exception e) {
         throw new RuntimeException("Test failed", e);
     }

     boolean shutItDown(InitialContext ctx) {
         try {
             if (ctx != null) ctx.close();
             return true;
         } catch (NamingException ex) {
             return false;
         }
     }

     public Boolean call() {
         InitialContext ctx = null;
         ScheduledFuture killer = null;
         long start = System.nanoTime();

         try {
             while(!server.accepting())
                 Thread.sleep(200); // allow the server to start up
             Thread.sleep(200); // to be sure

             // if this is a hanging test, scheduled a thread to
             // interrupt after a certain time
             if (killSwitchPool != null) {
                 final Thread current = Thread.currentThread();
                 killer = killSwitchPool.schedule(
                     new Callable<Void>() {
                         public Void call() throws Exception {
                             current.interrupt();
                             return null;
                         }
                     }, HANGING_TEST_TIMEOUT, MILLISECONDS);
             }

             env.put(Context.PROVIDER_URL, "ldap://localhost:" +
                     server.getLocalPort());

             try {
                 ctx = new InitialDirContext(env);
                 performOp(ctx);
                 fail();
             } catch (NamingException e) {
                 long end = System.nanoTime();
                 System.out.println(this.getClass().toString() + " - elapsed: "
                         + NANOSECONDS.toMillis(end - start));
                 handleNamingException(e, start, end);
             } finally {
                 if (killer != null && !killer.isDone())
                     killer.cancel(true);
                 shutItDown(ctx);
                 server.close();
             }
             return passed;
         } catch (IOException|InterruptedException e) {
             throw new RuntimeException(e);
         }
     }
 }

 abstract class ReadServerTest extends LdapTest {

     public ReadServerTest(Hashtable env) throws IOException {
         super(new BindableServer(), env);
     }

     public ReadServerTest(Hashtable env,
                           ScheduledExecutorService killSwitchPool)
             throws IOException
     {
         super(new BindableServer(), env, killSwitchPool);
     }

     public void performOp(InitialContext ctx) throws NamingException {
         SearchControls scl = new SearchControls();
         scl.setSearchScope(SearchControls.SUBTREE_SCOPE);
         NamingEnumeration<SearchResult> answer = ((InitialDirContext)ctx)
             .search("ou=People,o=JNDITutorial", "(objectClass=*)", scl);
     }
 }

 abstract class DeadServerTest extends LdapTest {

     public DeadServerTest(Hashtable env) throws IOException {
         super(new DeadServer(), env);
     }

     public DeadServerTest(Hashtable env,
                           ScheduledExecutorService killSwitchPool)
             throws IOException
     {
         super(new DeadServer(), env, killSwitchPool);
     }

     public void performOp(InitialContext ctx) throws NamingException {}
 }

 class DeadServerNoTimeoutTest extends DeadServerTest {

     public DeadServerNoTimeoutTest(Hashtable env,
                                    ScheduledExecutorService killSwitchPool)
             throws IOException
     {
         super(env, killSwitchPool);
     }

     public void handleNamingException(NamingException e, long start, long end) {
         if (e instanceof InterruptedNamingException) Thread.interrupted();

         if (NANOSECONDS.toMillis(end - start) < LdapTimeoutTest.MIN_TIMEOUT) {
             System.err.printf("DeadServerNoTimeoutTest fail: timeout should be " +
                               "at least %s ms, actual time is %s ms%n",
                               LdapTimeoutTest.MIN_TIMEOUT,
                               NANOSECONDS.toMillis(end - start));
             fail();
         } else {
             pass();
         }
     }
 }

 class DeadServerTimeoutTest extends DeadServerTest {

     public DeadServerTimeoutTest(Hashtable env) throws IOException {
         super(env);
     }

     public void handleNamingException(NamingException e, long start, long end)
     {
         // non SSL connect will timeout via readReply using connectTimeout
         if (NANOSECONDS.toMillis(end - start) < 2_900) {
             pass();
         } else {
             System.err.println("Fail: Waited too long");
             fail();
         }
     }
 }


 class ReadServerNoTimeoutTest extends ReadServerTest {

     public ReadServerNoTimeoutTest(Hashtable env,
                                    ScheduledExecutorService killSwitchPool)
             throws IOException
     {
         super(env, killSwitchPool);
     }

     public void handleNamingException(NamingException e, long start, long end) {
         if (e instanceof InterruptedNamingException) Thread.interrupted();

         if (NANOSECONDS.toMillis(end - start) < LdapTimeoutTest.MIN_TIMEOUT) {
             System.err.printf("ReadServerNoTimeoutTest fail: timeout should be " +
                               "at least %s ms, actual time is %s ms%n",
                               LdapTimeoutTest.MIN_TIMEOUT,
                               NANOSECONDS.toMillis(end - start));
             fail();
         } else {
             pass();
         }
     }
 }

 class ReadServerTimeoutTest extends ReadServerTest {

     public ReadServerTimeoutTest(Hashtable env) throws IOException {
         super(env);
     }

     public void handleNamingException(NamingException e, long start, long end) {
         System.out.println("ReadServerTimeoutTest: end-start=" + NANOSECONDS.toMillis(end - start));
         if (NANOSECONDS.toMillis(end - start) < 2_500) {
             fail();
         } else {
             pass();
         }
     }
 }

 class TestServer extends Thread {
     ServerSocket serverSock;
     boolean accepting = false;

     public TestServer() throws IOException {
         this.serverSock = new ServerSocket(0);
         start();
     }

     public int getLocalPort() {
         return serverSock.getLocalPort();
     }

     public boolean accepting() {
         return accepting;
     }

     public void close() throws IOException {
         serverSock.close();
     }
 }

 class BindableServer extends TestServer {

     public BindableServer() throws IOException {
         super();
     }

     private byte[] bindResponse = {
         0x30, 0x0C, 0x02, 0x01, 0x01, 0x61, 0x07, 0x0A,
         0x01, 0x00, 0x04, 0x00, 0x04, 0x00
     };

     public void run() {
         try {
             accepting = true;
             Socket socket = serverSock.accept();
             InputStream in = socket.getInputStream();
             OutputStream out = socket.getOutputStream();

             // Read the LDAP BindRequest
             while (in.read() != -1) {
                 in.skip(in.available());
                 break;
             }

             // Write an LDAP BindResponse
             out.write(bindResponse);
             out.flush();
         } catch (IOException e) {
             // ignore
         }
     }
 }

 class DeadServer extends TestServer {

     public DeadServer() throws IOException {
         super();
     }

     public void run() {
         while(true) {
             try {
                 accepting = true;
                 Socket socket = serverSock.accept();
             } catch (Exception e) {
                 break;
             }
         }
     }
 }

 public class LdapTimeoutTest {

     private static final ExecutorService testPool =
         Executors.newFixedThreadPool(3);
     private static final ScheduledExecutorService killSwitchPool =
         Executors.newScheduledThreadPool(3);
     public static int MIN_TIMEOUT = 18_000;

     static Hashtable createEnv() {
         Hashtable env = new Hashtable(11);
         env.put(Context.INITIAL_CONTEXT_FACTORY,
             "com.sun.jndi.ldap.LdapCtxFactory");
         return env;
     }

     public static void main(String[] args) throws Exception {

         InitialContext ctx = null;
         List<Future> results = new ArrayList<>();

         try {
             // run the DeadServerTest with no timeouts set
             // this should get stuck indefinitely, so we need to kill
             // it after a timeout
             System.out.println("Running connect timeout test with 20s kill switch");
             Hashtable env = createEnv();
             results.add(
                     testPool.submit(new DeadServerNoTimeoutTest(env, killSwitchPool)));

             // run the ReadServerTest with connect timeout set
             // this should get stuck indefinitely so we need to kill
             // it after a timeout
             System.out.println("Running read timeout test with 10ms connect timeout & 20s kill switch");
             Hashtable env1 = createEnv();
             env1.put("com.sun.jndi.ldap.connect.timeout", "10");
             results.add(testPool.submit(
                     new ReadServerNoTimeoutTest(env1, killSwitchPool)));

             // run the ReadServerTest with no timeouts set
             // this should get stuck indefinitely, so we need to kill
             // it after a timeout
             System.out.println("Running read timeout test with 20s kill switch");
             Hashtable env2 = createEnv();
             results.add(testPool.submit(
                     new ReadServerNoTimeoutTest(env2, killSwitchPool)));

             // run the DeadServerTest with connect / read timeouts set
             // this should exit after the connect timeout expires
             System.out.println("Running connect timeout test with 10ms connect timeout, 3000ms read timeout");
             Hashtable env3 = createEnv();
             env3.put("com.sun.jndi.ldap.connect.timeout", "10");
             env3.put("com.sun.jndi.ldap.read.timeout", "3000");
             results.add(testPool.submit(new DeadServerTimeoutTest(env3)));


             // run the ReadServerTest with connect / read timeouts set
             // this should exit after the connect timeout expires
             //
             // NOTE: commenting this test out as it is failing intermittently.
             //
             // System.out.println("Running read timeout test with 10ms connect timeout, 3000ms read timeout");
             // Hashtable env4 = createEnv();
             // env4.put("com.sun.jndi.ldap.connect.timeout", "10");
             // env4.put("com.sun.jndi.ldap.read.timeout", "3000");
             // results.add(testPool.submit(new ReadServerTimeoutTest(env4)));

             // run the DeadServerTest with connect timeout set
             // this should exit after the connect timeout expires
             System.out.println("Running connect timeout test with 10ms connect timeout");
             Hashtable env5 = createEnv();
             env5.put("com.sun.jndi.ldap.connect.timeout", "10");
             results.add(testPool.submit(new DeadServerTimeoutTest(env5)));

             // 8000487: Java JNDI connection library on ldap conn is
             // not honoring configured timeout
             System.out.println("Running simple auth connection test");
             Hashtable env6 = createEnv();
             env6.put("com.sun.jndi.ldap.connect.timeout", "10");
             env6.put("com.sun.jndi.ldap.read.timeout", "3000");
             env6.put(Context.SECURITY_AUTHENTICATION, "simple");
             env6.put(Context.SECURITY_PRINCIPAL, "user");
             env6.put(Context.SECURITY_CREDENTIALS, "password");
             results.add(testPool.submit(new DeadServerTimeoutTest(env6)));

             boolean testFailed = false;
             for (Future test : results) {
                 while (!test.isDone()) {
                     if ((Boolean) test.get() == false)
                         testFailed = true;
                 }
             }

             if (testFailed) {
                 throw new AssertionError("some tests failed");
             }

         } finally {
             LdapTimeoutTest.killSwitchPool.shutdown();
             LdapTimeoutTest.testPool.shutdown();
         }
     }

 }
	/*
	* Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	/**
	* @test
	* @run main/othervm LdapTimeoutTest
	* @bug 7094377 8000487 6176036 7056489
	* @summary Timeout tests for ldap
	*/

	import java.net.Socket;
	import java.net.ServerSocket;
	import java.net.SocketTimeoutException;
	import java.io.*;
	import javax.naming.*;
	import javax.naming.directory.*;
	import java.util.List;
	import java.util.Hashtable;
	import java.util.ArrayList;
	import java.util.concurrent.Callable;
	import java.util.concurrent.ExecutionException;
	import java.util.concurrent.Executors;
	import java.util.concurrent.ExecutorService;
	import java.util.concurrent.Future;
	import java.util.concurrent.ScheduledExecutorService;
	import java.util.concurrent.ScheduledFuture;
	import java.util.concurrent.TimeoutException;
	import java.util.concurrent.TimeUnit;
	import javax.net.ssl.SSLHandshakeException;

	import static java.util.concurrent.TimeUnit.MILLISECONDS;
	import static java.util.concurrent.TimeUnit.NANOSECONDS;


	abstract class LdapTest implements Callable {

	Hashtable env;
	TestServer server;
	ScheduledExecutorService killSwitchPool;
	boolean passed = false;
	private int HANGING_TEST_TIMEOUT = 20_000;

	public LdapTest (TestServer server, Hashtable env) {
	this.server = server;
	this.env = env;
	}

	public LdapTest(TestServer server, Hashtable env,
	ScheduledExecutorService killSwitchPool)
	{
	this(server, env);
	this.killSwitchPool = killSwitchPool;
	}

	public abstract void performOp(InitialContext ctx) throws NamingException;
	public abstract void handleNamingException(
	NamingException e, long start, long end);

	public void pass() {
	this.passed = true;
	}

	public void fail() {
	throw new RuntimeException("Test failed");
	}

	public void fail(Exception e) {
	throw new RuntimeException("Test failed", e);
	}

	boolean shutItDown(InitialContext ctx) {
	try {
	if (ctx != null) ctx.close();
	return true;
	} catch (NamingException ex) {
	return false;
	}
	}

	public Boolean call() {
	InitialContext ctx = null;
	ScheduledFuture killer = null;
	long start = System.nanoTime();

	try {
	while(!server.accepting())
	Thread.sleep(200); // allow the server to start up
	Thread.sleep(200); // to be sure

	// if this is a hanging test, scheduled a thread to
	// interrupt after a certain time
	if (killSwitchPool != null) {
	final Thread current = Thread.currentThread();
	killer = killSwitchPool.schedule(
	new Callable<Void>() {
	public Void call() throws Exception {
	current.interrupt();
	return null;
	}
	}, HANGING_TEST_TIMEOUT, MILLISECONDS);
	}

	env.put(Context.PROVIDER_URL, "ldap://localhost:" +
	server.getLocalPort());

	try {
	ctx = new InitialDirContext(env);
	performOp(ctx);
	fail();
	} catch (NamingException e) {
	long end = System.nanoTime();
	System.out.println(this.getClass().toString() + " - elapsed: "
	+ NANOSECONDS.toMillis(end - start));
	handleNamingException(e, start, end);
	} finally {
	if (killer != null && !killer.isDone())
	killer.cancel(true);
	shutItDown(ctx);
	server.close();
	}
	return passed;
	} catch (IOException\|InterruptedException e) {
	throw new RuntimeException(e);
	}
	}
	}

	abstract class ReadServerTest extends LdapTest {

	public ReadServerTest(Hashtable env) throws IOException {
	super(new BindableServer(), env);
	}

	public ReadServerTest(Hashtable env,
	ScheduledExecutorService killSwitchPool)
	throws IOException
	{
	super(new BindableServer(), env, killSwitchPool);
	}

	public void performOp(InitialContext ctx) throws NamingException {
	SearchControls scl = new SearchControls();
	scl.setSearchScope(SearchControls.SUBTREE_SCOPE);
	NamingEnumeration<SearchResult> answer = ((InitialDirContext)ctx)
	.search("ou=People,o=JNDITutorial", "(objectClass=*)", scl);
	}
	}

	abstract class DeadServerTest extends LdapTest {

	public DeadServerTest(Hashtable env) throws IOException {
	super(new DeadServer(), env);
	}

	public DeadServerTest(Hashtable env,
	ScheduledExecutorService killSwitchPool)
	throws IOException
	{
	super(new DeadServer(), env, killSwitchPool);
	}

	public void performOp(InitialContext ctx) throws NamingException {}
	}

	class DeadServerNoTimeoutTest extends DeadServerTest {

	public DeadServerNoTimeoutTest(Hashtable env,
	ScheduledExecutorService killSwitchPool)
	throws IOException
	{
	super(env, killSwitchPool);
	}

	public void handleNamingException(NamingException e, long start, long end) {
	if (e instanceof InterruptedNamingException) Thread.interrupted();

	if (NANOSECONDS.toMillis(end - start) < LdapTimeoutTest.MIN_TIMEOUT) {
	System.err.printf("DeadServerNoTimeoutTest fail: timeout should be " +
	"at least %s ms, actual time is %s ms%n",
	LdapTimeoutTest.MIN_TIMEOUT,
	NANOSECONDS.toMillis(end - start));
	fail();
	} else {
	pass();
	}
	}
	}

	class DeadServerTimeoutTest extends DeadServerTest {

	public DeadServerTimeoutTest(Hashtable env) throws IOException {
	super(env);
	}

	public void handleNamingException(NamingException e, long start, long end)
	{
	// non SSL connect will timeout via readReply using connectTimeout
	if (NANOSECONDS.toMillis(end - start) < 2_900) {
	pass();
	} else {
	System.err.println("Fail: Waited too long");
	fail();
	}
	}
	}


	class ReadServerNoTimeoutTest extends ReadServerTest {

	public ReadServerNoTimeoutTest(Hashtable env,
	ScheduledExecutorService killSwitchPool)
	throws IOException
	{
	super(env, killSwitchPool);
	}

	public void handleNamingException(NamingException e, long start, long end) {
	if (e instanceof InterruptedNamingException) Thread.interrupted();

	if (NANOSECONDS.toMillis(end - start) < LdapTimeoutTest.MIN_TIMEOUT) {
	System.err.printf("ReadServerNoTimeoutTest fail: timeout should be " +
	"at least %s ms, actual time is %s ms%n",
	LdapTimeoutTest.MIN_TIMEOUT,
	NANOSECONDS.toMillis(end - start));
	fail();
	} else {
	pass();
	}
	}
	}

	class ReadServerTimeoutTest extends ReadServerTest {

	public ReadServerTimeoutTest(Hashtable env) throws IOException {
	super(env);
	}

	public void handleNamingException(NamingException e, long start, long end) {
	System.out.println("ReadServerTimeoutTest: end-start=" + NANOSECONDS.toMillis(end - start));
	if (NANOSECONDS.toMillis(end - start) < 2_500) {
	fail();
	} else {
	pass();
	}
	}
	}

	class TestServer extends Thread {
	ServerSocket serverSock;
	boolean accepting = false;

	public TestServer() throws IOException {
	this.serverSock = new ServerSocket(0);
	start();
	}

	public int getLocalPort() {
	return serverSock.getLocalPort();
	}

	public boolean accepting() {
	return accepting;
	}

	public void close() throws IOException {
	serverSock.close();
	}
	}

	class BindableServer extends TestServer {

	public BindableServer() throws IOException {
	super();
	}

	private byte[] bindResponse = {
	0x30, 0x0C, 0x02, 0x01, 0x01, 0x61, 0x07, 0x0A,
	0x01, 0x00, 0x04, 0x00, 0x04, 0x00
	};

	public void run() {
	try {
	accepting = true;
	Socket socket = serverSock.accept();
	InputStream in = socket.getInputStream();
	OutputStream out = socket.getOutputStream();

	// Read the LDAP BindRequest
	while (in.read() != -1) {
	in.skip(in.available());
	break;
	}

	// Write an LDAP BindResponse
	out.write(bindResponse);
	out.flush();
	} catch (IOException e) {
	// ignore
	}
	}
	}

	class DeadServer extends TestServer {

	public DeadServer() throws IOException {
	super();
	}

	public void run() {
	while(true) {
	try {
	accepting = true;
	Socket socket = serverSock.accept();
	} catch (Exception e) {
	break;
	}
	}
	}
	}

	public class LdapTimeoutTest {

	private static final ExecutorService testPool =
	Executors.newFixedThreadPool(3);
	private static final ScheduledExecutorService killSwitchPool =
	Executors.newScheduledThreadPool(3);
	public static int MIN_TIMEOUT = 18_000;

	static Hashtable createEnv() {
	Hashtable env = new Hashtable(11);
	env.put(Context.INITIAL_CONTEXT_FACTORY,
	"com.sun.jndi.ldap.LdapCtxFactory");
	return env;
	}

	public static void main(String[] args) throws Exception {

	InitialContext ctx = null;
	List<Future> results = new ArrayList<>();

	try {
	// run the DeadServerTest with no timeouts set
	// this should get stuck indefinitely, so we need to kill
	// it after a timeout
	System.out.println("Running connect timeout test with 20s kill switch");
	Hashtable env = createEnv();
	results.add(
	testPool.submit(new DeadServerNoTimeoutTest(env, killSwitchPool)));

	// run the ReadServerTest with connect timeout set
	// this should get stuck indefinitely so we need to kill
	// it after a timeout
	System.out.println("Running read timeout test with 10ms connect timeout & 20s kill switch");
	Hashtable env1 = createEnv();
	env1.put("com.sun.jndi.ldap.connect.timeout", "10");
	results.add(testPool.submit(
	new ReadServerNoTimeoutTest(env1, killSwitchPool)));

	// run the ReadServerTest with no timeouts set
	// this should get stuck indefinitely, so we need to kill
	// it after a timeout
	System.out.println("Running read timeout test with 20s kill switch");
	Hashtable env2 = createEnv();
	results.add(testPool.submit(
	new ReadServerNoTimeoutTest(env2, killSwitchPool)));

	// run the DeadServerTest with connect / read timeouts set
	// this should exit after the connect timeout expires
	System.out.println("Running connect timeout test with 10ms connect timeout, 3000ms read timeout");
	Hashtable env3 = createEnv();
	env3.put("com.sun.jndi.ldap.connect.timeout", "10");
	env3.put("com.sun.jndi.ldap.read.timeout", "3000");
	results.add(testPool.submit(new DeadServerTimeoutTest(env3)));


	// run the ReadServerTest with connect / read timeouts set
	// this should exit after the connect timeout expires
	//
	// NOTE: commenting this test out as it is failing intermittently.
	//
	// System.out.println("Running read timeout test with 10ms connect timeout, 3000ms read timeout");
	// Hashtable env4 = createEnv();
	// env4.put("com.sun.jndi.ldap.connect.timeout", "10");
	// env4.put("com.sun.jndi.ldap.read.timeout", "3000");
	// results.add(testPool.submit(new ReadServerTimeoutTest(env4)));

	// run the DeadServerTest with connect timeout set
	// this should exit after the connect timeout expires
	System.out.println("Running connect timeout test with 10ms connect timeout");
	Hashtable env5 = createEnv();
	env5.put("com.sun.jndi.ldap.connect.timeout", "10");
	results.add(testPool.submit(new DeadServerTimeoutTest(env5)));

	// 8000487: Java JNDI connection library on ldap conn is
	// not honoring configured timeout
	System.out.println("Running simple auth connection test");
	Hashtable env6 = createEnv();
	env6.put("com.sun.jndi.ldap.connect.timeout", "10");
	env6.put("com.sun.jndi.ldap.read.timeout", "3000");
	env6.put(Context.SECURITY_AUTHENTICATION, "simple");
	env6.put(Context.SECURITY_PRINCIPAL, "user");
	env6.put(Context.SECURITY_CREDENTIALS, "password");
	results.add(testPool.submit(new DeadServerTimeoutTest(env6)));

	boolean testFailed = false;
	for (Future test : results) {
	while (!test.isDone()) {
	if ((Boolean) test.get() == false)
	testFailed = true;
	}
	}

	if (testFailed) {
	throw new AssertionError("some tests failed");
	}

	} finally {
	LdapTimeoutTest.killSwitchPool.shutdown();
	LdapTimeoutTest.testPool.shutdown();
	}
	}

	}