harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From telli...@apache.org
Subject 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...
Date Sun, 04 Feb 2007 08:10:11 GMT
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



Mime
View raw message