| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package tests.api.javax.net.ssl; |
| |
| import java.io.IOException; |
| import java.nio.ByteBuffer; |
| import java.nio.ReadOnlyBufferException; |
| import java.nio.channels.Pipe; |
| import java.nio.channels.Pipe.SinkChannel; |
| import java.nio.channels.Pipe.SourceChannel; |
| import java.security.KeyManagementException; |
| import java.security.KeyStoreException; |
| import java.security.NoSuchAlgorithmException; |
| import java.security.UnrecoverableKeyException; |
| import java.security.cert.CertificateException; |
| import java.security.cert.X509Certificate; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.Set; |
| import java.util.Vector; |
| |
| import javax.net.ssl.KeyManager; |
| import javax.net.ssl.SSLContext; |
| import javax.net.ssl.SSLEngine; |
| import javax.net.ssl.SSLEngineResult; |
| import javax.net.ssl.SSLException; |
| import javax.net.ssl.X509TrustManager; |
| import javax.net.ssl.SSLEngineResult.HandshakeStatus; |
| |
| import junit.framework.TestCase; |
| import dalvik.annotation.AndroidOnly; |
| import dalvik.annotation.KnownFailure; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetClass; |
| import dalvik.annotation.TestTargetNew; |
| import dalvik.annotation.TestTargets; |
| |
| |
| /** |
| * Tests for SSLEngine class |
| * |
| */ |
| @TestTargetClass(SSLEngine.class) |
| public class SSLEngineTest extends TestCase { |
| |
| private HandshakeHandler clientEngine; |
| private HandshakeHandler serverEngine; |
| |
| public static void main(String[] args) { |
| junit.textui.TestRunner.run(SSLEngineTest.class); |
| } |
| |
| /** |
| * Test for <code>SSLEngine()</code> constructor Assertion: creates |
| * SSLEngine object with null host and -1 port |
| * @throws NoSuchAlgorithmException |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "SSLEngine", |
| args = {} |
| ) |
| public void test_Constructor() throws NoSuchAlgorithmException { |
| SSLEngine e = getEngine(); |
| assertNull(e.getPeerHost()); |
| assertEquals(-1, e.getPeerPort()); |
| String[] suites = e.getSupportedCipherSuites(); |
| e.setEnabledCipherSuites(suites); |
| assertEquals(e.getEnabledCipherSuites().length, suites.length); |
| } |
| |
| /** |
| * Test for <code>SSLEngine(String host, int port)</code> constructor |
| * @throws NoSuchAlgorithmException |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verification with incorrect parameters missed", |
| method = "SSLEngine", |
| args = {java.lang.String.class, int.class} |
| ) |
| public void test_ConstructorLjava_lang_StringI01() throws NoSuchAlgorithmException { |
| int port = 1010; |
| SSLEngine e = getEngine(null, port); |
| assertNull(e.getPeerHost()); |
| assertEquals(e.getPeerPort(), port); |
| try { |
| e.beginHandshake(); |
| } catch (IllegalStateException ex) { |
| // expected |
| } catch (SSLException ex) { |
| fail("unexpected SSLException was thrown."); |
| } |
| e = getEngine(null, port); |
| e.setUseClientMode(true); |
| try { |
| e.beginHandshake(); |
| } catch (SSLException ex) { |
| // expected |
| } |
| e = getEngine(null, port); |
| e.setUseClientMode(false); |
| try { |
| e.beginHandshake(); |
| } catch (SSLException ex) { |
| // expected |
| } |
| } |
| |
| /** |
| * Test for <code>SSLEngine(String host, int port)</code> constructor |
| * @throws NoSuchAlgorithmException |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verification with incorrect parameters missed", |
| method = "SSLEngine", |
| args = {java.lang.String.class, int.class} |
| ) |
| public void test_ConstructorLjava_lang_StringI02() throws NoSuchAlgorithmException { |
| String host = "new host"; |
| int port = 8080; |
| SSLEngine e = getEngine(host, port); |
| assertEquals(e.getPeerHost(), host); |
| assertEquals(e.getPeerPort(), port); |
| String[] suites = e.getSupportedCipherSuites(); |
| e.setEnabledCipherSuites(suites); |
| assertEquals(e.getEnabledCipherSuites().length, suites.length); |
| e.setUseClientMode(true); |
| assertTrue(e.getUseClientMode()); |
| } |
| |
| /** |
| * Test for <code>getPeerHost()</code> method |
| * @throws NoSuchAlgorithmException |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getPeerHost", |
| args = {} |
| ) |
| public void test_getPeerHost() throws NoSuchAlgorithmException { |
| SSLEngine e = getEngine(); |
| assertNull(e.getPeerHost()); |
| e = getEngine("www.fortify.net", 80); |
| assertEquals("Incorrect host name", "www.fortify.net", e.getPeerHost()); |
| } |
| |
| /** |
| * Test for <code>getPeerPort()</code> method |
| * @throws NoSuchAlgorithmException |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getPeerPort", |
| args = {} |
| ) |
| public void test_getPeerPort() throws NoSuchAlgorithmException { |
| SSLEngine e = getEngine(); |
| assertEquals("Incorrect default value of peer port", |
| -1 ,e.getPeerPort()); |
| e = getEngine("www.fortify.net", 80); |
| assertEquals("Incorrect peer port", 80, e.getPeerPort()); |
| } |
| |
| /** |
| * @throws NoSuchAlgorithmException |
| * @tests javax.net.ssl.SSLEngine#getSupportedProtocols() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getSupportedProtocols", |
| args = {} |
| ) |
| public void test_getSupportedProtocols() throws NoSuchAlgorithmException { |
| SSLEngine sse = getEngine(); |
| try { |
| String[] res = sse.getSupportedProtocols(); |
| assertNotNull(res); |
| assertTrue(res.length > 0); |
| } catch (Exception ex) { |
| fail("Unexpected exception " + ex); |
| } |
| } |
| |
| /** |
| * @throws NoSuchAlgorithmException |
| * @tests javax.net.ssl.SSLEngine#setEnabledProtocols(String[] protocols) |
| * @tests javax.net.ssl.SSLEngine#getEnabledProtocols() |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getEnabledProtocols", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "setEnabledProtocols", |
| args = {String[].class} |
| ) |
| }) |
| public void test_EnabledProtocols() throws NoSuchAlgorithmException { |
| SSLEngine sse = getEngine(); |
| String[] pr = sse.getSupportedProtocols(); |
| try { |
| sse.setEnabledProtocols(pr); |
| String[] res = sse.getEnabledProtocols(); |
| assertNotNull("Null array was returned", res); |
| assertEquals("Incorrect array length", res.length, pr.length); |
| assertTrue("Incorrect array was returned", Arrays.equals(res, pr)); |
| } catch (Exception ex) { |
| fail("Unexpected exception " + ex); |
| } |
| try { |
| sse.setEnabledProtocols(null); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iae) { |
| //expected |
| } |
| } |
| |
| /** |
| * @throws NoSuchAlgorithmException |
| * @tests javax.net.ssl.SSLEngine#getSupportedCipherSuites() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getSupportedCipherSuites", |
| args = {} |
| ) |
| public void test_getSupportedCipherSuites() throws NoSuchAlgorithmException { |
| SSLEngine sse = getEngine(); |
| try { |
| String[] res = sse.getSupportedCipherSuites(); |
| assertNotNull(res); |
| assertTrue(res.length > 0); |
| } catch (Exception ex) { |
| fail("Unexpected exception " + ex); |
| } |
| } |
| |
| /** |
| * @throws NoSuchAlgorithmException |
| * @tests javax.net.ssl.SSLEngine#setEnabledCipherSuites(String[] suites) |
| * @tests javax.net.ssl.SSLEngine#getEnabledCipherSuites() |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "setEnabledCipherSuites", |
| args = {String[].class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getEnabledCipherSuites", |
| args = {} |
| ) |
| }) |
| public void test_EnabledCipherSuites() throws NoSuchAlgorithmException { |
| SSLEngine sse = getEngine(); |
| String[] st = sse.getSupportedCipherSuites(); |
| try { |
| sse.setEnabledCipherSuites(st); |
| String[] res = sse.getEnabledCipherSuites(); |
| assertNotNull("Null array was returned", res); |
| assertEquals("Incorrect array length", res.length, st.length); |
| assertTrue("Incorrect array was returned", Arrays.equals(res, st)); |
| } catch (Exception ex) { |
| fail("Unexpected exception " + ex); |
| } |
| try { |
| sse.setEnabledCipherSuites(null); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iae) { |
| //expected |
| } |
| } |
| |
| /** |
| * @throws NoSuchAlgorithmException |
| * @tests javax.net.ssl.SSLEngine#setEnableSessionCreation(boolean flag) |
| * @tests javax.net.ssl.SSLEngine#getEnableSessionCreation() |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "setEnableSessionCreation", |
| args = {boolean.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getEnableSessionCreation", |
| args = {} |
| ) |
| }) |
| public void test_EnableSessionCreation() throws NoSuchAlgorithmException { |
| SSLEngine sse = getEngine(); |
| try { |
| assertTrue(sse.getEnableSessionCreation()); |
| sse.setEnableSessionCreation(false); |
| assertFalse(sse.getEnableSessionCreation()); |
| sse.setEnableSessionCreation(true); |
| assertTrue(sse.getEnableSessionCreation()); |
| } catch (Exception ex) { |
| fail("Unexpected exception " + ex); |
| } |
| } |
| |
| /** |
| * @throws NoSuchAlgorithmException |
| * @tests javax.net.ssl.SSLEngine#setNeedClientAuth(boolean need) |
| * @tests javax.net.ssl.SSLEngine#getNeedClientAuth() |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "setNeedClientAuth", |
| args = {boolean.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getNeedClientAuth", |
| args = {} |
| ) |
| }) |
| public void test_NeedClientAuth() throws NoSuchAlgorithmException { |
| SSLEngine sse = getEngine(); |
| try { |
| sse.setNeedClientAuth(false); |
| assertFalse(sse.getNeedClientAuth()); |
| sse.setNeedClientAuth(true); |
| assertTrue(sse.getNeedClientAuth()); |
| } catch (Exception ex) { |
| fail("Unexpected exception " + ex); |
| } |
| } |
| |
| /** |
| * @throws NoSuchAlgorithmException |
| * @tests javax.net.ssl.SSLEngine#setWantClientAuth(boolean want) |
| * @tests javax.net.ssl.SSLEngine#getWantClientAuth() |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "setWantClientAuth", |
| args = {boolean.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getWantClientAuth", |
| args = {} |
| ) |
| }) |
| public void test_WantClientAuth() throws NoSuchAlgorithmException { |
| SSLEngine sse = getEngine(); |
| try { |
| sse.setWantClientAuth(false); |
| assertFalse(sse.getWantClientAuth()); |
| sse.setWantClientAuth(true); |
| assertTrue(sse.getWantClientAuth()); |
| } catch (Exception ex) { |
| fail("Unexpected exception " + ex); |
| } |
| } |
| |
| /** |
| * @throws NoSuchAlgorithmException |
| * @tests javax.net.ssl.SSLEngine#beginHandshake() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "beginHandshake", |
| args = {} |
| ) |
| public void test_beginHandshake() throws NoSuchAlgorithmException { |
| SSLEngine sse = getEngine(); |
| try { |
| sse.beginHandshake(); |
| fail("IllegalStateException wasn't thrown"); |
| } catch (IllegalStateException se) { |
| //expected |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalStateException"); |
| } |
| sse = getEngine("new host", 1080); |
| try { |
| sse.beginHandshake(); |
| fail("IllegalStateException wasn't thrown"); |
| } catch (IllegalStateException ise) { |
| //expected |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalStateException"); |
| } |
| sse = getEngine(); |
| try { |
| sse.setUseClientMode(true); |
| sse.beginHandshake(); |
| } catch (Exception ex) { |
| fail("Unexpected exception " + ex); |
| } |
| } |
| |
| /** |
| * @throws NoSuchAlgorithmException |
| * @tests javax.net.ssl.SSLEngine#setUseClientMode(boolean mode) |
| * @tests javax.net.ssl.SSLEngine#getUseClientMode() |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "setUseClientMode", |
| args = {boolean.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getUseClientMode", |
| args = {} |
| ) |
| }) |
| @AndroidOnly("The RI doesn't throw the expected IllegalStateException.") |
| public void test_UseClientMode() throws NoSuchAlgorithmException { |
| SSLEngine sse = getEngine(); |
| try { |
| sse.setUseClientMode(false); |
| assertFalse(sse.getUseClientMode()); |
| sse.setUseClientMode(true); |
| assertTrue(sse.getUseClientMode()); |
| } catch (Exception ex) { |
| fail("Unexpected exception " + ex); |
| } |
| |
| try { |
| sse = getEngine(null, 1080); |
| sse.setUseClientMode(true); |
| sse.beginHandshake(); |
| try { |
| sse.setUseClientMode(false); |
| fail("IllegalArgumentException was not thrown"); |
| } catch (IllegalArgumentException iae) { |
| //expected |
| } |
| } catch (Exception ex) { |
| fail("Unexpected exception " + ex); |
| } |
| } |
| |
| /** |
| * @throws NoSuchAlgorithmException |
| * @tests javax.net.ssl.SSLEngine#getSession() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getSession", |
| args = {} |
| ) |
| public void test_getSession() throws NoSuchAlgorithmException { |
| SSLEngine sse = getEngine(); |
| try { |
| assertNotNull(sse.getSession()); |
| } catch (Exception ex) { |
| fail("Unexpected exception " + ex); |
| } |
| } |
| |
| /** |
| * @throws NoSuchAlgorithmException |
| * @tests javax.net.ssl.SSLEngine#getHandshakeStatus() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getHandshakeStatus", |
| args = {} |
| ) |
| public void test_getHandshakeStatus() throws NoSuchAlgorithmException { |
| SSLEngine sse = getEngine(); |
| try { |
| assertEquals(sse.getHandshakeStatus().toString(), "NOT_HANDSHAKING"); |
| sse.setUseClientMode(true); |
| sse.beginHandshake(); |
| assertEquals(sse.getHandshakeStatus().toString(), "NEED_WRAP"); |
| } catch (Exception ex) { |
| fail("Unexpected exception " + ex); |
| } |
| } |
| |
| /** |
| * @throws NoSuchAlgorithmException |
| * @tests javax.net.ssl.SSLEngine#getDelegatedTask() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getDelegatedTask", |
| args = {} |
| ) |
| @KnownFailure("org.apache.harmony.xnet.provider.jsse.SSLEngineImpl#getDelegatedTask() throws NPE instead of returning null") |
| public void test_getDelegatedTask() throws NoSuchAlgorithmException { |
| SSLEngine sse = getEngine(); |
| try { |
| assertNull(sse.getDelegatedTask()); |
| } catch (Exception ex) { |
| fail("Unexpected exception " + ex); |
| } |
| } |
| |
| /** |
| * @throws IOException |
| * @throws InterruptedException |
| * @tests javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts, |
| * int offset, int length) |
| * Exception case: SSLException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "unwrap", |
| args = {ByteBuffer.class, ByteBuffer[].class, int.class, int.class} |
| ) |
| public void test_unwrap_01() throws IOException, InterruptedException { |
| prepareEngines(); |
| doHandshake(); |
| |
| ByteBuffer bbs = ByteBuffer.wrap(new byte[] {1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,3,1,2,31,2,3,1,2,3,1,2,3,1,2,3}); |
| ByteBuffer bbd = ByteBuffer.allocate(100); |
| try { |
| clientEngine.engine.unwrap(bbs, new ByteBuffer[] { bbd }, 0, 1); |
| fail("SSLException wasn't thrown"); |
| } catch (SSLException ex) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts, |
| * int offset, int length) |
| * Exception case: IndexOutOfBoundsException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "unwrap", |
| args = {ByteBuffer.class, ByteBuffer[].class, int.class, int.class} |
| ) |
| @KnownFailure("Fixed in DonutBurger, boundary checks missing") |
| public void test_unwrap_02() throws SSLException { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer[] bbA = { ByteBuffer.allocate(100), ByteBuffer.allocate(10), ByteBuffer.allocate(100) }; |
| |
| ByteBuffer bb = ByteBuffer.allocate(10); |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| sse.unwrap(bb, bbA, -1, 3); |
| fail("IndexOutOfBoundsException wasn't thrown"); |
| } catch (IndexOutOfBoundsException iobe) { |
| //expected |
| } |
| try { |
| sse.unwrap(bb, bbA, 0, -3); |
| fail("IndexOutOfBoundsException wasn't thrown"); |
| } catch (IndexOutOfBoundsException iobe) { |
| //expected |
| } |
| try { |
| sse.unwrap(bb, bbA, bbA.length + 1, bbA.length); |
| fail("IndexOutOfBoundsException wasn't thrown"); |
| } catch (IndexOutOfBoundsException iobe) { |
| //expected |
| } |
| try { |
| sse.unwrap(bb, bbA, 0, bbA.length + 1); |
| fail("IndexOutOfBoundsException wasn't thrown"); |
| } catch (IndexOutOfBoundsException iobe) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts, |
| * int offset, int length) |
| * Exception case: ReadOnlyBufferException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "unwrap", |
| args = {ByteBuffer.class, ByteBuffer[].class, int.class, int.class} |
| ) |
| @KnownFailure("Fixed on DonutBurger, Wrong Exception thrown") |
| public void test_unwrap_03() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bbR = ByteBuffer.allocate(100).asReadOnlyBuffer(); |
| ByteBuffer[] bbA = { bbR, ByteBuffer.allocate(10), ByteBuffer.allocate(100) }; |
| |
| ByteBuffer bb = ByteBuffer.allocate(10); |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| sse.unwrap(bb, bbA, 0, bbA.length); |
| fail("ReadOnlyBufferException wasn't thrown"); |
| } catch (ReadOnlyBufferException iobe) { |
| //expected |
| } catch (Exception e) { |
| fail(e + " was thrown instead of ReadOnlyBufferException"); |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts, |
| * int offset, int length) |
| * Exception case: IllegalArgumentException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "IllegalArgumentException should be thrown", |
| method = "unwrap", |
| args = {ByteBuffer.class, ByteBuffer[].class, int.class, int.class} |
| ) |
| @KnownFailure("Fixed on DonutBurger, Wrong Exception thrown") |
| public void test_unwrap_04() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer[] bbA = {ByteBuffer.allocate(100), ByteBuffer.allocate(10), ByteBuffer.allocate(100)}; |
| ByteBuffer[] bbAN = {ByteBuffer.allocate(100), null, ByteBuffer.allocate(100)}; |
| ByteBuffer[] bbN = null; |
| ByteBuffer bb = ByteBuffer.allocate(10); |
| ByteBuffer bN = null; |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| sse.unwrap(bN, bbA, 0, 3); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iobe) { |
| //expected |
| } catch (NullPointerException npe) { |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalArgumentException"); |
| } |
| try { |
| sse.unwrap(bb, bbAN, 0, 3); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iobe) { |
| //expected |
| } catch (NullPointerException npe) { |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalArgumentException"); |
| } |
| try { |
| sse.unwrap(bb, bbN, 0, 0); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iobe) { |
| //expected |
| } catch (NullPointerException npe) { |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalArgumentException"); |
| } |
| try { |
| sse.unwrap(bN, bbN, 0, 0); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iobe) { |
| //expected |
| } catch (NullPointerException npe) { |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalArgumentException"); |
| } |
| |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts, |
| * int offset, int length) |
| * Exception case: IllegalStateException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "unwrap", |
| args = {ByteBuffer.class, ByteBuffer[].class, int.class, int.class} |
| ) |
| @AndroidOnly("The RI doesn't throw the IllegalStateException.") |
| public void test_unwrap_05() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer[] bbA = { ByteBuffer.allocate(100), ByteBuffer.allocate(10), ByteBuffer.allocate(100) }; |
| |
| ByteBuffer bb = ByteBuffer.allocate(10); |
| SSLEngine sse = getEngine(host, port); |
| |
| try { |
| sse.unwrap(bb, bbA, 0, bbA.length); |
| fail("IllegalStateException wasn't thrown"); |
| } catch (IllegalStateException iobe) { |
| //expected |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalStateException"); |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts, |
| * int offset, int length) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "unwrap", |
| args = {ByteBuffer.class, ByteBuffer[].class, int.class, int.class} |
| ) |
| public void test_unwrap_06() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer[] bbA = { ByteBuffer.allocate(100), ByteBuffer.allocate(10), ByteBuffer.allocate(100) }; |
| |
| ByteBuffer bb = ByteBuffer.allocate(10); |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| SSLEngineResult res = sse.unwrap(bb, bbA, 0, bbA.length); |
| assertEquals(0, res.bytesConsumed()); |
| assertEquals(0, res.bytesProduced()); |
| } catch (Exception ex) { |
| fail("Unexpected exception: " + ex); |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, int offset, |
| * int length, ByteBuffer dst) |
| * Exception case: SSLException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.NOT_FEASIBLE, |
| notes = "wrap cannot be forced to fail", |
| method = "wrap", |
| args = {ByteBuffer[].class, int.class, int.class, ByteBuffer.class} |
| ) |
| public void test_wrap_01() throws IOException, InterruptedException { |
| prepareEngines(); |
| doHandshake(); |
| |
| ByteBuffer bbs = ByteBuffer.allocate(100); |
| ByteBuffer bbd = ByteBuffer.allocate(20000); |
| |
| try { |
| @SuppressWarnings("unused") |
| SSLEngineResult result = clientEngine.engine.wrap(new ByteBuffer[] { bbs }, 0, 1, bbd); |
| //fail("SSLException wasn't thrown"); |
| } catch (SSLException ex) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, int offset, |
| * int length, ByteBuffer dst) |
| * Exception case: IndexOutOfBoundsException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "wrap", |
| args = {ByteBuffer[].class, int.class, int.class, ByteBuffer.class} |
| ) |
| @KnownFailure("Fixed in DonutBurger, boundary checks missing") |
| public void test_wrap_02() throws SSLException { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bb = ByteBuffer.allocate(10); |
| ByteBuffer[] bbA = {ByteBuffer.allocate(5), ByteBuffer.allocate(10), ByteBuffer.allocate(5)}; |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| sse.wrap(bbA, -1, 3, bb); |
| fail("IndexOutOfBoundsException wasn't thrown"); |
| } catch (IndexOutOfBoundsException iobe) { |
| //expected |
| } |
| try { |
| sse.wrap(bbA, 0, -3, bb); |
| fail("IndexOutOfBoundsException wasn't thrown"); |
| } catch (IndexOutOfBoundsException iobe) { |
| //expected |
| } |
| try { |
| sse.wrap(bbA, bbA.length + 1, bbA.length, bb); |
| fail("IndexOutOfBoundsException wasn't thrown"); |
| } catch (IndexOutOfBoundsException iobe) { |
| //expected |
| } |
| try { |
| sse.wrap(bbA, 0, bbA.length + 1, bb); |
| fail("IndexOutOfBoundsException wasn't thrown"); |
| } catch (IndexOutOfBoundsException iobe) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, int offset, |
| * int length, ByteBuffer dst) |
| * Exception case: ReadOnlyBufferException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "wrap", |
| args = {ByteBuffer[].class, int.class, int.class, ByteBuffer.class} |
| ) |
| public void test_wrap_03() throws SSLException { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bb = ByteBuffer.allocate(10).asReadOnlyBuffer(); |
| ByteBuffer[] bbA = {ByteBuffer.allocate(5), ByteBuffer.allocate(10), ByteBuffer.allocate(5)}; |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| sse.wrap(bbA, 0, bbA.length, bb); |
| fail("ReadOnlyBufferException wasn't thrown"); |
| } catch (ReadOnlyBufferException iobe) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, int offset, |
| * int length, ByteBuffer dst) |
| * Exception case: IllegalArgumentException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "IllegalArgumentException must be thrown", |
| method = "wrap", |
| args = {ByteBuffer[].class, int.class, int.class, ByteBuffer.class} |
| ) |
| @KnownFailure("Fixed on DonutBurger, Wrong Exception thrown") |
| public void test_wrap_04() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer[] bbA = {ByteBuffer.allocate(100), ByteBuffer.allocate(10), ByteBuffer.allocate(100)}; |
| ByteBuffer[] bbN = null; |
| ByteBuffer bN = null; |
| SSLEngine e = getEngine(host, port); |
| e.setUseClientMode(true); |
| |
| try { |
| e.wrap(bbA, 0, 3, bN); |
| fail("IllegalArgumentException must be thrown for null srcs byte buffer array"); |
| } catch (NullPointerException npe) { |
| } catch (IllegalArgumentException ex) { |
| } catch (Exception ex) { |
| fail(ex + " was thrown instead of IllegalArgumentException"); |
| } |
| |
| try { |
| e.wrap(bbN, 0, 0, bN); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException ex) { |
| } catch (NullPointerException npe) { |
| } catch (Exception ex) { |
| fail(ex + " was thrown instead of IllegalArgumentException"); |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, int offset, |
| * int length, ByteBuffer dst) |
| * Exception case: IllegalStateException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "wrap", |
| args = {ByteBuffer[].class, int.class, int.class, ByteBuffer.class} |
| ) |
| @AndroidOnly("The RI doesn't throw the IllegalStateException.") |
| public void test_wrap_05() throws SSLException { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bb = ByteBuffer.allocate(10); |
| ByteBuffer[] bbA = {ByteBuffer.allocate(5), ByteBuffer.allocate(10), ByteBuffer.allocate(5)}; |
| SSLEngine sse = getEngine(host, port); |
| |
| try { |
| sse.wrap(bbA, 0, bbA.length, bb); |
| fail("IllegalStateException wasn't thrown"); |
| } catch (IllegalStateException iobe) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, int offset, |
| * int length, ByteBuffer dst) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "wrap", |
| args = {ByteBuffer[].class, int.class, int.class, ByteBuffer.class} |
| ) |
| public void test_wrap_06() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bb = ByteBuffer.allocate(10); |
| ByteBuffer[] bbA = {ByteBuffer.allocate(5), ByteBuffer.allocate(10), ByteBuffer.allocate(5)}; |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| sse.wrap(bbA, 0, bbA.length, bb); |
| } catch (Exception ex) { |
| fail("Unexpected exception: " + ex); |
| } |
| } |
| |
| /** |
| * @throws NoSuchAlgorithmException |
| * @tests javax.net.ssl.SSLEngine#closeOutbound() |
| * @tests javax.net.ssl.SSLEngine#isOutboundDone() |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "closeOutbound", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "isOutboundDone", |
| args = {} |
| ) |
| }) |
| public void test_closeOutbound() throws NoSuchAlgorithmException { |
| SSLEngine sse = getEngine(); |
| |
| try { |
| assertFalse(sse.isOutboundDone()); |
| sse.closeOutbound(); |
| assertTrue(sse.isOutboundDone()); |
| } catch (Exception ex) { |
| fail("Unexpected exception: " + ex); |
| } |
| } |
| |
| /** |
| * @throws NoSuchAlgorithmException |
| * @tests javax.net.ssl.SSLEngine#closeInbound() |
| * @tests javax.net.ssl.SSLEngine#isInboundDone() |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "", |
| method = "closeInbound", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "isInboundDone", |
| args = {} |
| ) |
| }) |
| public void test_closeInbound() throws NoSuchAlgorithmException { |
| SSLEngine sse = getEngine(); |
| |
| try { |
| assertFalse(sse.isInboundDone()); |
| sse.closeInbound(); |
| assertTrue(sse.isInboundDone()); |
| } catch (Exception ex) { |
| fail("Unexpected exception: " + ex); |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer dst) |
| * SSLException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "unwrap", |
| args = {ByteBuffer.class, ByteBuffer.class} |
| ) |
| public void test_unwrap_ByteBuffer_ByteBuffer_01() throws InterruptedException, IOException { |
| prepareEngines(); |
| doHandshake(); |
| ByteBuffer bbs = ByteBuffer.allocate(100); |
| ByteBuffer bbd = ByteBuffer.allocate(100); |
| |
| try { |
| SSLEngineResult unwrap = clientEngine.engine.unwrap(bbs, bbd); |
| fail("SSLException wasn't thrown"); |
| } catch (SSLException ex) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer dst) |
| * ReadOnlyBufferException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "unwrap", |
| args = {ByteBuffer.class, ByteBuffer.class} |
| ) |
| @KnownFailure("Fixed on DonutBurger, Wrong Exception thrown") |
| public void test_unwrap_ByteBuffer_ByteBuffer_02() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bbs = ByteBuffer.allocate(10); |
| ByteBuffer bbd = ByteBuffer.allocate(100).asReadOnlyBuffer(); |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| sse.unwrap(bbs, bbd); |
| fail("ReadOnlyBufferException wasn't thrown"); |
| } catch (ReadOnlyBufferException iobe) { |
| //expected |
| } catch (Exception e) { |
| fail(e + " was thrown instead of ReadOnlyBufferException"); |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer dst) |
| * IllegalArgumentException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "unwrap", |
| args = {ByteBuffer.class, ByteBuffer.class} |
| ) |
| @KnownFailure("Fixed on DonutBurger, Wrong Exception thrown") |
| public void test_unwrap_ByteBuffer_ByteBuffer_03() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bbsN = null; |
| ByteBuffer bbdN = null; |
| ByteBuffer bbs = ByteBuffer.allocate(10); |
| ByteBuffer bbd = ByteBuffer.allocate(100); |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| sse.unwrap(bbsN, bbd); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iae) { |
| //expected |
| } catch (NullPointerException npe) { |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalArgumentException"); |
| } |
| |
| try { |
| sse.unwrap(bbs, bbdN); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iae) { |
| //expected |
| } catch (NullPointerException npe) { |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalArgumentException"); |
| } |
| |
| try { |
| sse.unwrap(bbsN, bbdN); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iae) { |
| //expected |
| } catch (NullPointerException npe) { |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalArgumentException"); |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer dst) |
| * IllegalStateException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "unwrap", |
| args = {ByteBuffer.class, ByteBuffer.class} |
| ) |
| @AndroidOnly("The RI doesn't throw the IllegalStateException.") |
| public void test_unwrap_ByteBuffer_ByteBuffer_04() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bbs = ByteBuffer.allocate(10); |
| ByteBuffer bbd = ByteBuffer.allocate(100); |
| SSLEngine sse = getEngine(host, port); |
| |
| try { |
| sse.unwrap(bbs, bbd); |
| fail("IllegalStateException wasn't thrown"); |
| } catch (IllegalStateException iobe) { |
| //expected |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalStateException"); |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer dst) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "unwrap", |
| args = {ByteBuffer.class, ByteBuffer.class} |
| ) |
| public void test_unwrap_ByteBuffer_ByteBuffer_05() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bbs = ByteBuffer.allocate(10); |
| ByteBuffer bbd = ByteBuffer.allocate(100); |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| SSLEngineResult res = sse.unwrap(bbs, bbd); |
| assertEquals(0, res.bytesConsumed()); |
| assertEquals(0, res.bytesProduced()); |
| } catch (Exception e) { |
| fail("Unexpected exception: " + e); |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts) |
| * SSLException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "unwrap", |
| args = {ByteBuffer.class, ByteBuffer[].class} |
| ) |
| public void test_unwrap_ByteBuffer$ByteBuffer_01() throws IOException, InterruptedException { |
| prepareEngines(); |
| doHandshake(); |
| |
| ByteBuffer bbs = ByteBuffer.allocate(100); |
| ByteBuffer bbd = ByteBuffer.allocate(100); |
| |
| try { |
| clientEngine.engine.unwrap(bbs, new ByteBuffer[] { bbd }); |
| fail("SSLException wasn't thrown"); |
| } catch (SSLException ex) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts) |
| * ReadOnlyBufferException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "unwrap", |
| args = {ByteBuffer.class, ByteBuffer[].class} |
| ) |
| @KnownFailure("Fixed on DonutBurger, Wrong Exception thrown") |
| public void test_unwrap_ByteBuffer$ByteBuffer_02() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bbs = ByteBuffer.allocate(10); |
| ByteBuffer bbR = ByteBuffer.allocate(100).asReadOnlyBuffer(); |
| ByteBuffer[] bbA = { bbR, ByteBuffer.allocate(10), ByteBuffer.allocate(100) }; |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| sse.unwrap(bbs, bbA); |
| fail("ReadOnlyBufferException wasn't thrown"); |
| } catch (ReadOnlyBufferException iobe) { |
| //expected |
| } catch (Exception e) { |
| fail(e + " was thrown instead of ReadOnlyBufferException"); |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts) |
| * IllegalArgumentException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "unwrap", |
| args = {ByteBuffer.class, ByteBuffer[].class} |
| ) |
| @KnownFailure("Fixed on DonutBurger, Wrong Exception thrown") |
| public void test_unwrap_ByteBuffer$ByteBuffer_03() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer[] bbA = { ByteBuffer.allocate(100), ByteBuffer.allocate(10), ByteBuffer.allocate(100) }; |
| ByteBuffer[] bbN = { ByteBuffer.allocate(100), null, ByteBuffer.allocate(100) }; |
| ByteBuffer[] bbAN = null; |
| ByteBuffer bb = ByteBuffer.allocate(10); |
| ByteBuffer bN = null; |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| sse.unwrap(bN, bbA); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iobe) { |
| //expected |
| } catch (NullPointerException npe) { |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalArgumentException"); |
| } |
| |
| try { |
| sse.unwrap(bb, bbAN); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iobe) { |
| //expected |
| } catch (NullPointerException npe) { |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalArgumentException"); |
| } |
| |
| try { |
| sse.unwrap(bb, bbN); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iobe) { |
| //expected |
| } catch (NullPointerException npe) { |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalArgumentException"); |
| } |
| |
| try { |
| sse.unwrap(bN, bbAN); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iobe) { |
| //expected |
| } catch (NullPointerException npe) { |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalArgumentException"); |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts) |
| * IllegalStateException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "unwrap", |
| args = {ByteBuffer.class, ByteBuffer[].class} |
| ) |
| @AndroidOnly("The RI doesn't throw the IllegalStateException.") |
| public void test_unwrap_ByteBuffer$ByteBuffer_04() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bbs = ByteBuffer.allocate(10); |
| ByteBuffer[] bbd = {ByteBuffer.allocate(100), ByteBuffer.allocate(10), ByteBuffer.allocate(100) }; |
| SSLEngine sse = getEngine(host, port); |
| |
| try { |
| sse.unwrap(bbs, bbd); |
| fail("IllegalStateException wasn't thrown"); |
| } catch (IllegalStateException iobe) { |
| //expected |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalStateException"); |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#unwrap(ByteBuffer src, ByteBuffer[] dsts) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "unwrap", |
| args = {ByteBuffer.class, ByteBuffer[].class} |
| ) |
| public void test_unwrap_ByteBuffer$ByteBuffer_05() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bbs = ByteBuffer.allocate(10); |
| ByteBuffer[] bbd = {ByteBuffer.allocate(100), ByteBuffer.allocate(10), ByteBuffer.allocate(100) }; |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| SSLEngineResult res = sse.unwrap(bbs, bbd); |
| assertEquals(0, res.bytesConsumed()); |
| assertEquals(0, res.bytesProduced()); |
| } catch (Exception ex) { |
| fail("Unexpected exception: " + ex); |
| } |
| } |
| |
| /** |
| * @throws IOException |
| * @throws InterruptedException |
| * @tests javax.net.ssl.SSLEngine#wrap(ByteBuffer src, ByteBuffer dst) |
| * SSLException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.NOT_FEASIBLE, |
| notes = "wrap cannot be forced to produce SSLException", |
| method = "wrap", |
| args = {ByteBuffer.class, ByteBuffer.class} |
| ) |
| public void test_wrap_ByteBuffer_ByteBuffer_01() throws IOException, InterruptedException { |
| prepareEngines(); |
| doHandshake(); |
| ByteBuffer bbs = ByteBuffer.allocate(20); |
| ByteBuffer bbd = ByteBuffer.allocate(20000); |
| |
| try { |
| clientEngine.engine.wrap(bbs, bbd); |
| //fail("SSLException wasn't thrown"); |
| } catch (SSLException ex) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#wrap(ByteBuffer src, ByteBuffer dst) |
| * ReadOnlyBufferException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "wrap", |
| args = {ByteBuffer.class, ByteBuffer.class} |
| ) |
| public void test_wrap_ByteBuffer_ByteBuffer_02() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bbs = ByteBuffer.allocate(10); |
| ByteBuffer bbd = ByteBuffer.allocate(100).asReadOnlyBuffer(); |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| sse.wrap(bbs, bbd); |
| fail("ReadOnlyBufferException wasn't thrown"); |
| } catch (ReadOnlyBufferException iobe) { |
| //expected |
| } catch (Exception e) { |
| fail(e + " was thrown instead of ReadOnlyBufferException"); |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#wrap(ByteBuffer src, ByteBuffer dst) |
| * IllegalArgumentException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "wrap", |
| args = {ByteBuffer.class, ByteBuffer.class} |
| ) |
| @KnownFailure("Fixed on DonutBurger, Wrong Exception thrown") |
| public void test_wrap_ByteBuffer_ByteBuffer_03() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bbsN = null; |
| ByteBuffer bbdN = null; |
| ByteBuffer bbs = ByteBuffer.allocate(10); |
| ByteBuffer bbd = ByteBuffer.allocate(100); |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| sse.wrap(bbsN, bbd); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iae) { |
| //expected |
| } catch (NullPointerException npe) { |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalArgumentException"); |
| } |
| |
| try { |
| sse.wrap(bbs, bbdN); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iae) { |
| //expected |
| } catch (NullPointerException npe) { |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalArgumentException"); |
| } |
| |
| try { |
| sse.wrap(bbsN, bbdN); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iae) { |
| //expected |
| } catch (NullPointerException npe) { |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalArgumentException"); |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#wrap(ByteBuffer src, ByteBuffer dst) |
| * IllegalStateException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "wrap", |
| args = {ByteBuffer.class, ByteBuffer.class} |
| ) |
| @AndroidOnly("The RI doesn't throw the IllegalStateException.") |
| public void test_wrap_ByteBuffer_ByteBuffer_04() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bbs = ByteBuffer.allocate(10); |
| ByteBuffer bbd = ByteBuffer.allocate(10); |
| SSLEngine sse = getEngine(host, port); |
| |
| try { |
| sse.wrap(bbs, bbd); |
| fail("IllegalStateException wasn't thrown"); |
| } catch (IllegalStateException iobe) { |
| //expected |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalStateException"); |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#wrap(ByteBuffer src, ByteBuffer dst) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "wrap", |
| args = {ByteBuffer.class, ByteBuffer.class} |
| ) |
| public void test_wrap_ByteBuffer_ByteBuffer_05() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bb = ByteBuffer.allocate(10); |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| SSLEngineResult res = sse.wrap(bb, ByteBuffer.allocate(10)); |
| assertEquals(0, res.bytesConsumed()); |
| assertEquals(0, res.bytesProduced()); |
| } catch (Exception e) { |
| fail("Unexpected exception: " + e); |
| } |
| } |
| |
| /** |
| * @throws IOException |
| * @throws InterruptedException |
| * @tests javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, ByteBuffer dst) |
| * SSLException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "wrap cannot be forced to throw SSLException", |
| method = "wrap", |
| args = {ByteBuffer[].class, ByteBuffer.class} |
| ) |
| public void test_wrap_ByteBuffer$ByteBuffer_01() throws IOException, InterruptedException { |
| prepareEngines(); |
| doHandshake(); |
| ByteBuffer bbs = ByteBuffer.allocate(100); |
| ByteBuffer bbd = ByteBuffer.allocate(20000); |
| |
| try { |
| clientEngine.engine.wrap(new ByteBuffer[] { bbs }, bbd); |
| serverEngine.engine.wrap(new ByteBuffer[] { bbs }, bbd); |
| //fail("SSLException wasn't thrown"); |
| } catch (SSLException ex) { |
| //expected |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, ByteBuffer dst) |
| * ReadOnlyBufferException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "wrap", |
| args = {ByteBuffer[].class, ByteBuffer.class} |
| ) |
| public void test_wrap_ByteBuffer$ByteBuffer_02() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bb = ByteBuffer.allocate(10).asReadOnlyBuffer(); |
| ByteBuffer[] bbA = {ByteBuffer.allocate(5), ByteBuffer.allocate(10), ByteBuffer.allocate(5)}; |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| sse.wrap(bbA, bb); |
| fail("ReadOnlyBufferException wasn't thrown"); |
| } catch (ReadOnlyBufferException iobe) { |
| //expected |
| } catch (Exception e) { |
| fail(e + " was thrown instead of ReadOnlyBufferException"); |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, ByteBuffer dst) |
| * IllegalArgumentException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "wrap", |
| args = {ByteBuffer[].class, ByteBuffer.class} |
| ) |
| @KnownFailure("Fixed on DonutBurger, Wrong Exception thrown") |
| public void test_wrap_ByteBuffer$ByteBuffer_03() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer[] bbA = {ByteBuffer.allocate(100), ByteBuffer.allocate(10), ByteBuffer.allocate(100)}; |
| ByteBuffer[] bbAN = null; |
| ByteBuffer bb = ByteBuffer.allocate(10); |
| ByteBuffer bN = null; |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| sse.wrap(bbA, bN); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iobe) { |
| //expected |
| } catch (NullPointerException npe) { |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalArgumentException"); |
| } |
| |
| try { |
| sse.wrap(bbAN, bb); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iobe) { |
| //expected |
| } catch (NullPointerException npe) { |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalArgumentException"); |
| } |
| |
| try { |
| sse.wrap(bbAN, bN); |
| fail("IllegalArgumentException wasn't thrown"); |
| } catch (IllegalArgumentException iobe) { |
| //expected |
| } catch (NullPointerException npe) { |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalArgumentException"); |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, ByteBuffer dst) |
| * IllegalStateException should be thrown. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "wrap", |
| args = {ByteBuffer[].class, ByteBuffer.class} |
| ) |
| @AndroidOnly("The RI doesn't throw the IllegalStateException.") |
| public void test_wrap_ByteBuffer$ByteBuffer_04() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bb = ByteBuffer.allocate(10); |
| ByteBuffer[] bbA = { ByteBuffer.allocate(5), ByteBuffer.allocate(10), ByteBuffer.allocate(5) }; |
| SSLEngine sse = getEngine(host, port); |
| |
| try { |
| sse.wrap(bbA, bb); |
| fail("IllegalStateException wasn't thrown"); |
| } catch (IllegalStateException iobe) { |
| //expected |
| } catch (Exception e) { |
| fail(e + " was thrown instead of IllegalStateException"); |
| } |
| } |
| |
| /** |
| * @tests javax.net.ssl.SSLEngine#wrap(ByteBuffer[] srcs, ByteBuffer dst) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "wrap", |
| args = {ByteBuffer[].class, ByteBuffer.class} |
| ) |
| public void test_wrap_ByteBuffer$ByteBuffer_05() { |
| String host = "new host"; |
| int port = 8080; |
| ByteBuffer bb = ByteBuffer.allocate(10); |
| ByteBuffer[] bbA = { ByteBuffer.allocate(5), ByteBuffer.allocate(10), ByteBuffer.allocate(5) }; |
| SSLEngine sse = getEngine(host, port); |
| sse.setUseClientMode(true); |
| |
| try { |
| SSLEngineResult res = sse.wrap(bbA, bb); |
| assertEquals(0, res.bytesConsumed()); |
| assertEquals(0, res.bytesProduced()); |
| } catch (Exception ex) { |
| fail("Unexpected exception: " + ex); |
| } |
| } |
| |
| private SSLEngine getEngine() { |
| SSLContext context = null; |
| try { |
| context = SSLContext.getInstance("TLS"); |
| context.init(null, null, null); |
| } catch (KeyManagementException e) { |
| fail("Could not get SSLEngine: key management exception " |
| + e.getMessage()); |
| } catch (NoSuchAlgorithmException e) { |
| fail("Could not get SSLEngine: no such algorithm " + e.getMessage()); |
| } |
| return context.createSSLEngine(); |
| } |
| |
| private SSLEngine getEngine(String host, int port) { |
| SSLContext context = null; |
| try { |
| context = SSLContext.getInstance("TLS"); |
| context.init(null, null, null); |
| } catch (KeyManagementException e) { |
| fail("Could not get SSLEngine: key management exception " |
| + e.getMessage()); |
| } catch (NoSuchAlgorithmException e) { |
| fail("Could not get SSLEngine: no such algorithm " + e.getMessage()); |
| } |
| return context.createSSLEngine(host, port); |
| } |
| |
| class HandshakeHandler implements Runnable { |
| |
| private final SSLEngine engine; |
| |
| private final SourceChannel in; |
| |
| private final SinkChannel out; |
| |
| private final ByteBuffer EMPTY = ByteBuffer.allocate(0); |
| |
| @SuppressWarnings("unused") |
| private final String LOGTAG; |
| |
| private SSLEngineResult.HandshakeStatus status; |
| |
| private ByteBuffer readBuffer; |
| |
| private ByteBuffer writeBuffer; |
| |
| HandshakeHandler(boolean clientMode, SourceChannel in, SinkChannel out) |
| throws SSLException { |
| this.in = in; |
| this.out = out; |
| engine = getEngine(); |
| engine.setUseClientMode(clientMode); |
| String[] cipherSuites = engine.getSupportedCipherSuites(); |
| Set<String> enabledSuites = new HashSet<String>(); |
| for (String cipherSuite : cipherSuites) { |
| if (cipherSuite.contains("anon")) { |
| enabledSuites.add(cipherSuite); |
| } |
| } |
| engine.setEnabledCipherSuites((String[]) enabledSuites.toArray( |
| new String[enabledSuites.size()])); |
| |
| engine.beginHandshake(); |
| status = engine.getHandshakeStatus(); |
| |
| if (clientMode) { |
| LOGTAG = "CLIENT: "; |
| } else { |
| LOGTAG = "SERVER: "; |
| } |
| |
| log("CipherSuites: " + Arrays.toString(engine.getEnabledCipherSuites())); |
| log(status); |
| |
| readBuffer = ByteBuffer.allocate(200000); |
| writeBuffer = ByteBuffer.allocate(20000); |
| } |
| |
| public SSLEngineResult.HandshakeStatus getStatus() { |
| return status; |
| } |
| |
| private void log(Object o) { |
| //System.out.print(LOGTAG); |
| //System.out.println(o); |
| } |
| |
| private ByteBuffer read() throws IOException { |
| if (readBuffer == null || readBuffer.remaining() == 0 || readBuffer.position() == 0) { |
| readBuffer.clear(); |
| int read = in.read(readBuffer); |
| log("read: " + read); |
| readBuffer.rewind(); |
| readBuffer.limit(read); |
| } |
| return readBuffer; |
| } |
| |
| public void run() { |
| try { |
| while (true) { |
| switch (status) { |
| case FINISHED: { |
| log(status); |
| return; |
| } |
| case NEED_TASK: { |
| log(status); |
| Runnable task; |
| while ((task = engine.getDelegatedTask()) != null) { |
| task.run(); |
| } |
| status = engine.getHandshakeStatus(); |
| break; |
| } |
| case NEED_UNWRAP: { |
| log(status); |
| ByteBuffer source = read(); |
| writeBuffer.clear(); |
| |
| while (status == HandshakeStatus.NEED_UNWRAP) { |
| SSLEngineResult result = engine.unwrap(source, writeBuffer); |
| status = result.getHandshakeStatus(); |
| log(result); |
| } |
| break; |
| } |
| case NEED_WRAP: { |
| log(status); |
| writeBuffer.clear(); |
| |
| int produced = 0; |
| SSLEngineResult result = null; |
| while (status == HandshakeStatus.NEED_WRAP) { |
| result = engine.wrap(EMPTY, writeBuffer); |
| status = result.getHandshakeStatus(); |
| produced += result.bytesProduced(); |
| log(result); |
| } |
| writeBuffer.rewind(); |
| writeBuffer.limit(produced); |
| log("write: " + produced); |
| out.write(writeBuffer); |
| break; |
| } |
| case NOT_HANDSHAKING: { |
| log("Not Handshaking"); |
| return; |
| } |
| } |
| } |
| } catch (IOException e) { |
| log(e); |
| } catch (RuntimeException e) { |
| // ignore; |
| } |
| } |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "wrap", |
| args = {ByteBuffer.class, ByteBuffer.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "unwrap", |
| args = {ByteBuffer.class, ByteBuffer.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "beginHandshake", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getHandshakeStatus", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "wrap", |
| args = {ByteBuffer[].class, ByteBuffer.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getDelegatedTask", |
| args = {} |
| ) |
| }) |
| @KnownFailure("Handshake Status is never finished. NPE in " |
| + "ClientSessionContext$HostAndPort.hashCode() when host is null") |
| public void testHandshake() throws IOException, InterruptedException { |
| |
| prepareEngines(); |
| |
| assertTrue("handshake failed", doHandshake()); |
| |
| System.out.println(clientEngine.engine.getSession().getCipherSuite()); |
| |
| assertEquals("Handshake not finished", |
| SSLEngineResult.HandshakeStatus.FINISHED, |
| clientEngine.getStatus()); |
| assertEquals("Handshake not finished", |
| SSLEngineResult.HandshakeStatus.FINISHED, |
| serverEngine.getStatus()); |
| } |
| |
| void prepareEngines() throws IOException { |
| Pipe clientSendPipe = Pipe.open(); |
| Pipe serverSendPipe = Pipe.open(); |
| |
| SinkChannel clientSink = clientSendPipe.sink(); |
| SourceChannel serverSource = clientSendPipe.source(); |
| SinkChannel serverSink = serverSendPipe.sink(); |
| SourceChannel clientSource = serverSendPipe.source(); |
| |
| clientEngine = new HandshakeHandler(true, clientSource, clientSink); |
| serverEngine = new HandshakeHandler(false, serverSource, serverSink); |
| } |
| |
| boolean doHandshake() throws InterruptedException { |
| Thread clientThread = new Thread(clientEngine); |
| clientThread.start(); |
| |
| Thread serverThread = new Thread(serverEngine); |
| serverThread.start(); |
| |
| int i = 0; |
| while (clientThread.isAlive() && serverThread.isAlive() && i < 20) { |
| Thread.sleep(500); |
| i++; |
| } |
| |
| if (clientThread.isAlive()) { |
| clientThread.interrupt(); |
| } |
| |
| if (serverThread.isAlive()) { |
| serverThread.interrupt(); |
| } |
| |
| return clientEngine.getStatus() == HandshakeStatus.FINISHED && serverEngine.getStatus() == HandshakeStatus.FINISHED; |
| } |
| |
| } |