jdk/test/sample/chatserver/ChatTest.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2011 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
  * @summary Test chat server chatserver test
  *
  * @library ../../../src/share/sample/nio/chatserver
  * @build ChatTest ChatServer Client ClientReader DataReader MessageReader NameReader
  * @run main ChatTest
  */

 import java.io.*;
 import java.net.InetSocketAddress;
 import java.net.Socket;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.CyclicBarrier;

 public class ChatTest {
     public static int listeningPort = 0;

     public static void main(String[] args) throws Throwable {
         testStartStop();
         testPortOpen();
         testAsksForName();
         testUseName();
         testConnectDisconnectConnect();
         testUsernameAndMessage();
         testDontReceiveMessageInNameState();
     }

     private static ChatServer startServer() throws IOException {
         ChatServer server = new ChatServer(0);
         InetSocketAddress address = (InetSocketAddress) server.getSocketAddress();
         listeningPort = address.getPort();
         server.run();
         return server;
     }

     public static void testStartStop() throws Exception {
         ChatServer server = startServer();
         server.shutdown();
     }

     public static void testPortOpen() throws Exception {
         ChatServer server = startServer();
         try {
             Socket socket = new Socket("localhost", listeningPort);
             if (!socket.isConnected()) {
                 throw new RuntimeException("Failed to connect to server: port not open");
             }
         } finally {
             server.shutdown();
         }
     }

     public static void testAsksForName() throws Exception {
         ChatServer server = startServer();
         try {
             Socket socket = new Socket("localhost", listeningPort);

             Reader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
             String string = readAvailableString(reader);
             if (!string.equals("Name: ")) {
                 throw new RuntimeException("Server doesn't send Name: ");
             }
         } finally {
             server.shutdown();
         }
     }

     public static void testUseName() throws Throwable {
         ChatServer server = startServer();
         try {
             performTestUseName();
         } finally {
             server.shutdown();
         }
     }

     public static void testConnectDisconnectConnect() throws Exception {
         ChatServer server = startServer();
         try {
             performTestConnectDisconnectConnect();
         } finally {
             server.shutdown();
         }
     }

     public static void testUsernameAndMessage() throws Exception {
         ChatServer server = startServer();
         try {
             performTestUsernameAndMessage();
         } finally {
             server.shutdown();
         }
     }

     public static void testDontReceiveMessageInNameState() throws Exception {
         ChatServer server = startServer();
         try {
             performDontReceiveMessageInNameState();
         } finally {
             server.shutdown();
         }
     }

     private static void assertEqual(List<Exception> exception, Object value, Object expected) {
         if (expected == value) {
             return;
         }
         if (expected == null) {
             exception.add(new RuntimeException("Expected null, but was: " + value));
             return;
         }
         if (!expected.equals(value)) {
             exception.add(new RuntimeException("Expected: " + expected + " but was: " + value));
             return;
         }
     }

     private static void performDontReceiveMessageInNameState() throws Exception {
         final CyclicBarrier barrier1 = new CyclicBarrier(2);
         final CyclicBarrier barrier2 = new CyclicBarrier(2);
         final CyclicBarrier barrier3 = new CyclicBarrier(2);
         final List<Exception> exceptions = Collections.synchronizedList(new ArrayList<Exception>());

         ChatConnection chatConnection = new ChatConnection() {
             @Override
             public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {
                 String string = readAvailableString(reader);
                 assertEqual(exceptions, string, "Name: ");
                 writer.write("testClient1\n");
                 waitForJoin(reader, "testClient1");
                 barrier1.await();
                 writer.write("Ignore this!\n");
                 barrier2.await();
                 barrier3.await();
             }
         };

         Thread client2 = new Thread(new ChatConnection() {
             @Override
             public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {
                 barrier1.await();
                 barrier2.await();
                 String string = readAvailableString(reader);
                 assertEqual(exceptions, string, "Name: ");
                 string = readAvailableString(reader, true);
                 assertEqual(exceptions, string, null);
                 writer.write("testClient2\n");
                 barrier3.await();
             }
         });

         client2.start();
         chatConnection.run();
         if (!exceptions.isEmpty()) {
             throw exceptions.get(0);
         }

     }

     private static void waitForJoin(BufferedReader reader, String s) throws IOException {
         String joined;
         do {
             joined = readAvailableString(reader);
         } while (!(joined != null && joined.contains("Welcome " + s)));
     }

     private static void performTestUsernameAndMessage() throws Exception {
         final CyclicBarrier barrier1 = new CyclicBarrier(2);
         final CyclicBarrier barrier2 = new CyclicBarrier(2);
         final CyclicBarrier barrier3 = new CyclicBarrier(2);
         final List<Exception> exceptions = Collections.synchronizedList(new ArrayList<Exception>());

         ChatConnection chatConnection = new ChatConnection() {
             @Override
             public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {
                 String string = readAvailableString(reader);
                 assertEqual(exceptions, string, "Name: ");
                 writer.write("testClient1\n");
                 waitForJoin(reader, "testClient1");
                 barrier1.await();
                 barrier2.await();
                 string = readAvailableString(reader);
                 assertEqual(exceptions, string, "testClient2: Hello world!\n");
                 barrier3.await();
             }
         };

         Thread client2 = new Thread(new ChatConnection() {
             @Override
             public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {
                 String string = readAvailableString(reader);
                 assertEqual(exceptions, string, "Name: ");
                 barrier1.await();
                 writer.write("testClient2\nHello world!\n");
                 barrier2.await();
                 barrier3.await();
             }
         });

         client2.start();
         chatConnection.run();
         if (!exceptions.isEmpty()) {
             throw exceptions.get(0);
         }
     }

     private static void performTestConnectDisconnectConnect() throws Exception {
         final CyclicBarrier barrier1 = new CyclicBarrier(2);
         final CyclicBarrier barrier2 = new CyclicBarrier(2);
         final CyclicBarrier barrier3 = new CyclicBarrier(2);
         final List<Exception> exceptions = new ArrayList<Exception>();

         ChatConnection chatConnection = new ChatConnection() {
             @Override
             public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {
                 String string = readAvailableString(reader);
                 assertEqual(exceptions, string, "Name: ");
                 writer.write("testClient1\n");
             }
         };

         ChatConnection chatConnection2 = new ChatConnection() {
             @Override
             public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {
                 readAvailableString(reader);
                 writer.write("testClient1\n");
                 waitForJoin(reader, "testClient1");
                 barrier1.await();
                 writer.write("Good morning!\n");
                 barrier2.await();
                 String string = readAvailableString(reader);
                 assertEqual(exceptions, string, "testClient2: Hello world!\n");
                 barrier3.await();
             }
         };

         Thread client2 = new Thread(new ChatConnection() {
             @Override
             public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {
                 readAvailableString(reader);
                 writer.write("testClient2\n");
                 waitForJoin(reader, "testClient2");
                 barrier1.await();
                 writer.write("Hello world!\n");
                 barrier2.await();
                 String string = readAvailableString(reader);
                 assertEqual(exceptions, string, "testClient1: Good morning!\n");
                 barrier3.await();
             }
         });

         client2.start();
         chatConnection.run();
         chatConnection2.run();
         if (!exceptions.isEmpty()) {
             throw exceptions.get(0);
         }
     }

     private static void performTestUseName() throws Exception {
         final CyclicBarrier barrier1 = new CyclicBarrier(2);
         final CyclicBarrier barrier2 = new CyclicBarrier(2);
         final CyclicBarrier barrier3 = new CyclicBarrier(2);
         final List<Exception> exceptions = new ArrayList<Exception>();

         ChatConnection chatConnection = new ChatConnection() {
             @Override
             public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {
                 String string = readAvailableString(reader);
                 if (!"Name: ".equals(string)) {
                     exceptions.add(new RuntimeException("Expected Name: "));
                 }
                 writer.write("testClient1\n");
                 waitForJoin(reader, "testClient1");
                 barrier1.await();
                 barrier2.await();
                 string = readAvailableString(reader);
                 if (!"testClient2: Hello world!\n".equals(string)) {
                     exceptions.add(new RuntimeException("testClient2: Hello world!\n"));
                 }
                 barrier3.await();
             }
         };

         Thread client2 = new Thread(new ChatConnection() {
             @Override
             public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {
                 String string = readAvailableString(reader);
                 if (!"Name: ".equals(string)) {
                     exceptions.add(new RuntimeException("Expected Name: "));
                 }
                 writer.write("testClient2\n");
                 waitForJoin(reader, "testClient2");
                 barrier1.await();
                 writer.write("Hello world!\n");
                 barrier2.await();
                 barrier3.await();
             }
         });

         client2.start();
         chatConnection.run();
         if (!exceptions.isEmpty()) {
             throw exceptions.get(0);
         }
     }

     private static String readAvailableString(Reader reader) throws IOException {
         return readAvailableString(reader, false);
     }

     private static String readAvailableString(Reader reader, boolean now) throws IOException {
         StringBuilder builder = new StringBuilder();
         int bytes;
         if (now && !reader.ready()) {
             return null;
         }
         do {
             char[] buf = new char[256];
             bytes = reader.read(buf);
             builder.append(buf, 0, bytes);
         } while (bytes == 256);
         return builder.toString();
     }

     private abstract static class ChatConnection implements Runnable {
         public Exception exception;

         @Override
         public void run() {
             try (Socket socket = new Socket("localhost", listeningPort);
             BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
             Writer writer = new FlushingWriter(new OutputStreamWriter(socket.getOutputStream()))) {
                 socket.setTcpNoDelay(true);

                 run(socket, reader, writer);
             } catch (Exception e) {
                 exception = e;
             }
         }

         public abstract void run(Socket socket, BufferedReader reader, Writer writer) throws Exception;
     }

     private static class FlushingWriter extends Writer {
         public final Writer delegate;

         private FlushingWriter(Writer delegate) {
             this.delegate = delegate;
         }

         @Override
         public void write(char[] cbuf, int off, int len) throws IOException {
             delegate.write(cbuf, off, len);
         }

         @Override
         public void flush() throws IOException {
             delegate.flush();
         }

         @Override
         public void close() throws IOException {
             delegate.close();
         }

         @Override
         public void write(String str) throws IOException {
             super.write(str);
             flush();
         }
     }
 }
	/*
	* Copyright (c) 2011 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
	* @summary Test chat server chatserver test
	*
	* @library ../../../src/share/sample/nio/chatserver
	* @build ChatTest ChatServer Client ClientReader DataReader MessageReader NameReader
	* @run main ChatTest
	*/

	import java.io.*;
	import java.net.InetSocketAddress;
	import java.net.Socket;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.List;
	import java.util.concurrent.CyclicBarrier;

	public class ChatTest {
	public static int listeningPort = 0;

	public static void main(String[] args) throws Throwable {
	testStartStop();
	testPortOpen();
	testAsksForName();
	testUseName();
	testConnectDisconnectConnect();
	testUsernameAndMessage();
	testDontReceiveMessageInNameState();
	}

	private static ChatServer startServer() throws IOException {
	ChatServer server = new ChatServer(0);
	InetSocketAddress address = (InetSocketAddress) server.getSocketAddress();
	listeningPort = address.getPort();
	server.run();
	return server;
	}

	public static void testStartStop() throws Exception {
	ChatServer server = startServer();
	server.shutdown();
	}

	public static void testPortOpen() throws Exception {
	ChatServer server = startServer();
	try {
	Socket socket = new Socket("localhost", listeningPort);
	if (!socket.isConnected()) {
	throw new RuntimeException("Failed to connect to server: port not open");
	}
	} finally {
	server.shutdown();
	}
	}

	public static void testAsksForName() throws Exception {
	ChatServer server = startServer();
	try {
	Socket socket = new Socket("localhost", listeningPort);

	Reader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
	String string = readAvailableString(reader);
	if (!string.equals("Name: ")) {
	throw new RuntimeException("Server doesn't send Name: ");
	}
	} finally {
	server.shutdown();
	}
	}

	public static void testUseName() throws Throwable {
	ChatServer server = startServer();
	try {
	performTestUseName();
	} finally {
	server.shutdown();
	}
	}

	public static void testConnectDisconnectConnect() throws Exception {
	ChatServer server = startServer();
	try {
	performTestConnectDisconnectConnect();
	} finally {
	server.shutdown();
	}
	}

	public static void testUsernameAndMessage() throws Exception {
	ChatServer server = startServer();
	try {
	performTestUsernameAndMessage();
	} finally {
	server.shutdown();
	}
	}

	public static void testDontReceiveMessageInNameState() throws Exception {
	ChatServer server = startServer();
	try {
	performDontReceiveMessageInNameState();
	} finally {
	server.shutdown();
	}
	}

	private static void assertEqual(List<Exception> exception, Object value, Object expected) {
	if (expected == value) {
	return;
	}
	if (expected == null) {
	exception.add(new RuntimeException("Expected null, but was: " + value));
	return;
	}
	if (!expected.equals(value)) {
	exception.add(new RuntimeException("Expected: " + expected + " but was: " + value));
	return;
	}
	}

	private static void performDontReceiveMessageInNameState() throws Exception {
	final CyclicBarrier barrier1 = new CyclicBarrier(2);
	final CyclicBarrier barrier2 = new CyclicBarrier(2);
	final CyclicBarrier barrier3 = new CyclicBarrier(2);
	final List<Exception> exceptions = Collections.synchronizedList(new ArrayList<Exception>());

	ChatConnection chatConnection = new ChatConnection() {
	@Override
	public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {
	String string = readAvailableString(reader);
	assertEqual(exceptions, string, "Name: ");
	writer.write("testClient1\n");
	waitForJoin(reader, "testClient1");
	barrier1.await();
	writer.write("Ignore this!\n");
	barrier2.await();
	barrier3.await();
	}
	};

	Thread client2 = new Thread(new ChatConnection() {
	@Override
	public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {
	barrier1.await();
	barrier2.await();
	String string = readAvailableString(reader);
	assertEqual(exceptions, string, "Name: ");
	string = readAvailableString(reader, true);
	assertEqual(exceptions, string, null);
	writer.write("testClient2\n");
	barrier3.await();
	}
	});

	client2.start();
	chatConnection.run();
	if (!exceptions.isEmpty()) {
	throw exceptions.get(0);
	}

	}

	private static void waitForJoin(BufferedReader reader, String s) throws IOException {
	String joined;
	do {
	joined = readAvailableString(reader);
	} while (!(joined != null && joined.contains("Welcome " + s)));
	}

	private static void performTestUsernameAndMessage() throws Exception {
	final CyclicBarrier barrier1 = new CyclicBarrier(2);
	final CyclicBarrier barrier2 = new CyclicBarrier(2);
	final CyclicBarrier barrier3 = new CyclicBarrier(2);
	final List<Exception> exceptions = Collections.synchronizedList(new ArrayList<Exception>());

	ChatConnection chatConnection = new ChatConnection() {
	@Override
	public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {
	String string = readAvailableString(reader);
	assertEqual(exceptions, string, "Name: ");
	writer.write("testClient1\n");
	waitForJoin(reader, "testClient1");
	barrier1.await();
	barrier2.await();
	string = readAvailableString(reader);
	assertEqual(exceptions, string, "testClient2: Hello world!\n");
	barrier3.await();
	}
	};

	Thread client2 = new Thread(new ChatConnection() {
	@Override
	public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {
	String string = readAvailableString(reader);
	assertEqual(exceptions, string, "Name: ");
	barrier1.await();
	writer.write("testClient2\nHello world!\n");
	barrier2.await();
	barrier3.await();
	}
	});

	client2.start();
	chatConnection.run();
	if (!exceptions.isEmpty()) {
	throw exceptions.get(0);
	}
	}

	private static void performTestConnectDisconnectConnect() throws Exception {
	final CyclicBarrier barrier1 = new CyclicBarrier(2);
	final CyclicBarrier barrier2 = new CyclicBarrier(2);
	final CyclicBarrier barrier3 = new CyclicBarrier(2);
	final List<Exception> exceptions = new ArrayList<Exception>();

	ChatConnection chatConnection = new ChatConnection() {
	@Override
	public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {
	String string = readAvailableString(reader);
	assertEqual(exceptions, string, "Name: ");
	writer.write("testClient1\n");
	}
	};

	ChatConnection chatConnection2 = new ChatConnection() {
	@Override
	public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {
	readAvailableString(reader);
	writer.write("testClient1\n");
	waitForJoin(reader, "testClient1");
	barrier1.await();
	writer.write("Good morning!\n");
	barrier2.await();
	String string = readAvailableString(reader);
	assertEqual(exceptions, string, "testClient2: Hello world!\n");
	barrier3.await();
	}
	};

	Thread client2 = new Thread(new ChatConnection() {
	@Override
	public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {
	readAvailableString(reader);
	writer.write("testClient2\n");
	waitForJoin(reader, "testClient2");
	barrier1.await();
	writer.write("Hello world!\n");
	barrier2.await();
	String string = readAvailableString(reader);
	assertEqual(exceptions, string, "testClient1: Good morning!\n");
	barrier3.await();
	}
	});

	client2.start();
	chatConnection.run();
	chatConnection2.run();
	if (!exceptions.isEmpty()) {
	throw exceptions.get(0);
	}
	}

	private static void performTestUseName() throws Exception {
	final CyclicBarrier barrier1 = new CyclicBarrier(2);
	final CyclicBarrier barrier2 = new CyclicBarrier(2);
	final CyclicBarrier barrier3 = new CyclicBarrier(2);
	final List<Exception> exceptions = new ArrayList<Exception>();

	ChatConnection chatConnection = new ChatConnection() {
	@Override
	public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {
	String string = readAvailableString(reader);
	if (!"Name: ".equals(string)) {
	exceptions.add(new RuntimeException("Expected Name: "));
	}
	writer.write("testClient1\n");
	waitForJoin(reader, "testClient1");
	barrier1.await();
	barrier2.await();
	string = readAvailableString(reader);
	if (!"testClient2: Hello world!\n".equals(string)) {
	exceptions.add(new RuntimeException("testClient2: Hello world!\n"));
	}
	barrier3.await();
	}
	};

	Thread client2 = new Thread(new ChatConnection() {
	@Override
	public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {
	String string = readAvailableString(reader);
	if (!"Name: ".equals(string)) {
	exceptions.add(new RuntimeException("Expected Name: "));
	}
	writer.write("testClient2\n");
	waitForJoin(reader, "testClient2");
	barrier1.await();
	writer.write("Hello world!\n");
	barrier2.await();
	barrier3.await();
	}
	});

	client2.start();
	chatConnection.run();
	if (!exceptions.isEmpty()) {
	throw exceptions.get(0);
	}
	}

	private static String readAvailableString(Reader reader) throws IOException {
	return readAvailableString(reader, false);
	}

	private static String readAvailableString(Reader reader, boolean now) throws IOException {
	StringBuilder builder = new StringBuilder();
	int bytes;
	if (now && !reader.ready()) {
	return null;
	}
	do {
	char[] buf = new char[256];
	bytes = reader.read(buf);
	builder.append(buf, 0, bytes);
	} while (bytes == 256);
	return builder.toString();
	}

	private abstract static class ChatConnection implements Runnable {
	public Exception exception;

	@Override
	public void run() {
	try (Socket socket = new Socket("localhost", listeningPort);
	BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
	Writer writer = new FlushingWriter(new OutputStreamWriter(socket.getOutputStream()))) {
	socket.setTcpNoDelay(true);

	run(socket, reader, writer);
	} catch (Exception e) {
	exception = e;
	}
	}

	public abstract void run(Socket socket, BufferedReader reader, Writer writer) throws Exception;
	}

	private static class FlushingWriter extends Writer {
	public final Writer delegate;

	private FlushingWriter(Writer delegate) {
	this.delegate = delegate;
	}

	@Override
	public void write(char[] cbuf, int off, int len) throws IOException {
	delegate.write(cbuf, off, len);
	}

	@Override
	public void flush() throws IOException {
	delegate.flush();
	}

	@Override
	public void close() throws IOException {
	delegate.close();
	}

	@Override
	public void write(String str) throws IOException {
	super.write(str);
	flush();
	}
	}
	}