You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by te...@apache.org on 2007/02/04 09:10:11 UTC
svn commit: r503371 [3/5] - in
/harmony/enhanced/classlib/trunk/modules/x-net: ./ META-INF/
src/main/java/org/apache/harmony/xnet/provider/jsse/
src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/
src/test/impl/java.injected/org/apache/harmo...
Added: harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLEngineImplTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLEngineImplTest.java?view=auto&rev=503371
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLEngineImplTest.java (added)
+++ harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLEngineImplTest.java Sun Feb 4 00:10:09 2007
@@ -0,0 +1,1381 @@
+/*
+ * 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.nio.ByteBuffer;
+import java.util.Arrays;
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.SSLEngineResult;
+import javax.net.ssl.SSLException;
+import javax.net.ssl.SSLSession;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+/**
+ * SSLEngine implementation test.
+ */
+public class SSLEngineImplTest extends TestCase {
+
+ /**
+ * The cipher suites used for functionality testing.
+ */
+ private static final String[] cipher_suites = {
+ "RSA_WITH_RC4_128_MD5",
+ "RSA_WITH_DES_CBC_SHA",
+ "DH_anon_EXPORT_WITH_DES40_CBC_SHA"
+ };
+
+ /**
+ * Test logging switch.
+ */
+ private static boolean doLog = false;
+
+ /**
+ * Sets up the test case.
+ */
+ public void setUp() throws Exception {
+ if (doLog) {
+ System.out.println("");
+ System.out.println("========================");
+ System.out.println("====== Running the test: " + getName());
+ System.out.println("========================");
+ }
+ }
+
+ /**
+ * Tests the interaction between the engines.
+ */
+ public void testSelfInteraction() throws Exception {
+ String[] protocols = {"SSLv3", "TLSv1"};
+ for (int i=0; i<cipher_suites.length; i++) {
+ for (int j=0; j<2; j++) {
+ if (doLog) {
+ System.out.println("\n===== Interact over suite: "
+ + cipher_suites[i]);
+ }
+ SSLEngine client = getEngine();
+ SSLEngine server = getEngine();
+ initEngines(client, server);
+
+ doHandshake(client, server);
+ doDataExchange(client, server);
+ doClose(client, server);
+ }
+ }
+ }
+
+ /**
+ * Tests the session negotiation process.
+ */
+ public void testHandshake() throws Exception {
+ SSLEngine client = getEngine();
+ SSLEngine server = getEngine();
+
+ initEngines(client, server);
+
+ // checks the impossibility of initial handshake
+ // with the server not allowed to session creation
+ doNoRenegotiationTest(client, server, true);
+
+ client = getEngine();
+ server = getEngine();
+ initEngines(client, server);
+
+ client.setUseClientMode(true);
+ server.setUseClientMode(false);
+
+ // do initial handshake
+ doHandshake(client, server);
+
+ // client initiates rehandshake
+ client.beginHandshake();
+ doHandshakeImpl(client, server);
+
+ // server initiates rehandshake
+ server.beginHandshake();
+ doHandshakeImpl(client, server);
+
+ // client initiates rehandshake while server invalidates
+ // used session
+ server.getSession().invalidate();
+ client.beginHandshake();
+ doHandshakeImpl(client, server);
+
+ // server initiates rehandshake while client invalidates
+ // used session
+ client.getSession().invalidate();
+ server.beginHandshake();
+ doHandshakeImpl(client, server);
+
+ client.getSession().invalidate();
+ server.getSession().invalidate();
+ doHandshake(client, server);
+
+ doNoRenegotiationTest(client, server, false);
+
+ doNoRenegotiationTest(server, client, false);
+
+ doClose(client, server);
+ }
+
+ /**
+ * setNeedClientAuth(boolean need) method testing.
+ * getNeedClientAuth() method testing.
+ */
+ public void testSetGetNeedClientAuth() throws Exception {
+ SSLEngine engine = getEngine();
+
+ engine.setWantClientAuth(true);
+ engine.setNeedClientAuth(false);
+ assertFalse("Result differs from expected",
+ engine.getNeedClientAuth());
+ assertFalse("Socket did not reset its want client auth state",
+ engine.getWantClientAuth());
+ engine.setWantClientAuth(true);
+ engine.setNeedClientAuth(true);
+ assertTrue("Result differs from expected",
+ engine.getNeedClientAuth());
+ assertFalse("Socket did not reset its want client auth state",
+ engine.getWantClientAuth());
+ }
+
+ /**
+ * setWantClientAuth(boolean want) method testing.
+ * getWantClientAuth() method testing.
+ */
+ public void testSetGetWantClientAuth() throws Exception {
+ SSLEngine engine = getEngine();
+
+ engine.setNeedClientAuth(true);
+ engine.setWantClientAuth(false);
+ assertFalse("Result differs from expected",
+ engine.getWantClientAuth());
+ assertFalse("Socket did not reset its want client auth state",
+ engine.getNeedClientAuth());
+ engine.setNeedClientAuth(true);
+ engine.setWantClientAuth(true);
+ assertTrue("Result differs from expected",
+ engine.getWantClientAuth());
+ assertFalse("Socket did not reset its want client auth state",
+ engine.getNeedClientAuth());
+ }
+
+ /**
+ * getSupportedCipherSuites() method testing.
+ */
+ public void testGetSupportedCipherSuites() throws Exception {
+ SSLEngine engine = getEngine();
+ String[] supported = engine.getSupportedCipherSuites();
+ assertNotNull(supported);
+ supported[0] = "NOT_SUPPORTED_CIPHER_SUITE";
+ supported = engine.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 {
+ SSLEngine engine = getEngine();
+ String[] enabled = engine.getEnabledCipherSuites();
+ assertNotNull(enabled);
+ String[] supported = engine.getSupportedCipherSuites();
+ for (int i=0; i<enabled.length; 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]);
+ }
+ }
+ engine.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);
+ engine.setEnabledCipherSuites(enabled);
+ String[] result = engine.getEnabledCipherSuites();
+ if (result.length != enabled.length) {
+ fail("Returned result differs from 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 {
+ SSLEngine engine = getEngine();
+ String[] enabled = engine.getEnabledCipherSuites();
+ assertNotNull(enabled);
+ String[] supported = engine.getSupportedCipherSuites();
+ for (int i=0; i<enabled.length; 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]);
+ }
+ }
+ engine.setEnabledCipherSuites(supported);
+ engine.setEnabledCipherSuites(enabled);
+ engine.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 {
+ engine.setEnabledCipherSuites(more_than_supported);
+ fail("Expected IllegalArgumentException was not thrown");
+ } catch (IllegalArgumentException e) { }
+ }
+ enabled = engine.getEnabledCipherSuites();
+ enabled[0] = "NOT_SUPPORTED_CIPHER_SUITE";
+ enabled = engine.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 {
+ SSLEngine engine = getEngine();
+ String[] supported = engine.getSupportedProtocols();
+ assertNotNull(supported);
+ assertFalse(supported.length == 0);
+ supported[0] = "NOT_SUPPORTED_PROTOCOL";
+ supported = engine.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 {
+ SSLEngine engine = getEngine();
+ String[] enabled = engine.getEnabledProtocols();
+ assertNotNull(enabled);
+ String[] supported = engine.getSupportedProtocols();
+ for (int i=0; i<enabled.length; 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]);
+ }
+ }
+ engine.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);
+ engine.setEnabledProtocols(enabled);
+ String[] result = engine.getEnabledProtocols();
+ if (result.length != enabled.length) {
+ fail("Returned result differs from 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.");
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * setUseClientMode(boolean mode) method testing.
+ * getUseClientMode() method testing.
+ */
+ public void testSetGetUseClientMode() throws Exception {
+ SSLEngine engine = getEngine();
+
+ engine.setUseClientMode(false);
+ assertFalse("Result differs from expected",
+ engine.getUseClientMode());
+ engine.setUseClientMode(true);
+ assertTrue("Result differs from expected",
+ engine.getUseClientMode());
+
+ engine.beginHandshake();
+ try {
+ engine.setUseClientMode(false);
+ fail("Expected IllegalArgumentException was not thrown");
+ } catch (IllegalArgumentException e) { }
+
+ engine.wrap(ByteBuffer.allocate(0), ByteBuffer.allocate(
+ engine.getSession().getPacketBufferSize()));
+ try {
+ engine.setUseClientMode(false);
+ fail("Expected IllegalArgumentException was not thrown");
+ } catch (IllegalArgumentException e) { }
+ }
+
+ /**
+ * setEnableSessionCreation(boolean flag) method testing.
+ * getEnableSessionCreation() method testing.
+ */
+ public void testSetGetEnableSessionCreation() throws Exception {
+ SSLEngine engine = getEngine();
+
+ engine.setEnableSessionCreation(false);
+ assertFalse("Result differs from expected",
+ engine.getEnableSessionCreation());
+ engine.setEnableSessionCreation(true);
+ assertTrue("Result differs from expected",
+ engine.getEnableSessionCreation());
+ }
+
+ /**
+ * getSession() method testing.
+ */
+ public void testGetSession() throws Exception {
+ SSLEngine engine = getEngine();
+
+ SSLSession session = engine.getSession();
+ if ((session == null)
+ || (!session.getCipherSuite()
+ .endsWith("_NULL_WITH_NULL_NULL"))) {
+ fail("Returned session is null "
+ + "or not TLS_NULL_WITH_NULL_NULL");
+ }
+ }
+
+ /**
+ * beginHandshake() method testing
+ *
+ */
+ public void testBeginHandshake() throws Exception {
+ SSLEngine engine = getEngine();
+ assertEquals("Incorrect initial handshake status",
+ engine.getHandshakeStatus(),
+ SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING);
+ try {
+ engine.beginHandshake();
+ fail("Expected IllegalStateException was not thrown");
+ } catch (IllegalStateException e) { }
+
+ engine = getEngine();
+ engine.setUseClientMode(false);
+ engine.beginHandshake();
+ assertEquals("Incorrect initial handshake status",
+ engine.getHandshakeStatus(),
+ SSLEngineResult.HandshakeStatus.NEED_UNWRAP);
+
+ engine = getEngine();
+ engine.setUseClientMode(true);
+ engine.beginHandshake();
+ assertEquals("Incorrect initial handshake status",
+ engine.getHandshakeStatus(),
+ SSLEngineResult.HandshakeStatus.NEED_WRAP);
+ }
+
+ /**
+ * closeOutbound() method testing.
+ */
+ public void testCloseOutbound() throws Exception {
+ SSLEngine engine = getEngine();
+ assertFalse(engine.isOutboundDone());
+ engine.closeOutbound();
+ SSLEngineResult result = engine.wrap(ByteBuffer.allocate(0),
+ ByteBuffer.allocate(20000));
+ assertEquals("Incorrect status", result.getStatus(),
+ SSLEngineResult.Status.CLOSED);
+ assertEquals("Incorrect status", result.getHandshakeStatus(),
+ SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING);
+ try {
+ // should throw SSLException "engine already closed"
+ engine.beginHandshake();
+ fail("Expected exception was not thrown.");
+ } catch (SSLException e) { }
+ assertTrue(engine.isOutboundDone());
+ }
+
+ /**
+ * closeInbound() method testing.
+ */
+ public void testCloseInbound() throws Exception {
+ SSLEngine engine = getEngine();
+ assertFalse(engine.isInboundDone());
+ engine.closeInbound();
+ SSLEngineResult result = engine.wrap(ByteBuffer.allocate(0),
+ ByteBuffer.allocate(20000));
+ assertEquals("Incorrect status", result.getStatus(),
+ SSLEngineResult.Status.CLOSED);
+ assertEquals("Incorrect status", result.getHandshakeStatus(),
+ SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING);
+ try {
+ // should throw SSLException "engine already closed"
+ engine.beginHandshake();
+ fail("Expected exception was not thrown.");
+ } catch (SSLException e) { }
+ assertTrue(engine.isInboundDone());
+ }
+
+ /**
+ * closeInbound() method testing.
+ * Tests error processing in the case of unexpected closeInbound.
+ */
+ public void testCloseInbound2() throws Exception {
+ SSLEngine client = getEngine();
+ SSLEngine server = getEngine();
+ initEngines(client, server);
+
+ int packetBufferSize =
+ client.getSession().getPacketBufferSize();
+ int applicationBufferSize =
+ server.getSession().getApplicationBufferSize();
+
+ ByteBuffer buffer = ByteBuffer.allocate(packetBufferSize);
+ ByteBuffer app_data_buffer = ByteBuffer.allocate(applicationBufferSize);
+
+ client.setUseClientMode(true);
+ server.setUseClientMode(false);
+
+ doHandshake(client, server);
+
+ if (doLog) {
+ System.out.println("\nError processing test:");
+ }
+ try {
+ // should cause SSLException, prepare fatal alert "internal error",
+ // and set HandshakeStatus to NEED_WRAP
+ // (to send alert to another side)
+ server.closeInbound();
+ fail("Expected exception was not thrown.");
+ } catch (Exception e) {
+ if (doLog) {
+ System.out.println("Server threw exception: "
+ + e.getMessage());
+ }
+ // e.printStackTrace();
+ // should do nothing
+ server.closeInbound();
+ assertEquals("Unexpected status:",
+ SSLEngineResult.HandshakeStatus.NEED_WRAP,
+ server.getHandshakeStatus());
+
+ if (doLog) {
+ System.out.println("Wrapping of the alert message");
+ }
+ SSLEngineResult result = null;
+ print(result = server.wrap(ByteBuffer.allocate(0), buffer));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.CLOSED,
+ result.getStatus());
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING,
+ result.getHandshakeStatus());
+ assertTrue(
+ "The length of the consumed data differs from expected",
+ 0 == result.bytesConsumed());
+ assertTrue(
+ "The length of the produced data differs from expected",
+ result.bytesProduced() > 0);
+ // tune buffer to be read
+ buffer.flip();
+ try {
+ // should rethrow the SSLException "internal error"
+ print(client.unwrap(buffer, app_data_buffer));
+ fail("Expected exception was not thrown.");
+ } catch (Exception ex) {
+ if (doLog) {
+ System.out.println("Client rethrew received alert: "
+ + ex.getMessage());
+ }
+ // NOT_HANDSHAKING..
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING,
+ client.getHandshakeStatus());
+ client.closeOutbound();
+ // NEED_WRAP.. should it be so? it contradicts to the TLS spec:
+ // "Upon transmission or receipt of an fatal alert message, both
+ // parties immediately close the connection. Servers and clients
+ // are required to forget any session-identifiers, keys, and
+ // secrets associated with a failed connection."
+ // So in this case we expect NOT_HANDSHAKING
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING,
+ client.getHandshakeStatus());
+ assertTrue("Outbound should be closed.",
+ client.isOutboundDone());
+ assertTrue("Inbound should be closed.",
+ client.isInboundDone());
+ }
+ }
+ }
+
+ /**
+ * closeInbound() method testing.
+ * Tests error processing
+ */
+ public void testErrorProcessing() throws Exception {
+ SSLEngine client = getEngine();
+ SSLEngine server = getEngine();
+ initEngines(client, server);
+
+ int packetBufferSize =
+ client.getSession().getPacketBufferSize();
+ int applicationBufferSize =
+ server.getSession().getApplicationBufferSize();
+
+ ByteBuffer buffer = ByteBuffer.allocate(packetBufferSize);
+ ByteBuffer app_data_buffer = ByteBuffer.allocate(applicationBufferSize);
+
+ client.setUseClientMode(true);
+ server.setUseClientMode(false);
+
+ doHandshake(client, server);
+
+ if (doLog) {
+ System.out.println("\nError processing test:");
+ }
+ try {
+ print(server.unwrap(ByteBuffer.allocate(40), app_data_buffer));
+ fail("Expected exception was not thrown.");
+ } catch (Exception e) {
+ if (doLog) {
+ System.out.println("\nServer threw exception: "
+ +e.getMessage());
+ }
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NEED_WRAP,
+ server.getHandshakeStatus());
+
+ SSLEngineResult result = null;
+ assertFalse("Outbound should not be closed.",
+ server.isOutboundDone());
+ assertTrue("Inbound should be closed.",
+ server.isInboundDone());
+
+ if (doLog) {
+ System.out.println(
+ "\nServer tries to unwrap the data after error");
+ }
+ print(result =
+ server.unwrap(ByteBuffer.allocate(40), app_data_buffer));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.CLOSED,
+ result.getStatus());
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NEED_WRAP,
+ result.getHandshakeStatus());
+ assertTrue(
+ "The length of the consumed data differs from expected",
+ 0 == result.bytesConsumed());
+ assertTrue(
+ "The length of the produced data differs from expected",
+ 0 == result.bytesProduced());
+
+ if (doLog) {
+ System.out.println("\nServer wraps the fatal alert");
+ }
+ print(result = server.wrap(ByteBuffer.allocate(0), buffer));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.CLOSED,
+ result.getStatus());
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING,
+ result.getHandshakeStatus());
+ assertTrue(
+ "The length of the consumed data differs from expected",
+ 0 == result.bytesConsumed());
+ assertTrue(
+ "The length of the produced data differs from expected",
+ result.bytesProduced() > 0);
+
+ assertTrue("Outbound should be closed.",
+ server.isOutboundDone());
+ assertTrue("Inbound should be closed.",
+ server.isInboundDone());
+
+ buffer.flip();
+ try {
+ if (doLog) {
+ System.out.println("\nClient unwraps the fatal alert");
+ }
+ print(client.unwrap(buffer, app_data_buffer));
+ fail("Expected exception was not thrown.");
+ } catch (Exception ex) {
+ if (doLog) {
+ System.out.println("\nClient rethrew the exception: "
+ + ex.getMessage());
+ }
+ // NOT_HANDSHAKING..
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING,
+ client.getHandshakeStatus());
+ client.closeOutbound();
+ // NEED_WRAP.. should it be so? it contradicts to the TLS spec:
+ // "Upon transmission or receipt of an fatal alert message, both
+ // parties immediately close the connection. Servers and clients
+ // are required to forget any session-identifiers, keys, and
+ // secrets associated with a failed connection."
+ // So in this case we expect NOT_HANDSHAKING
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING,
+ client.getHandshakeStatus());
+ assertTrue("Outbound should be closed.",
+ client.isOutboundDone());
+ assertTrue("Inbound should be closed.",
+ client.isInboundDone());
+ }
+ }
+ }
+
+
+ // --------------------------------------------------------------------
+ // ------------------------ Staff methods -----------------------------
+ // --------------------------------------------------------------------
+
+ /*
+ * Performs the handshake over the specified engines
+ */
+ private void doHandshake(SSLEngine client,
+ SSLEngine server) throws Exception {
+ if (doLog) {
+ System.out.println("\n--- doHandshake:");
+ System.out.println("Server: "+server.getSession().getClass());
+ System.out.println("Client: "+client.getSession().getClass());
+ }
+
+ client.beginHandshake();
+ server.beginHandshake();
+
+ doHandshakeImpl(client, server);
+ }
+
+ /*
+ * Performs the handshake over the specified engines.
+ * Note that method passes app data between the engines during
+ * the handshake process.
+ */
+ private void doHandshakeImpl(SSLEngine client,
+ SSLEngine server) throws Exception {
+ if (doLog) {
+ System.out.println("\n--- doHandshakeImpl:");
+ System.out.println("Client's hsh status: "
+ + client.getHandshakeStatus());
+ System.out.println("Client's session: "+client.getSession());
+ System.out.println("Server's hsh status: "
+ + server.getHandshakeStatus());
+ System.out.println("Server's session: "+server.getSession());
+ }
+
+ int packetBufferSize =
+ client.getSession().getPacketBufferSize();
+ int applicationBufferSize =
+ server.getSession().getApplicationBufferSize();
+
+ // buffer will contain handshake messages
+ ByteBuffer clients_buffer = ByteBuffer.allocate(packetBufferSize+1000);
+ ByteBuffer servers_buffer = ByteBuffer.allocate(packetBufferSize+1000);
+ // buffers will contain application data messages
+ ByteBuffer app_data = ByteBuffer.allocate(packetBufferSize);
+ ByteBuffer app_data_plain = ByteBuffer.allocate(applicationBufferSize);
+
+ SSLEngine[] engines = new SSLEngine[] {client, server};
+ ByteBuffer[] buffers =
+ new ByteBuffer[] {clients_buffer, servers_buffer};
+
+ // choose which peer will start handshake negotiation
+ // (initial handshake is initiated by client, but rehandshake
+ // can be initiated by any peer)
+ int step = (client.getHandshakeStatus()
+ != SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING) ? 0 : 1;
+
+ SSLEngine current_engine = engines[step];
+ ByteBuffer buffer;
+ SSLEngineResult result = null;
+ SSLEngineResult.HandshakeStatus status;
+
+ while ((client.getHandshakeStatus()
+ != SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING)
+ || (server.getHandshakeStatus()
+ != SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING)) {
+ if (doLog) {
+ System.out.print("\n"
+ + ((current_engine == client) ? "CLIENT " : "SERVER "));
+ }
+ status = current_engine.getHandshakeStatus();
+ if (status == SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING) {
+ // so another peer produced
+ // the handshaking data which has to be unwrapped
+ if (doLog) {
+ System.out.print("(NOT_HANDSHAKING) ");
+ }
+ status = SSLEngineResult.HandshakeStatus.NEED_UNWRAP;
+ }
+ if (status == SSLEngineResult.HandshakeStatus.NEED_WRAP) {
+ if (doLog) {
+ System.out.println("NEED_WRAP");
+ }
+ // will wrap handshake data into its special buffer
+ buffer = buffers[step];
+ if (buffer.remaining() == 0) {
+ // handshake data was fully read by another peer,
+ // so we need clear the buffer before reusing it
+ buffer.clear();
+ }
+ // wrap the next handshake message
+ print(result = current_engine.wrap(app_data, buffer));
+ // if there are no any messages to send, switch the engine
+ if (current_engine.getHandshakeStatus()
+ != SSLEngineResult.HandshakeStatus.NEED_WRAP) {
+ // switch the current engine
+ step ^= 1;
+ current_engine = engines[step];
+ // and prepare the buffer for reading
+ buffer.flip();
+ }
+ } else if (status == SSLEngineResult.HandshakeStatus.NEED_UNWRAP) {
+ if (doLog) {
+ System.out.println("NEED_UNWRAP");
+ }
+
+ // If there are no unread handshake messages produced by the
+ // current engine, try to wrap the application data and unwrap
+ // it by another engine. It will test app data flow during
+ // the rehandshake.
+ if (!buffers[step].hasRemaining()) {
+ if (doLog) {
+ System.out.println(
+ "\nTry to WRAP the application data");
+ }
+ print(result = current_engine.wrap(
+ ByteBuffer.wrap(new byte[] {0}), app_data));
+ // The output in app_data will be produced only if it
+ // is rehandshaking stage
+ // (i.e. initial handshake has been done)
+ if (result.bytesProduced() > 0) {
+ // if the app data message has been produced,
+ // unwrap it by another peer
+ if (doLog) {
+ System.out.print("\n" + ((current_engine != client)
+ ? "CLIENT " : "SERVER "));
+ System.out.println(
+ "UNWRAPs app data sent during handshake");
+ }
+ app_data.flip();
+ print(result = engines[(step+1)%2].unwrap(
+ app_data, app_data_plain));
+ app_data.clear();
+ app_data_plain.clear();
+ }
+ }
+
+ buffer = buffers[step^1];
+
+ // check if there is handshake data to be unwrapped
+ if (buffer.remaining() == 0) {
+ if (doLog) {
+ System.out.println(
+ "There is no handshake data to be unwrapped.");
+ }
+ // switch the current engine
+ step ^= 1;
+ current_engine = engines[step];
+ if ((current_engine.getHandshakeStatus()
+ == SSLEngineResult.HandshakeStatus.NEED_UNWRAP)
+ && (buffers[step^1].remaining() == 0)) {
+ System.out.println(
+ "Both engines are in NEED_UNWRAP state");
+ fail("Both engines are in NEED_UNWRAP state");
+ }
+ continue;
+ }
+
+ print(result = current_engine.unwrap(buffer, app_data));
+ if (current_engine.getHandshakeStatus()
+ == SSLEngineResult.HandshakeStatus.NEED_TASK) {
+ if (doLog) {
+ System.out.println("NEED_TASK");
+ }
+ current_engine.getDelegatedTask().run();
+ if (doLog) {
+ System.out.println("status after the task: "
+ +current_engine.getHandshakeStatus());
+ }
+ }
+ } else {
+ fail("Unexpected HandshakeStatus: "+status);
+ }
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.OK,
+ result.getStatus());
+ }
+ }
+
+ /*
+ * Performs the session renegotiation process when one
+ * of the peers is not allowed to create the session.
+ */
+ private void doNoRenegotiationTest(SSLEngine allowed,
+ SSLEngine not_allowed, boolean is_initial) throws Exception {
+ if (doLog) {
+ System.out.println(
+ "\n--- doNoRenegotiationTest: is_initial: "+is_initial);
+ }
+
+ not_allowed.setEnableSessionCreation(false);
+ not_allowed.getSession().invalidate();
+
+ int packetBufferSize =
+ allowed.getSession().getPacketBufferSize();
+ int applicationBufferSize =
+ not_allowed.getSession().getApplicationBufferSize();
+
+ // buffer will contain handshake messages
+ ByteBuffer buffer = ByteBuffer.allocate(packetBufferSize+1000);
+ // buffers will contain application data messages
+ ByteBuffer app_data = ByteBuffer.allocate(packetBufferSize);
+ ByteBuffer app_data_plain = ByteBuffer.allocate(applicationBufferSize);
+
+ SSLEngineResult result = null;
+
+ allowed.beginHandshake();
+ //not_allowed.beginHandshake();
+
+ if (doLog) {
+ System.out.println(
+ "\nAllowed peer wraps the initial session negotiation message");
+ }
+ // wrap the initial session negotiation message
+ while (allowed.getHandshakeStatus().equals(
+ SSLEngineResult.HandshakeStatus.NEED_WRAP)) {
+ print(result = allowed.wrap(app_data_plain, buffer));
+ assertTrue("Engine did not produce any data",
+ result.bytesProduced() > 0);
+ }
+ // prepare the buffer for reading
+ buffer.flip();
+ if (doLog) {
+ System.out.println("\nNot allowed unwraps the message");
+ }
+ try {
+ // unwrap the message. expecting whether SSLException or NEED_WRAP
+ print(result = not_allowed.unwrap(buffer, app_data_plain));
+ } catch (SSLException e) {
+ if (is_initial) {
+ return; // ok, exception was thrown
+ } else {
+ fail("Unexpected SSLException was thrown "+e);
+ }
+ }
+ // if it is not an initial handshake phase it is posible
+ // SSLException to be thrown.
+ try {
+ while (!not_allowed.getHandshakeStatus().equals(
+ SSLEngineResult.HandshakeStatus.NEED_WRAP)) {
+ assertTrue("Engine did not consume any data",
+ result.bytesConsumed() > 0);
+ if (not_allowed.getHandshakeStatus().equals(
+ SSLEngineResult.HandshakeStatus.NEED_TASK)) {
+ not_allowed.getDelegatedTask().run();
+ if (doLog) {
+ System.out.println("Status after the task: "
+ + not_allowed.getHandshakeStatus());
+ }
+ continue;
+ } else if (not_allowed.getHandshakeStatus().equals(
+ SSLEngineResult.HandshakeStatus.NEED_UNWRAP)) {
+ print(result = not_allowed.unwrap(buffer, app_data_plain));
+ } else {
+ fail("Unexpected status of operation: "
+ + not_allowed.getHandshakeStatus());
+ }
+ }
+ // prepare for writting
+ buffer.clear();
+ if (doLog) {
+ System.out.println(
+ "\nWrapping the message. Expecting no_renegotiation alert");
+ }
+ // wrapping the message. expecting no_renegotiation alert
+ print(result = not_allowed.wrap(app_data_plain, buffer));
+ } catch (SSLException e) {
+ if (!is_initial) {
+ fail("Unexpected SSLException was thrown."+e.getMessage());
+ }
+ if (doLog) {
+ System.out.println("Throwed exception during the unwrapping "
+ + "of handshake initiation message:");
+ e.printStackTrace();
+ System.out.println("Handshake Status: "
+ + not_allowed.getHandshakeStatus());
+ }
+ if (not_allowed.getHandshakeStatus().equals(
+ SSLEngineResult.HandshakeStatus.NEED_WRAP)) {
+ // needs to wrap fatal alert message
+ if (doLog) {
+ System.out.println(
+ "\nnot_allowed wraps fatal alert message");
+ }
+ // prepare for writting
+ buffer.clear();
+ print(result = not_allowed.wrap(app_data_plain, buffer));
+ }
+ }
+ // check whether alert message has been sent
+ assertTrue("Engine did not produce any data",
+ result.bytesProduced() > 0);
+ // check whether not_allowed engine stoped handshake operation
+ assertEquals("Unexpected status of operation: not_allowed "
+ + "to session creation peer did not stop its handshake process",
+ SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING,
+ not_allowed.getHandshakeStatus());
+ // prepare for reading
+ buffer.flip();
+ try {
+ print(result = allowed.unwrap(buffer, app_data_plain));
+ assertTrue("Engine did not consume any data",
+ result.bytesConsumed() > 0);
+ assertEquals("Responce from the peer not allowed to create "
+ + "the session did not cause the stopping of "
+ + "the session negotiation process",
+ SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING,
+ result.getHandshakeStatus());
+ } catch (SSLException e) {
+ if (!is_initial) {
+ fail("Unexpected SSLException was thrown."+e.getMessage());
+ }
+ if (doLog) {
+ System.out.println("Throwed exception during the unwrapping "
+ + "of responce from allowed peer:");
+ e.printStackTrace();
+ System.out.println("Handshake Status: "
+ + not_allowed.getHandshakeStatus());
+ }
+ }
+ }
+
+ /*
+ * Tests the data exchange process between two engines
+ */
+ private void doDataExchange(SSLEngine client,
+ SSLEngine server) throws Exception {
+ if (doLog) {
+ System.out.println("\n--- doDataExchange:");
+ }
+ ByteBuffer co = ByteBuffer.allocate(
+ client.getSession().getPacketBufferSize());
+ ByteBuffer si = ByteBuffer.allocate(
+ server.getSession().getPacketBufferSize());
+ SSLEngineResult result;
+
+ String data_2b_sent = "data to be sent";
+ ByteBuffer data = ByteBuffer.wrap(data_2b_sent.getBytes());
+
+ if (doLog) {
+ System.out.println("\nTry to wrap the data into small buffer");
+ }
+ print(result = client.wrap(data, ByteBuffer.allocate(35)));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.BUFFER_OVERFLOW,
+ result.getStatus());
+
+ if (doLog) {
+ System.out.println("\nWrapping the data of length "
+ + data.remaining());
+ }
+ print(result = client.wrap(data, co));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.OK,
+ result.getStatus());
+
+ // tune the buffer to read from it
+ co.limit(co.position());
+ co.rewind();
+
+ if (doLog) {
+ System.out.println("\nTry to unwrap the data into small buffer");
+ }
+ print(result = server.unwrap(co, ByteBuffer.allocate(0)));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.BUFFER_OVERFLOW,
+ result.getStatus());
+ if (doLog) {
+ System.out.println("\nUnwrapping the data into buffer");
+ }
+ print(result = server.unwrap(co, si));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.OK,
+ result.getStatus());
+ assertTrue(
+ "The length of the received data differs from expected",
+ "data to be sent".length() == result.bytesProduced());
+
+ // take the data from the buffer
+ byte[] resulting_data = new byte[result.bytesProduced()];
+ si.rewind();
+ si.get(resulting_data);
+ si.clear();
+ assertTrue(Arrays.equals(data_2b_sent.getBytes(), resulting_data));
+
+ co.clear();
+ for (int i=1; i<10; i++) {
+ byte[] buff = new byte[i];
+ data = ByteBuffer.wrap(buff);
+ if (doLog) {
+ System.out.println("\nWrap the data");
+ }
+ print(result = client.wrap(data, co));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.OK,
+ result.getStatus());
+ if (doLog) {
+ System.out.println("\nUnwrap the data");
+ }
+ co.rewind();
+ print(result = server.unwrap(co, si));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.OK,
+ result.getStatus());
+ assertTrue(
+ "The length of the received data differs from expected",
+ i == result.bytesProduced());
+ resulting_data = new byte[i];
+ si.rewind();
+ si.get(resulting_data);
+ si.clear();
+ assertTrue(Arrays.equals(buff, resulting_data));
+ co.clear();
+ si.clear();
+ }
+ }
+
+ /*
+ * Performs the closure process over the two communicationg engines.
+ * The handshake process should be performed before the call of this
+ * method.
+ */
+ private void doClose(SSLEngine client, SSLEngine server) throws Exception {
+ if (doLog) {
+ System.out.println("\n--- doClose: ");
+ }
+ ByteBuffer buffer = ByteBuffer.allocate(
+ // +100 because we put the data into the buffer multiple times
+ server.getSession().getPacketBufferSize()+100);
+ ByteBuffer app_data_buffer = ByteBuffer.allocate(
+ client.getSession().getApplicationBufferSize());
+ SSLEngineResult result;
+ // first: send 0 just for fun
+ if (doLog) {
+ System.out.println("\nServer sends pending outboud data:");
+ }
+ print(result = server.wrap(ByteBuffer.wrap(new byte[] {0}), buffer));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.OK,
+ result.getStatus());
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING,
+ result.getHandshakeStatus());
+ // second: initiate a close
+ if (doLog) {
+ System.out.println("\nServer initiates a closure:");
+ }
+ server.closeOutbound();
+ // should do nothing:
+ server.closeOutbound();
+
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NEED_WRAP,
+ server.getHandshakeStatus());
+
+ // will cause SSLException because closure alert was not received yet:
+ // server.closeInbound();
+
+ // wrap closure alert (previosly sent 0 should not be lost)
+ print(result = server.wrap(ByteBuffer.allocate(0), buffer));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.CLOSED,
+ result.getStatus());
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NEED_UNWRAP,
+ result.getHandshakeStatus());
+
+ if (doLog) {
+ System.out.println("\nServer sends pending outboud data again:");
+ }
+ // will do nothing because closure alert has been sent
+ // and outbound has been closed
+ print(result = server.wrap(ByteBuffer.wrap(new byte[] {0}), buffer));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.CLOSED,
+ result.getStatus());
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NEED_UNWRAP,
+ result.getHandshakeStatus());
+ assertTrue(
+ "The length of the consumed data differs from expected",
+ 0 == result.bytesConsumed());
+ assertTrue(
+ "The length of the produced data differs from expected",
+ 0 == result.bytesProduced());
+
+ // prepare the buffer for reading
+ buffer.flip();
+
+ if (doLog) {
+ System.out.println(
+ "\nClient receives pending servers' outbound data");
+ }
+ print(result = client.unwrap(buffer, app_data_buffer));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.OK,
+ result.getStatus());
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING,
+ result.getHandshakeStatus());
+ assertTrue(
+ "The length of the produced data differs from expected",
+ 1 == result.bytesProduced());
+
+ app_data_buffer.clear();
+
+ if (doLog) {
+ System.out.println("\nClient receives close notify");
+ }
+ print(result = client.unwrap(buffer, app_data_buffer));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.CLOSED,
+ result.getStatus());
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NEED_WRAP,
+ result.getHandshakeStatus());
+ assertTrue(
+ "The length of the consumed data differs from expected",
+ result.bytesConsumed() > 0);
+ assertTrue(
+ "The length of the received data differs from expected",
+ 0 == result.bytesProduced());
+
+ // prepare the buffer for writing
+ app_data_buffer.clear();
+
+ // it's needless, but should work (don't cause exceptions):
+ client.closeInbound();
+ client.closeOutbound();
+
+ if (doLog) {
+ System.out.println("\nClient tries to read data again");
+ }
+ // CLOSED, 0 consumed, 0 produced
+ print(result = client.unwrap(buffer, app_data_buffer));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.CLOSED,
+ result.getStatus());
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NEED_WRAP,
+ result.getHandshakeStatus());
+ assertTrue(
+ "The length of the consumed data differs from expected",
+ 0 == result.bytesConsumed());
+ assertTrue(
+ "The length of the received data differs from expected",
+ 0 == result.bytesProduced());
+
+ // prepare the buffer for writing
+ buffer.clear();
+
+ if (doLog) {
+ System.out.println("\nClient sends responding close notify");
+ }
+ print(result = client.wrap(ByteBuffer.wrap(new byte[] {0}), buffer));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.CLOSED,
+ result.getStatus());
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING,
+ result.getHandshakeStatus());
+ assertTrue(
+ "The length of the consumed data differs from expected",
+ 0 == result.bytesConsumed());
+ assertTrue(
+ "The length of the produced data differs from expected",
+ result.bytesProduced() > 0);
+ if (doLog) {
+ System.out.println(
+ "\nClient tries to send data after closure alert");
+ }
+ // this data will not be sent (should do nothing - 0 cons, 0 prod)
+ print(result = client.wrap(ByteBuffer.wrap(new byte[] {0}), buffer));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.CLOSED,
+ result.getStatus());
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING,
+ result.getHandshakeStatus());
+ assertTrue(
+ "The length of the consumed data differs from expected",
+ 0 == result.bytesConsumed());
+ assertTrue(
+ "The length of the produced data differs from expected",
+ 0 == result.bytesProduced());
+
+ // prepare the buffers for reading
+ app_data_buffer.clear();
+ buffer.flip();
+
+ if (doLog) {
+ System.out.println("\nServer receives close notify");
+ }
+ print(result = server.unwrap(buffer, app_data_buffer));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.CLOSED,
+ result.getStatus());
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING,
+ result.getHandshakeStatus());
+ assertTrue(
+ "The length of the consumed data differs from expected",
+ result.bytesConsumed() > 0);
+ assertTrue(
+ "The length of the produced data differs from expected",
+ 0 == result.bytesProduced());
+
+ if (doLog) {
+ System.out.println("\nServer tries to read after closure");
+ }
+ // will be ignored
+ print(result = server.unwrap(buffer, app_data_buffer));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.CLOSED,
+ result.getStatus());
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING,
+ result.getHandshakeStatus());
+ assertTrue(
+ "The length of the consumed data differs from expected",
+ 0 == result.bytesConsumed());
+ assertTrue(
+ "The length of the produced data differs from expected",
+ 0 == result.bytesProduced());
+
+ // it's needless, but should work:
+ client.closeInbound();
+ // will be ignored
+
+ if (doLog) {
+ System.out.println("\nServer tries to write after closure");
+ }
+ buffer.clear();
+ print(result = server.wrap(ByteBuffer.allocate(0), buffer));
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.Status.CLOSED,
+ result.getStatus());
+ assertEquals("Unexpected status of operation:",
+ SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING,
+ result.getHandshakeStatus());
+ assertTrue(
+ "The length of the consumed data differs from expected",
+ 0 == result.bytesConsumed());
+ assertTrue(
+ "The length of the produced data differs from expected",
+ 0 == result.bytesProduced());
+ }
+
+ private static void print(SSLEngineResult result) {
+ if (doLog) {
+ System.out.println("result:\n"+result);
+ }
+ }
+
+ /**
+ * Returns the engine to be tested.
+ */
+ private SSLEngine getEngine() throws Exception {
+ return JSSETestData.getContext().createSSLEngine("localhost", 2345);
+ }
+
+ /**
+ * Initializes the engines.
+ */
+ private void initEngines(SSLEngine client, SSLEngine server) {
+ String prefix = "TLS_";
+
+ client.setEnabledProtocols(new String[] {"TLSv1"});
+ server.setEnabledProtocols(new String[] {"TLSv1"});
+ client.setEnabledCipherSuites(
+ new String[] {prefix+cipher_suites[0]});
+ server.setEnabledCipherSuites(
+ new String[] {prefix+cipher_suites[0]});
+
+ client.setUseClientMode(true);
+ server.setUseClientMode(false);
+ }
+
+ public static Test suite() {
+ return new TestSuite(SSLEngineImplTest.class);
+ }
+
+ public static void main(String[] args) throws Exception {
+ junit.textui.TestRunner.run(suite());
+ }
+}
+
Propchange: harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLEngineImplTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLServerSocketImplTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLServerSocketImplTest.java?view=auto&rev=503371
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLServerSocketImplTest.java (added)
+++ harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLServerSocketImplTest.java Sun Feb 4 00:10:09 2007
@@ -0,0 +1,645 @@
+/*
+ * 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());
+ }
+}
+
Propchange: harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLServerSocketImplTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLSessionContextImplTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLSessionContextImplTest.java?view=auto&rev=503371
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLSessionContextImplTest.java (added)
+++ harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLSessionContextImplTest.java Sun Feb 4 00:10:09 2007
@@ -0,0 +1,87 @@
+/*
+ * 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.util.Enumeration;
+import java.security.SecureRandom;
+
+import javax.net.ssl.SSLSession;
+
+import junit.framework.TestCase;
+
+/**
+ * Tests for <code>SSLSessionContextImp</code> constructor and methods
+ *
+ */
+public class SSLSessionContextImplTest extends TestCase {
+
+ public void testSSLSessionContextImpl() {
+ SecureRandom sr = new SecureRandom();
+ SSLSessionImpl ses1 = new SSLSessionImpl(
+ CipherSuite.TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA, sr);
+ SSLSessionImpl ses2 = new SSLSessionImpl(
+ CipherSuite.TLS_DH_anon_WITH_3DES_EDE_CBC_SHA, sr);
+ SSLSessionImpl ses3 = new SSLSessionImpl(
+ CipherSuite.TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5, sr);
+
+ SSLSessionContextImpl context = new SSLSessionContextImpl();
+ context.putSession(ses1);
+ context.putSession(ses2);
+ context.putSession(ses3);
+
+ for (Enumeration en = context.getIds(); en.hasMoreElements();) {
+ byte[] id = (byte[])en.nextElement();
+ assertTrue(context.getSession(id) != null);
+ }
+
+ SSLSession ses = context.getSession(ses1.getId());
+ assertSame(ses1, ses);
+
+ ses = context.getSession(ses3.getId());
+ assertSame(ses3, ses);
+ }
+
+ public void testGetSessionCacheSize() {
+ SSLSessionContextImpl context = new SSLSessionContextImpl();
+ assertEquals(context.getSessionCacheSize(), 0);
+
+ context.setSessionCacheSize(100);
+ assertEquals(context.getSessionCacheSize(), 100);
+
+ try {
+ context.setSessionCacheSize(-1);
+ fail("No expected IllegalArgumentException");
+ } catch (IllegalArgumentException e) {
+ }
+ }
+
+ public void testGetSessionTimeout() {
+ SSLSessionContextImpl context = new SSLSessionContextImpl();
+ assertEquals(context.getSessionTimeout(), 0);
+
+ context.setSessionTimeout(1000);
+ assertEquals(context.getSessionTimeout(), 1000);
+
+ try {
+ context.setSessionTimeout(-1);
+ fail("No expected IllegalArgumentException");
+ } catch (IllegalArgumentException e) {
+ }
+ }
+
+}
\ No newline at end of file
Propchange: harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLSessionContextImplTest.java
------------------------------------------------------------------------------
svn:eol-style = native