/*
* 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 org.apache.harmony.xnet.provider.jsse;
import java.io.IOException;
import java.net.Socket;
import java.net.InetSocketAddress;
import javax.net.ssl.SSLServerSocket;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
/**
* SSLServerSocketImplTest test
*/
public class SSLServerSocketImplTest extends TestCase {
private static boolean doLog = false;
/**
* Sets up the test case.
*/
public void setUp() {
if (doLog) {
System.out.println("");
System.out.println("========================");
System.out.println("====== Running the test: " + getName());
}
}
private SSLServerSocket createSSLServerSocket() throws Exception {
return new SSLServerSocketImpl(JSSETestData.getSSLParameters());
}
/**
* SSLServerSocketImpl(SSLParameters sslParameters) method testing.
*/
public void testSSLServerSocketImpl1() throws Exception {
Client client = null;
SSLServerSocket ssocket = null;
try {
ssocket = new SSLServerSocketImpl(JSSETestData.getSSLParameters());
ssocket.bind(null);
ssocket.setUseClientMode(true);
final SSLServerSocket s = ssocket;
Thread thread = new Thread() {
public void run() {
try {
s.accept().close();
} catch (Exception e) { }
}
};
thread.start();
client = new Client(ssocket.getLocalPort());
client.start();
int timeout = 10; // wait no more than 5 seconds for handshake
while (!client.handshakeStarted()) {
// wait for handshake start
try {
Thread.sleep(500);
} catch (Exception e) { }
timeout--;
if (timeout < 0) {
try {
client.close();
} catch (IOException ex) { }
try {
ssocket.close();
} catch (IOException ex) { }
fail("Handshake was not started");
}
}
} finally {
if (client != null) {
try {
client.close();
} catch (IOException ex) { }
}
if (ssocket != null) {
try {
ssocket.close();
} catch (IOException ex) { }
}
}
}
/**
* SSLServerSocketImpl(int port, SSLParameters sslParameters) method
* testing.
*/
public void testSSLServerSocketImpl2() throws Exception {
Client client = null;
SSLServerSocket ssocket = null;
try {
ssocket = new SSLServerSocketImpl(0,
JSSETestData.getSSLParameters());
ssocket.setUseClientMode(true);
final SSLServerSocket s = ssocket;
Thread thread = new Thread() {
public void run() {
try {
s.accept().close();
} catch (Exception e) { }
}
};
thread.start();
client = new Client(ssocket.getLocalPort());
client.start();
int timeout = 10; // wait no more than 5 seconds for handshake
while (!client.handshakeStarted()) {
// wait for handshake start
try {
Thread.sleep(500);
} catch (Exception e) { }
timeout--;
if (timeout < 0) {
try {
client.close();
} catch (IOException ex) { }
try {
ssocket.close();
} catch (IOException ex) { }
fail("Handshake was not started");
}
}
} finally {
if (client != null) {
try {
client.close();
} catch (IOException ex) { }
}
if (ssocket != null) {
try {
ssocket.close();
} catch (IOException ex) { }
}
}
}
/**
* SSLServerSocketImpl(int port, int backlog,
* SSLParameters sslParameters) method testing.
*/
public void testSSLServerSocketImpl3() throws Exception {
Client client = null;
SSLServerSocket ssocket = null;
try {
ssocket = new SSLServerSocketImpl(0, 1,
JSSETestData.getSSLParameters());
ssocket.setUseClientMode(true);
final SSLServerSocket s = ssocket;
Thread thread = new Thread() {
public void run() {
try {
s.accept().close();
} catch (Exception e) { }
}
};
thread.start();
client = new Client(ssocket.getLocalPort());
client.start();
int timeout = 10; // wait no more than 5 seconds for handshake
while (!client.handshakeStarted()) {
// wait for handshake start
try {
Thread.sleep(500);
} catch (Exception e) { }
timeout--;
if (timeout < 0) {
try {
client.close();
} catch (IOException ex) { }
try {
ssocket.close();
} catch (IOException ex) { }
fail("Handshake was not started");
}
}
} finally {
if (client != null) {
try {
client.close();
} catch (IOException ex) { }
}
if (ssocket != null) {
try {
ssocket.close();
} catch (IOException ex) { }
}
}
}
/**
* SSLServerSocketImpl(int port, int backlog, InetAddress iAddress,
* SSLParameters sslParameters) method testing.
*/
public void testSSLServerSocketImpl4() throws Exception {
Client client = null;
SSLServerSocket ssocket = null;
try {
ssocket = new SSLServerSocketImpl(0, 1, null,
JSSETestData.getSSLParameters());
ssocket.setUseClientMode(true);
final SSLServerSocket s = ssocket;
Thread thread = new Thread() {
public void run() {
try {
s.accept().close();
} catch (Exception e) { }
}
};
thread.start();
client = new Client(ssocket.getLocalPort());
client.start();
int timeout = 10; // wait no more than 5 seconds for handshake
while (!client.handshakeStarted()) {
// wait for handshake start
try {
Thread.sleep(500);
} catch (Exception e) { }
timeout--;
if (timeout < 0) {
try {
client.close();
} catch (IOException ex) { }
try {
ssocket.close();
} catch (IOException ex) { }
fail("Handshake was not started");
}
}
} finally {
if (client != null) {
try {
client.close();
} catch (IOException ex) { }
}
if (ssocket != null) {
try {
ssocket.close();
} catch (IOException ex) { }
}
}
}
/**
* getSupportedCipherSuites() method testing.
*/
public void testGetSupportedCipherSuites() throws Exception {
SSLServerSocket ssocket = createSSLServerSocket();
String[] supported = ssocket.getSupportedCipherSuites();
assertNotNull(supported);
supported[0] = "NOT_SUPPORTED_CIPHER_SUITE";
supported = ssocket.getEnabledCipherSuites();
for (int i=0; i<supported.length; i++) {
if ("NOT_SUPPORTED_CIPHER_SUITE".equals(supported[i])) {
fail("Modification of the returned result "
+ "causes the modification of the internal state");
}
}
}
/**
* getEnabledCipherSuites() method testing.
*/
public void testGetEnabledCipherSuites() throws Exception {
SSLServerSocket ssocket = createSSLServerSocket();
String[] enabled = ssocket.getEnabledCipherSuites();
assertNotNull(enabled);
String[] supported = ssocket.getSupportedCipherSuites();
for (int i=0; i<enabled.length; i++) {
//System.out.println("Checking of "+enabled[i]);
found: {
for (int j=0; j<supported.length; j++) {
if (enabled[i].equals(supported[j])) {
break found;
}
}
fail("Enabled suite does not belong to the set "
+ "of supported cipher suites: " + enabled[i]);
}
}
ssocket.setEnabledCipherSuites(supported);
for (int i=0; i<supported.length; i++) {
enabled = new String[supported.length - i];
System.arraycopy(supported, 0,
enabled, 0, supported.length-i);
ssocket.setEnabledCipherSuites(enabled);
String[] result = ssocket.getEnabledCipherSuites();
if (result.length != enabled.length) {
fail("Returned result does not correspond to expected.");
}
for (int k=0; k<result.length; k++) {
found: {
for (int n=0; n<enabled.length; n++) {
if (result[k].equals(enabled[n])) {
break found;
}
}
if (result.length != enabled.length) {
fail("Returned result does not correspond "
+ "to expected.");
}
}
}
}
}
/**
* setEnabledCipherSuites(String[] suites) method testing.
*/
public void testSetEnabledCipherSuites() throws Exception {
SSLServerSocket ssocket = createSSLServerSocket();
String[] enabled = ssocket.getEnabledCipherSuites();
assertNotNull(enabled);
String[] supported = ssocket.getSupportedCipherSuites();
for (int i=0; i<enabled.length; i++) {
//System.out.println("Checking of "+enabled[i]);
found: {
for (int j=0; j<supported.length; j++) {
if (enabled[i].equals(supported[j])) {
break found;
}
}
fail("Enabled suite does not belong to the set "
+ "of supported cipher suites: " + enabled[i]);
}
}
ssocket.setEnabledCipherSuites(supported);
ssocket.setEnabledCipherSuites(enabled);
ssocket.setEnabledCipherSuites(supported);
String[] more_than_supported = new String[supported.length+1];
for (int i=0; i<supported.length+1; i++) {
more_than_supported[i]
= "NOT_SUPPORTED_CIPHER_SUITE";
System.arraycopy(supported, 0,
more_than_supported, 0, i);
System.arraycopy(supported, i,
more_than_supported, i+1, supported.length-i);
try {
ssocket.setEnabledCipherSuites(more_than_supported);
fail("Expected IllegalArgumentException was not thrown");
} catch (IllegalArgumentException e) { }
}
enabled = ssocket.getEnabledCipherSuites();
enabled[0] = "NOT_SUPPORTED_CIPHER_SUITE";
enabled = ssocket.getEnabledCipherSuites();
for (int i=0; i<enabled.length; i++) {
if ("NOT_SUPPORTED_CIPHER_SUITE".equals(enabled[i])) {
fail("Modification of the returned result "
+ "causes the modification of the internal state");
}
}
}
/**
* getSupportedProtocols() method testing.
*/
public void testGetSupportedProtocols() throws Exception {
SSLServerSocket ssocket = createSSLServerSocket();
String[] supported = ssocket.getSupportedProtocols();
assertNotNull(supported);
assertFalse(supported.length == 0);
supported[0] = "NOT_SUPPORTED_PROTOCOL";
supported = ssocket.getSupportedProtocols();
for (int i=0; i<supported.length; i++) {
if ("NOT_SUPPORTED_PROTOCOL".equals(supported[i])) {
fail("Modification of the returned result "
+ "causes the modification of the internal state");
}
}
}
/**
* getEnabledProtocols() method testing.
*/
public void testGetEnabledProtocols() throws Exception {
SSLServerSocket ssocket = createSSLServerSocket();
String[] enabled = ssocket.getEnabledProtocols();
assertNotNull(enabled);
String[] supported = ssocket.getSupportedProtocols();
for (int i=0; i<enabled.length; i++) {
//System.out.println("Checking of "+enabled[i]);
found: {
for (int j=0; j<supported.length; j++) {
if (enabled[i].equals(supported[j])) {
break found;
}
}
fail("Enabled protocol does not belong to the set "
+ "of supported protocols: " + enabled[i]);
}
}
ssocket.setEnabledProtocols(supported);
for (int i=0; i<supported.length; i++) {
enabled = new String[supported.length - i];
System.arraycopy(supported, i,
enabled, 0, supported.length-i);
//System.out.println("");
//for (int k=0; k<supported.length - i; k++) {
// System.out.println("---- "+enabled[k]);
//}
ssocket.setEnabledProtocols(enabled);
String[] result = ssocket.getEnabledProtocols();
if (result.length != enabled.length) {
fail("Returned result does not correspond to expected.");
}
for (int k=0; k<result.length; k++) {
found: {
for (int n=0; n<enabled.length; n++) {
if (result[k].equals(enabled[n])) {
break found;
}
}
if (result.length != enabled.length) {
fail("Returned result does not correspond "
+ "to expected.");
}
}
}
}
}
/**
* setEnabledProtocols(String[] protocols) method testing.
*/
public void testSetEnabledProtocols() throws Exception {
SSLServerSocket ssocket = createSSLServerSocket();
String[] enabled = ssocket.getEnabledProtocols();
assertNotNull(enabled);
String[] supported = ssocket.getSupportedProtocols();
for (int i=0; i<enabled.length; i++) {
//System.out.println("Checking of "+enabled[i]);
found: {
for (int j=0; j<supported.length; j++) {
if (enabled[i].equals(supported[j])) {
break found;
}
}
fail("Enabled suite does not belong to the set "
+ "of supported cipher suites: " + enabled[i]);
}
}
ssocket.setEnabledProtocols(supported);
ssocket.setEnabledProtocols(enabled);
ssocket.setEnabledProtocols(supported);
String[] more_than_supported = new String[supported.length+1];
for (int i=0; i<supported.length+1; i++) {
more_than_supported[i]
= "NOT_SUPPORTED_PROTOCOL";
System.arraycopy(supported, 0,
more_than_supported, 0, i);
System.arraycopy(supported, i,
more_than_supported, i+1, supported.length-i);
try {
ssocket.setEnabledProtocols(more_than_supported);
fail("Expected IllegalArgumentException was not thrown");
} catch (IllegalArgumentException e) { }
}
enabled = ssocket.getEnabledProtocols();
enabled[0] = "NOT_SUPPORTED_PROTOCOL";
enabled = ssocket.getEnabledProtocols();
for (int i=0; i<enabled.length; i++) {
if ("NOT_SUPPORTED_PROTOCOL".equals(enabled[i])) {
fail("Modification of the returned result "
+ "causes the modification of the internal state");
}
}
}
/**
* setUseClientMode(boolean mode) method testing.
* getUseClientMode() method testing.
*/
public void testSetGetUseClientMode() throws Exception {
SSLServerSocket ssocket = createSSLServerSocket();
ssocket.setUseClientMode(false);
assertFalse("Result does not correspond to expected",
ssocket.getUseClientMode());
ssocket.setUseClientMode(true);
assertTrue("Result does not correspond to expected",
ssocket.getUseClientMode());
}
/**
* setNeedClientAuth(boolean need) method testing.
* getNeedClientAuth() method testing.
*/
public void testSetGetNeedClientAuth() throws Exception {
SSLServerSocket ssocket = createSSLServerSocket();
ssocket.setWantClientAuth(true);
ssocket.setNeedClientAuth(false);
assertFalse("Result does not correspond to expected",
ssocket.getNeedClientAuth());
assertFalse("Socket did not reset its want client auth state",
ssocket.getWantClientAuth());
ssocket.setWantClientAuth(true);
ssocket.setNeedClientAuth(true);
assertTrue("Result does not correspond to expected",
ssocket.getNeedClientAuth());
assertFalse("Socket did not reset its want client auth state",
ssocket.getWantClientAuth());
}
/**
* setWantClientAuth(boolean want) method testing.
* getWantClientAuth() method testing.
*/
public void testSetGetWantClientAuth() throws Exception {
SSLServerSocket ssocket = createSSLServerSocket();
ssocket.setNeedClientAuth(true);
ssocket.setWantClientAuth(false);
assertFalse("Result does not correspond to expected",
ssocket.getWantClientAuth());
assertFalse("Socket did not reset its want client auth state",
ssocket.getNeedClientAuth());
ssocket.setNeedClientAuth(true);
ssocket.setWantClientAuth(true);
assertTrue("Result does not correspond to expected",
ssocket.getWantClientAuth());
assertFalse("Socket did not reset its want client auth state",
ssocket.getNeedClientAuth());
}
/**
* setEnableSessionCreation(boolean flag) method testing.
* getEnableSessionCreation() method testing.
*/
public void testSetGetEnableSessionCreation() throws Exception {
SSLServerSocket ssocket = createSSLServerSocket();
ssocket.setEnableSessionCreation(false);
assertFalse("Result does not correspond to expected",
ssocket.getEnableSessionCreation());
ssocket.setEnableSessionCreation(true);
assertTrue("Result does not correspond to expected",
ssocket.getEnableSessionCreation());
}
/**
* toString() method testing.
*/
public void testToString() throws Exception {
SSLServerSocket ssocket = createSSLServerSocket();
assertNotNull("String representation is null", ssocket.toString());
}
private static class Client extends Thread {
private boolean closed;
private boolean handshake_started = false;
private Socket client = null;
private int port;
public Client(int port) throws IOException {
super();
this.port = port;
client = new Socket();
client.setSoTimeout(10000);
}
public int getPort() {
return client.getLocalPort();
}
public void run() {
while (!closed) {
try {
if (doLog) {
System.out.print(".");
}
if (!handshake_started) {
client.connect(
new InetSocketAddress("localhost", port));
client.getInputStream().read();
handshake_started = true;
}
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
}
if (client != null) {
try {
client.close();
} catch (IOException e) { }
}
//System.out.println("===== client has been stopped");
}
public boolean handshakeStarted() {
return handshake_started;
}
public void close() throws IOException {
closed = true;
client.close();
}
};
public static Test suite() {
return new TestSuite(SSLServerSocketImplTest.class);
}
public static void main(String[] args) {
junit.textui.TestRunner.run(suite());
}
}