| /* |
| * 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. |
| */ |
| @Override |
| 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() { |
| @Override |
| 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() { |
| @Override |
| 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() { |
| @Override |
| 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() { |
| @Override |
| 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(); |
| } |
| |
| @Override |
| 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); |
| } |
| |
| } |
