/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package tests.api.java.net;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestLevel;
import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.io.OutputStream;
import java.net.BindException;
import java.net.ConnectException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.SocketException;
import java.net.SocketImpl;
import java.net.SocketImplFactory;
import java.net.SocketTimeoutException;
import java.net.UnknownHostException;
import java.nio.channels.IllegalBlockingModeException;
import java.nio.channels.ServerSocketChannel;
import java.security.Permission;
import java.util.Date;
import java.util.Properties;
import tests.support.Support_Configuration;
import tests.support.Support_PortManager;
@TestTargetClass(value = ServerSocket.class)
public class ServerSocketTest extends SocketTestCase {
boolean interrupted;
boolean isCreateCalled = false;
ServerSocket s;
Socket sconn;
Thread t;
static class SSClient implements Runnable {
Socket cs;
int port;
public SSClient(int prt) {
port = prt;
}
public void run() {
try {
// Go to sleep so the server can setup and wait for connection
Thread.sleep(1000);
cs = new Socket(InetAddress.getLocalHost().getHostName(), port);
// Sleep again to allow server side processing. Thread is
// stopped by server.
Thread.sleep(10000);
} catch (InterruptedException e) {
return;
} catch (Throwable e) {
System.out
.println("Error establishing client: " + e.toString());
} finally {
try {
if (cs != null)
cs.close();
} catch (Exception e) {
}
}
}
}
SecurityManager sm = new SecurityManager() {
public void checkPermission(Permission perm) {
}
public void checkListen(int port) {
throw new SecurityException();
}
};
/**
* @tests java.net.ServerSocket#ServerSocket()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "ServerSocket",
args = {}
)
public void test_Constructor() {
ServerSocket ss = null;
try {
ss = new ServerSocket();
assertEquals(-1, ss.getLocalPort());
} catch (IOException e) {
fail("IOException was thrown.");
} finally {
try {
ss.close();
} catch(IOException ioe) {}
}
}
/**
* @tests java.net.ServerSocket#ServerSocket(int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "ServerSocket",
args = {int.class}
)
public void test_ConstructorI() throws Exception {
int portNumber = Support_PortManager.getNextPort();
s = new ServerSocket(portNumber);
try {
new ServerSocket(portNumber);
fail("IOException was not thrown.");
} catch(IOException ioe) {
//expected
}
try {
startClient(s.getLocalPort());
sconn = s.accept();
assertNotNull("Was unable to accept connection", sconn);
sconn.close();
} finally {
s.close();
}
s = new ServerSocket(0);
try {
startClient(s.getLocalPort());
sconn = s.accept();
assertNotNull("Was unable to accept connection", sconn);
sconn.close();
} finally {
s.close();
}
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
new ServerSocket(0);
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} catch (SocketException e) {
fail("SocketException was thrown.");
} finally {
System.setSecurityManager(oldSm);
}
}
/**
* @tests java.net.ServerSocket#ServerSocket(int)
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "Regression test.",
method = "ServerSocket",
args = {int.class}
)
public void test_ConstructorI_SocksSet() throws IOException {
// Harmony-623 regression test
ServerSocket ss = null;
Properties props = (Properties) System.getProperties().clone();
try {
System.setProperty("socksProxyHost", "127.0.0.1");
System.setProperty("socksProxyPort", "12345");
ss = new ServerSocket(0);
} finally {
System.setProperties(props);
if (null != ss) {
ss.close();
}
}
}
/**
* @tests java.net.ServerSocket#ServerSocket(int, int)
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "Doesn't check backlog.",
method = "ServerSocket",
args = {int.class, int.class}
)
public void test_ConstructorII() throws IOException {
int freePortNumber = Support_PortManager.getNextPort();
try {
s = new ServerSocket(freePortNumber, 1);
s.setSoTimeout(2000);
startClient(freePortNumber);
sconn = s.accept();
} catch (InterruptedIOException e) {
fail("InterruptedIOException was thrown.");
} finally {
try {
sconn.close();
s.close();
} catch(IOException ioe) {}
}
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
new ServerSocket(0, 0);
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} catch (SocketException e) {
fail("SocketException was thrown.");
} finally {
System.setSecurityManager(oldSm);
}
int portNumber = Support_PortManager.getNextPort();
new ServerSocket(portNumber, 0);
try {
new ServerSocket(portNumber, 0);
fail("IOExcepion was not thrown.");
} catch(IOException ioe) {
//expected
}
}
/**
* @tests java.net.ServerSocket#ServerSocket(int, int, java.net.InetAddress)
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "Doesn't check backlog value.",
method = "ServerSocket",
args = {int.class, int.class, java.net.InetAddress.class}
)
public void test_ConstructorIILjava_net_InetAddress()
throws UnknownHostException, IOException {
s = new ServerSocket(0, 10, InetAddress.getLocalHost());
try {
s.setSoTimeout(5000);
startClient(s.getLocalPort());
sconn = s.accept();
assertNotNull("Was unable to accept connection", sconn);
sconn.close();
} finally {
s.close();
}
int freePortNumber = Support_PortManager.getNextPort();
ServerSocket ss = new ServerSocket(freePortNumber, 10,
InetAddress.getLocalHost());
try {
new ServerSocket(freePortNumber, 10,
InetAddress.getLocalHost());
fail("IOException was not thrown.");
} catch(IOException ioe) {
//expected
}
try {
new ServerSocket(65536, 10,
InetAddress.getLocalHost());
fail("IllegalArgumentException was not thrown.");
} catch(IllegalArgumentException iae) {
//expected
}
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
new ServerSocket(0, 10, InetAddress.getLocalHost());
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} catch (SocketException e) {
fail("SocketException was thrown.");
} finally {
System.setSecurityManager(oldSm);
}
int portNumber = Support_PortManager.getNextPort();
new ServerSocket(portNumber, 0);
try {
new ServerSocket(portNumber, 0);
fail("IOExcepion was not thrown.");
} catch(IOException ioe) {
//expected
}
}
/**
* @tests java.net.ServerSocket#accept()
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "IOException is not checked.",
method = "accept",
args = {}
)
public void test_accept() throws IOException {
s = new ServerSocket(0);
try {
s.setSoTimeout(5000);
startClient(s.getLocalPort());
sconn = s.accept();
int localPort1 = s.getLocalPort();
int localPort2 = sconn.getLocalPort();
sconn.close();
assertEquals("Bad local port value", localPort1, localPort2);
} finally {
s.close();
}
try {
interrupted = false;
final ServerSocket ss = new ServerSocket(0);
ss.setSoTimeout(12000);
Runnable runnable = new Runnable() {
public void run() {
try {
ss.accept();
} catch (InterruptedIOException e) {
interrupted = true;
} catch (IOException e) {
}
}
};
Thread thread = new Thread(runnable, "ServerSocket.accept");
thread.start();
try {
do {
Thread.sleep(500);
} while (!thread.isAlive());
} catch (InterruptedException e) {
}
ss.close();
int c = 0;
do {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
if (interrupted) {
fail("accept interrupted");
}
if (++c > 4) {
fail("accept call did not exit");
}
} while (thread.isAlive());
interrupted = false;
ServerSocket ss2 = new ServerSocket(0);
ss2.setSoTimeout(500);
Date start = new Date();
try {
ss2.accept();
} catch (InterruptedIOException e) {
interrupted = true;
}
assertTrue("accept not interrupted", interrupted);
Date finish = new Date();
int delay = (int) (finish.getTime() - start.getTime());
assertTrue("timeout too soon: " + delay + " " + start.getTime()
+ " " + finish.getTime(), delay >= 490);
ss2.close();
} catch (IOException e) {
fail("Unexpected IOException : " + e.getMessage());
}
int portNumber = Support_PortManager.getNextPort();
ServerSocket serSocket = new ServerSocket(portNumber);
startClient(portNumber);
SecurityManager sm = new SecurityManager() {
public void checkPermission(Permission perm) {
}
public void checkAccept(String host,
int port) {
throw new SecurityException();
}
};
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
serSocket.accept();
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} catch (SocketException e) {
fail("SocketException was thrown.");
} finally {
System.setSecurityManager(oldSm);
serSocket.close();
}
ServerSocket newSocket = new ServerSocket(portNumber);
newSocket.setSoTimeout(500);
try {
newSocket.accept();
fail("SocketTimeoutException was not thrown.");
} catch(SocketTimeoutException ste) {
//expected
} finally {
newSocket.close();
}
ServerSocketChannel ssc = ServerSocketChannel.open();
ServerSocket ss = ssc.socket();
try {
ss.accept();
fail("IllegalBlockingModeException was not thrown.");
} catch(IllegalBlockingModeException ibme) {
//expected
} finally {
ss.close();
ssc.close();
}
}
/**
* @tests java.net.ServerSocket#close()
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "IOException checking missed.",
method = "close",
args = {}
)
public void test_close() throws IOException {
try {
s = new ServerSocket(0);
try {
s.close();
s.accept();
fail("Close test failed");
} catch (SocketException e) {
// expected;
}
} finally {
s.close();
}
}
/**
* @tests java.net.ServerSocket#getInetAddress()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getInetAddress",
args = {}
)
public void test_getInetAddress() throws IOException {
InetAddress addr = InetAddress.getLocalHost();
s = new ServerSocket(0, 10, addr);
try {
assertEquals("Returned incorrect InetAdrees", addr, s
.getInetAddress());
} finally {
s.close();
}
}
/**
* @tests java.net.ServerSocket#getLocalPort()
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "getLocalPort",
args = {}
)
public void test_getLocalPort() throws IOException {
// Try a specific port number, but don't complain if we don't get it
int portNumber = 63024; // I made this up
try {
try {
s = new ServerSocket(portNumber);
} catch (BindException e) {
// we could not get the port, give up
return;
}
assertEquals("Returned incorrect port", portNumber, s
.getLocalPort());
} finally {
s.close();
}
}
/**
* @tests java.net.ServerSocket#getSoTimeout()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getSoTimeout",
args = {}
)
public void test_getSoTimeout() throws IOException {
s = new ServerSocket(0);
try {
s.setSoTimeout(100);
assertEquals("Returned incorrect sotimeout", 100, s.getSoTimeout());
} finally {
s.close();
}
try {
ServerSocket newSocket = new ServerSocket();
newSocket.close();
try {
newSocket.setSoTimeout(100);
fail("SocketException was not thrown.");
} catch(SocketException e) {
//expected
}
} catch(Exception e) {
fail("Unexpected exception.");
}
}
/**
* @tests java.net.ServerSocket#setSoTimeout(int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "setSoTimeout",
args = {int.class}
)
public void test_setSoTimeoutI() throws IOException {
// Timeout should trigger and throw InterruptedIOException
try {
s = new ServerSocket(0);
s.setSoTimeout(100);
s.accept();
} catch (InterruptedIOException e) {
try {
assertEquals("Set incorrect sotimeout", 100, s.getSoTimeout());
return;
} catch (Exception x) {
fail("Exception during setSOTimeout: " + e.toString());
}
} catch (IOException iox) {
fail("IOException during setSotimeout: " + iox.toString());
}
// Timeout should not trigger in this case
s = new ServerSocket(0);
startClient(s.getLocalPort());
s.setSoTimeout(10000);
sconn = s.accept();
ServerSocket newSocket = new ServerSocket();
newSocket.close();
try {
newSocket.setSoTimeout(100);
fail("SocketException was not thrown.");
} catch(SocketException se) {
//expected
}
}
/**
* @tests java.net.ServerSocket#toString()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "toString",
args = {}
)
public void test_toString() throws Exception {
s = new ServerSocket(0);
try {
int portNumber = s.getLocalPort();
assertTrue(s.toString().contains("" + portNumber));
} finally {
try {
s.close();
} catch(Exception e) {
}
}
}
/**
* @tests java.net.ServerSocket#bind(java.net.SocketAddress)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "bind",
args = {java.net.SocketAddress.class}
)
public void test_bindLjava_net_SocketAddress() throws IOException {
class mySocketAddress extends SocketAddress {
public mySocketAddress() {
}
}
// create servers socket, bind it and then validate basic state
ServerSocket theSocket = new ServerSocket();
InetSocketAddress theAddress = new InetSocketAddress(InetAddress
.getLocalHost(), 0);
theSocket.bind(theAddress);
int portNumber = theSocket.getLocalPort();
assertTrue(
"Returned incorrect InetSocketAddress(2):"
+ theSocket.getLocalSocketAddress().toString()
+ "Expected: "
+ (new InetSocketAddress(InetAddress.getLocalHost(),
portNumber)).toString(), theSocket
.getLocalSocketAddress().equals(
new InetSocketAddress(InetAddress
.getLocalHost(), portNumber)));
assertTrue("Server socket not bound when it should be:", theSocket
.isBound());
// now make sure that it is actually bound and listening on the
// address we provided
Socket clientSocket = new Socket();
InetSocketAddress clAddress = new InetSocketAddress(InetAddress
.getLocalHost(), portNumber);
clientSocket.connect(clAddress);
Socket servSock = theSocket.accept();
assertEquals(clAddress, clientSocket.getRemoteSocketAddress());
theSocket.close();
servSock.close();
clientSocket.close();
// validate we can specify null for the address in the bind and all
// goes ok
theSocket = new ServerSocket();
theSocket.bind(null);
theSocket.close();
// Address that we have already bound to
theSocket = new ServerSocket();
ServerSocket theSocket2 = new ServerSocket();
try {
theAddress = new InetSocketAddress(InetAddress.getLocalHost(), 0);
theSocket.bind(theAddress);
SocketAddress localAddress = theSocket.getLocalSocketAddress();
theSocket2.bind(localAddress);
fail("No exception binding to address that is not available");
} catch (IOException ex) {
}
theSocket.close();
theSocket2.close();
// validate we get io address when we try to bind to address we
// cannot bind to
theSocket = new ServerSocket();
try {
theSocket.bind(new InetSocketAddress(InetAddress
.getByAddress(Support_Configuration.nonLocalAddressBytes),
0));
fail("No exception was thrown when binding to bad address");
} catch (IOException ex) {
}
theSocket.close();
// now validate case where we pass in an unsupported subclass of
// SocketAddress
theSocket = new ServerSocket();
try {
theSocket.bind(new mySocketAddress());
fail("No exception when binding using unsupported SocketAddress subclass");
} catch (IllegalArgumentException ex) {
}
theSocket.close();
ServerSocket serSocket = new ServerSocket();
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
serSocket.bind(theAddress);
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} catch (SocketException e) {
fail("SocketException was thrown.");
} finally {
System.setSecurityManager(oldSm);
serSocket.close();
}
}
/**
* @tests java.net.ServerSocket#bind(java.net.SocketAddress,int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "bind",
args = {java.net.SocketAddress.class, int.class}
)
public void test_bindLjava_net_SocketAddressI() throws IOException {
class mySocketAddress extends SocketAddress {
public mySocketAddress() {
}
}
// create servers socket, bind it and then validate basic state
ServerSocket theSocket = new ServerSocket();
InetSocketAddress theAddress = new InetSocketAddress(InetAddress
.getLocalHost(), 0);
theSocket.bind(theAddress, 5);
int portNumber = theSocket.getLocalPort();
assertTrue(
"Returned incorrect InetSocketAddress(2):"
+ theSocket.getLocalSocketAddress().toString()
+ "Expected: "
+ (new InetSocketAddress(InetAddress.getLocalHost(),
portNumber)).toString(), theSocket
.getLocalSocketAddress().equals(
new InetSocketAddress(InetAddress
.getLocalHost(), portNumber)));
assertTrue("Server socket not bound when it should be:", theSocket
.isBound());
// now make sure that it is actually bound and listening on the
// address we provided
SocketAddress localAddress = theSocket.getLocalSocketAddress();
Socket clientSocket = new Socket();
clientSocket.connect(localAddress);
Socket servSock = theSocket.accept();
assertTrue(clientSocket.getRemoteSocketAddress().equals(localAddress));
theSocket.close();
servSock.close();
clientSocket.close();
// validate we can specify null for the address in the bind and all
// goes ok
theSocket = new ServerSocket();
theSocket.bind(null, 5);
theSocket.close();
// Address that we have already bound to
theSocket = new ServerSocket();
ServerSocket theSocket2 = new ServerSocket();
try {
theAddress = new InetSocketAddress(InetAddress.getLocalHost(), 0);
theSocket.bind(theAddress, 5);
SocketAddress inuseAddress = theSocket.getLocalSocketAddress();
theSocket2.bind(inuseAddress, 5);
fail("No exception binding to address that is not available");
} catch (IOException ex) {
// expected
}
theSocket.close();
theSocket2.close();
// validate we get ioException when we try to bind to address we
// cannot bind to
theSocket = new ServerSocket();
try {
theSocket.bind(new InetSocketAddress(InetAddress
.getByAddress(Support_Configuration.nonLocalAddressBytes),
0), 5);
fail("No exception was thrown when binding to bad address");
} catch (IOException ex) {
}
theSocket.close();
// now validate case where we pass in an unsupported subclass of
// SocketAddress
theSocket = new ServerSocket();
try {
theSocket.bind(new mySocketAddress(), 5);
fail("Binding using unsupported SocketAddress subclass should have thrown exception");
} catch (IllegalArgumentException ex) {
}
theSocket.close();
// now validate that backlog is respected. We have to do a test that
// checks if it is a least a certain number as some platforms make
// it higher than we request. Unfortunately non-server versions of
// windows artificially limit the backlog to 5 and 5 is the
// historical default so it it not a great test.
theSocket = new ServerSocket();
theAddress = new InetSocketAddress(InetAddress.getLocalHost(), 0);
theSocket.bind(theAddress, 4);
localAddress = theSocket.getLocalSocketAddress();
Socket theSockets[] = new Socket[4];
int i = 0;
try {
for (i = 0; i < 4; i++) {
theSockets[i] = new Socket();
theSockets[i].connect(localAddress);
}
} catch (ConnectException ex) {
fail("Backlog does not seem to be respected in bind:" + i + ":"
+ ex.toString());
}
for (i = 0; i < 4; i++) {
theSockets[i].close();
}
theSocket.close();
servSock.close();
ServerSocket serSocket = new ServerSocket();
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
serSocket.bind(theAddress, 5);
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} catch (SocketException e) {
fail("SocketException was thrown.");
} finally {
System.setSecurityManager(oldSm);
serSocket.close();
}
}
/**
* @tests java.net.ServerSocket#getLocalSocketAddress()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getLocalSocketAddress",
args = {}
)
public void test_getLocalSocketAddress() {
// set up server connect and then validate that we get the right
// response for the local address
try {
ServerSocket theSocket = new ServerSocket(0, 5, InetAddress
.getLocalHost());
int portNumber = theSocket.getLocalPort();
assertTrue("Returned incorrect InetSocketAddress(1):"
+ theSocket.getLocalSocketAddress().toString()
+ "Expected: "
+ (new InetSocketAddress(InetAddress.getLocalHost(),
portNumber)).toString(), theSocket
.getLocalSocketAddress().equals(
new InetSocketAddress(InetAddress.getLocalHost(),
portNumber)));
theSocket.close();
// now create a socket that is not bound and validate we get the
// right answer
theSocket = new ServerSocket();
assertNull(
"Returned incorrect InetSocketAddress -unbound socket- Expected null",
theSocket.getLocalSocketAddress());
// now bind the socket and make sure we get the right answer
theSocket
.bind(new InetSocketAddress(InetAddress.getLocalHost(), 0));
int localPort = theSocket.getLocalPort();
assertEquals("Returned incorrect InetSocketAddress(2):", theSocket
.getLocalSocketAddress(), new InetSocketAddress(InetAddress
.getLocalHost(), localPort));
theSocket.close();
} catch (Exception e) {
fail("Exception during getLocalSocketAddress test: " + e);
}
}
/**
* @tests java.net.ServerSocket#isBound()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "isBound",
args = {}
)
public void test_isBound() throws IOException {
InetAddress addr = InetAddress.getLocalHost();
ServerSocket serverSocket = new ServerSocket();
assertFalse("Socket indicated bound when it should be (1)",
serverSocket.isBound());
// now bind and validate bound ok
serverSocket.bind(new InetSocketAddress(addr, 0));
assertTrue("Socket indicated not bound when it should be (1)",
serverSocket.isBound());
serverSocket.close();
// now do with some of the other constructors
serverSocket = new ServerSocket(0);
assertTrue("Socket indicated not bound when it should be (2)",
serverSocket.isBound());
serverSocket.close();
serverSocket = new ServerSocket(0, 5, addr);
assertTrue("Socket indicated not bound when it should be (3)",
serverSocket.isBound());
serverSocket.close();
serverSocket = new ServerSocket(0, 5);
assertTrue("Socket indicated not bound when it should be (4)",
serverSocket.isBound());
serverSocket.close();
}
/**
* @tests java.net.ServerSocket#isClosed()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "isClosed",
args = {}
)
public void test_isClosed() throws IOException {
InetAddress addr = InetAddress.getLocalHost();
ServerSocket serverSocket = new ServerSocket(0, 5, addr);
// validate isClosed returns expected values
assertFalse("Socket should indicate it is not closed(1):", serverSocket
.isClosed());
serverSocket.close();
assertTrue("Socket should indicate it is closed(1):", serverSocket
.isClosed());
// now do with some of the other constructors
serverSocket = new ServerSocket(0);
assertFalse("Socket should indicate it is not closed(1):", serverSocket
.isClosed());
serverSocket.close();
assertTrue("Socket should indicate it is closed(1):", serverSocket
.isClosed());
serverSocket = new ServerSocket(0, 5, addr);
assertFalse("Socket should indicate it is not closed(1):", serverSocket
.isClosed());
serverSocket.close();
assertTrue("Socket should indicate it is closed(1):", serverSocket
.isClosed());
serverSocket = new ServerSocket(0, 5);
assertFalse("Socket should indicate it is not closed(1):", serverSocket
.isClosed());
serverSocket.close();
assertTrue("Socket should indicate it is closed(1):", serverSocket
.isClosed());
}
/**
* @tests java.net.ServerSocket#setReuseAddress(boolean)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "setReuseAddress",
args = {boolean.class}
)
public void test_setReuseAddressZ() {
try {
// set up server and connect
InetSocketAddress anyAddress = new InetSocketAddress(InetAddress
.getLocalHost(), 0);
ServerSocket serverSocket = new ServerSocket();
serverSocket.setReuseAddress(false);
serverSocket.bind(anyAddress);
SocketAddress theAddress = serverSocket.getLocalSocketAddress();
// make a connection to the server, then close the server
Socket theSocket = new Socket();
theSocket.connect(theAddress);
Socket stillActiveSocket = serverSocket.accept();
serverSocket.close();
// now try to rebind the server which should fail with
// setReuseAddress to false. On windows platforms the bind is
// allowed even then reUseAddress is false so our test uses
// the platform to determine what the expected result is.
String platform = System.getProperty("os.name");
try {
serverSocket = new ServerSocket();
serverSocket.setReuseAddress(false);
serverSocket.bind(theAddress);
if ((!platform.startsWith("Windows"))) {
fail("No exception when setReuseAddress is false and we bind:"
+ theAddress.toString());
}
} catch (IOException ex) {
if (platform.startsWith("Windows")) {
fail("Got unexpected exception when binding with setReuseAddress false on windows platform:"
+ theAddress.toString() + ":" + ex.toString());
}
}
stillActiveSocket.close();
theSocket.close();
// now test case were we set it to true
anyAddress = new InetSocketAddress(InetAddress.getLocalHost(), 0);
serverSocket = new ServerSocket();
serverSocket.setReuseAddress(true);
serverSocket.bind(anyAddress);
theAddress = serverSocket.getLocalSocketAddress();
// make a connection to the server, then close the server
theSocket = new Socket();
theSocket.connect(theAddress);
stillActiveSocket = serverSocket.accept();
serverSocket.close();
// now try to rebind the server which should pass with
// setReuseAddress to true
try {
serverSocket = new ServerSocket();
serverSocket.setReuseAddress(true);
serverSocket.bind(theAddress);
} catch (IOException ex) {
fail("Unexpected exception when setReuseAddress is true and we bind:"
+ theAddress.toString() + ":" + ex.toString());
}
stillActiveSocket.close();
theSocket.close();
ensureExceptionThrownIfOptionIsUnsupportedOnOS(SO_REUSEADDR);
// now test default case were we expect this to work regardless of
// the value set
anyAddress = new InetSocketAddress(InetAddress.getLocalHost(), 0);
serverSocket = new ServerSocket();
serverSocket.bind(anyAddress);
theAddress = serverSocket.getLocalSocketAddress();
// make a connection to the server, then close the server
theSocket = new Socket();
theSocket.connect(theAddress);
stillActiveSocket = serverSocket.accept();
serverSocket.close();
// now try to rebind the server which should pass
try {
serverSocket = new ServerSocket();
serverSocket.bind(theAddress);
} catch (IOException ex) {
fail("Unexpected exception when setReuseAddress is the default case and we bind:"
+ theAddress.toString() + ":" + ex.toString());
}
stillActiveSocket.close();
theSocket.close();
try {
theSocket.setReuseAddress(true);
fail("SocketException was not thrown.");
} catch(SocketException se) {
//expected
}
ensureExceptionThrownIfOptionIsUnsupportedOnOS(SO_REUSEADDR);
} catch (Exception e) {
handleException(e, SO_REUSEADDR);
}
}
/**
* @tests java.net.ServerSocket#getReuseAddress()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getReuseAddress",
args = {}
)
public void test_getReuseAddress() {
try {
ServerSocket theSocket = new ServerSocket();
theSocket.setReuseAddress(true);
assertTrue("getReuseAddress false when it should be true",
theSocket.getReuseAddress());
theSocket.setReuseAddress(false);
assertFalse("getReuseAddress true when it should be False",
theSocket.getReuseAddress());
ensureExceptionThrownIfOptionIsUnsupportedOnOS(SO_REUSEADDR);
} catch (Exception e) {
handleException(e, SO_REUSEADDR);
}
try {
ServerSocket newSocket = new ServerSocket();
newSocket.close();
try {
newSocket.getReuseAddress();
fail("SocketException was not thrown.");
} catch(SocketException e) {
//expected
}
} catch(Exception e) {
fail("Unexpected exception.");
}
}
/**
* @tests java.net.ServerSocket#setReceiveBufferSize(int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "setReceiveBufferSize",
args = {int.class}
)
public void test_setReceiveBufferSizeI() {
try {
// now validate case where we try to set to 0
ServerSocket theSocket = new ServerSocket();
try {
theSocket.setReceiveBufferSize(0);
fail("No exception when receive buffer size set to 0");
} catch (IllegalArgumentException ex) {
}
theSocket.close();
// now validate case where we try to set to a negative value
theSocket = new ServerSocket();
try {
theSocket.setReceiveBufferSize(-1000);
fail("No exception when receive buffer size set to -1000");
} catch (IllegalArgumentException ex) {
}
theSocket.close();
// now just try to set a good value to make sure it is set and there
// are not exceptions
theSocket = new ServerSocket();
theSocket.setReceiveBufferSize(1000);
theSocket.close();
try {
theSocket.setReceiveBufferSize(10);
fail("SocketException was not thrown.");
} catch(SocketException se) {
//expected
}
ensureExceptionThrownIfOptionIsUnsupportedOnOS(SO_RCVBUF);
} catch (Exception e) {
handleException(e, SO_RCVBUF);
}
}
/*
* @tests java.net.ServerSocket#getReceiveBufferSize()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getReceiveBufferSize",
args = {}
)
public void test_getReceiveBufferSize() {
try {
ServerSocket theSocket = new ServerSocket();
// since the value returned is not necessary what we set we are
// limited in what we can test
// just validate that it is not 0 or negative
assertFalse("get Buffer size returns 0:", 0 == theSocket
.getReceiveBufferSize());
assertFalse("get Buffer size returns a negative value:",
0 > theSocket.getReceiveBufferSize());
ensureExceptionThrownIfOptionIsUnsupportedOnOS(SO_RCVBUF);
} catch (Exception e) {
handleException(e, SO_RCVBUF);
}
try {
ServerSocket newSocket = new ServerSocket();
newSocket.close();
try {
newSocket.getReceiveBufferSize();
fail("SocketException was not thrown.");
} catch(SocketException e) {
//expected
}
} catch(Exception e) {
fail("Unexpected exception.");
}
}
/**
* @tests java.net.ServerSocket#getChannel()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getChannel",
args = {}
)
public void test_getChannel() throws Exception {
assertNull(new ServerSocket().getChannel());
}
/*
* @tests java.net.ServerSocket#setPerformancePreference()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "setPerformancePreferences",
args = {int.class, int.class, int.class}
)
public void test_setPerformancePreference_Int_Int_Int() throws Exception {
performancePreferenceTest(1, 0, 0);
performancePreferenceTest(1, 1, 1);
performancePreferenceTest(0, 1, 2);
performancePreferenceTest(Integer.MAX_VALUE, Integer.MAX_VALUE,
Integer.MAX_VALUE);
}
void performancePreferenceTest(int connectionTime, int latency,
int bandwidth) throws Exception {
ServerSocket theSocket = new ServerSocket();
theSocket.setPerformancePreferences(connectionTime, latency, bandwidth);
InetSocketAddress theAddress = new InetSocketAddress(InetAddress
.getLocalHost(), 0);
theSocket.bind(theAddress);
int portNumber = theSocket.getLocalPort();
assertTrue(
"Returned incorrect InetSocketAddress(2):"
+ theSocket.getLocalSocketAddress().toString()
+ "Expected: "
+ (new InetSocketAddress(InetAddress.getLocalHost(),
portNumber)).toString(), theSocket
.getLocalSocketAddress().equals(
new InetSocketAddress(InetAddress
.getLocalHost(), portNumber)));
assertTrue("Server socket not bound when it should be:", theSocket
.isBound());
// now make sure that it is actually bound and listening on the
// address we provided
Socket clientSocket = new Socket();
InetSocketAddress clAddress = new InetSocketAddress(InetAddress
.getLocalHost(), portNumber);
clientSocket.connect(clAddress);
Socket servSock = theSocket.accept();
assertEquals(clAddress, clientSocket.getRemoteSocketAddress());
theSocket.close();
servSock.close();
clientSocket.close();
}
/**
* Sets up the fixture, for example, open a network connection. This method
* is called before a test is executed.
*/
protected void setUp() {
}
/**
* Tears down the fixture, for example, close a network connection. This
* method is called after a test is executed.
*/
protected void tearDown() {
try {
if (s != null)
s.close();
if (sconn != null)
sconn.close();
if (t != null)
t.interrupt();
} catch (Exception e) {
}
}
/**
* Sets up the fixture, for example, open a network connection. This method
* is called before a test is executed.
*/
protected void startClient(int port) {
t = new Thread(new SSClient(port), "SSClient");
t.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
System.out.println("Exception during startClinet()" + e.toString());
}
}
/**
* @tests java.net.ServerSocket#implAccept
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Regression test.",
method = "implAccept",
args = {java.net.Socket.class}
)
public void test_implAcceptLjava_net_Socket() throws Exception {
// regression test for Harmony-1235
try {
new MockServerSocket().mockImplAccept(new MockSocket(
new MockSocketImpl()));
} catch (SocketException e) {
// expected
}
}
class MockSocketImpl extends SocketImpl {
public MockSocketImpl() {
isCreateCalled = true;
}
protected void create(boolean arg0) throws IOException {
//empty
}
protected void connect(String arg0, int arg1) throws IOException {
// empty
}
protected void connect(InetAddress arg0, int arg1) throws IOException {
// empty
}
protected void connect(SocketAddress arg0, int arg1) throws IOException {
// empty
}
protected void bind(InetAddress arg0, int arg1) throws IOException {
// empty
}
protected void listen(int arg0) throws IOException {
// empty
}
protected void accept(SocketImpl arg0) throws IOException {
// empty
}
protected InputStream getInputStream() throws IOException {
return null;
}
protected OutputStream getOutputStream() throws IOException {
return null;
}
protected int available() throws IOException {
return 0;
}
protected void close() throws IOException {
// empty
}
protected void sendUrgentData(int arg0) throws IOException {
// empty
}
public void setOption(int arg0, Object arg1) throws SocketException {
// empty
}
public Object getOption(int arg0) throws SocketException {
return null;
}
}
static class MockSocket extends Socket {
public MockSocket(SocketImpl impl) throws SocketException {
super(impl);
}
}
static class MockServerSocket extends ServerSocket {
public MockServerSocket() throws Exception {
super();
}
public void mockImplAccept(Socket s) throws Exception {
super.implAccept(s);
}
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "getLocalPort",
args = {}
)
public void test_LocalPort() throws IOException {
ServerSocket ss1 = new ServerSocket(4242);
assertEquals(ss1.getLocalPort(), 4242);
ss1.close();
ServerSocket ss2 = new ServerSocket();
ss2.bind(new InetSocketAddress("127.0.0.1", 4343));
assertEquals(ss2.getLocalPort(), 4343);
ss2.close();
ServerSocket ss3 = new ServerSocket(0);
assertTrue(ss3.getLocalPort() != 0);
ss3.close();
}
/**
* @tests java.net.ServerSocket#setSocketFactory(java.net.SocketImplFactory)
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "",
method = "setSocketFactory",
args = {java.net.SocketImplFactory.class}
)
public void test_setSocketFactoryLjava_net_SocketImplFactory() {
SecurityManager sm = new SecurityManager() {
public void checkPermission(Permission perm) {
}
public void checkSetFactory() {
throw new SecurityException();
}
};
MockSocketFactory sf = new MockSocketFactory();
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
ServerSocket.setSocketFactory(sf);
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} catch (IOException e) {
fail("IOException was thrown.");
} finally {
System.setSecurityManager(oldSm);
}
/*
* try {
* ServerSocket.setSocketFactory(sf);
* ServerSocket ss1 = new ServerSocket();
* assertTrue(isCreateCalled);
* isCreateCalled = false;
* ServerSocket ss2 = new ServerSocket(0);
* assertTrue(isCreateCalled);
* } catch(IOException ioe) {
* fail("IOException was thrown: " + ioe.toString());
* }
* try {
* ServerSocket.setSocketFactory(null);
* fail("IOException was not thrown.");
* } catch(IOException ioe) {
* //expected
* }
*/
}
class MockSocketFactory implements SocketImplFactory {
public SocketImpl createSocketImpl() {
return new MockSocketImpl();
}
}
}
|
