You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by te...@apache.org on 2007/02/04 09:10:11 UTC
svn commit: r503371 [1/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...
Author: tellison
Date: Sun Feb 4 00:10:09 2007
New Revision: 503371
URL: http://svn.apache.org/viewvc?view=rev&rev=503371
Log:
Apply contribution HARMONY-2371 ([classlib][x-net]JSSE provider tests contribution)
Added:
harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/KeyManagerFactory1Test.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/KeyManagerFactory2Test.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/SSLContext1Test.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/SSLContext2Test.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/TrustManagerFactory1Test.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/TrustManagerFactory2Test.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/CipherSuiteTest.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/DelegatedTaskTest.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/DigitalSignatureTest.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/HandshakeProtocolTest.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/KeyManagerImplTest.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLEngineImplTest.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLServerSocketImplTest.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLSessionContextImplTest.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLSessionImplTest.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLSocketFactoriesTest.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLSocketFunctionalTest.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLSocketImplTest.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/SSLStreamedInputTest.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/ServerHandshakeImplTest.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java.injected/org/apache/harmony/xnet/provider/jsse/TrustManagerImplTest.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java/org/apache/harmony/xnet/tests/provider/jsse/KeyManagerFactoryImplTest.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java/org/apache/harmony/xnet/tests/provider/jsse/ProtocolVersionTest.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/impl/java/org/apache/harmony/xnet/tests/provider/jsse/TrustManagerFactoryImplTest.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/resources/key_store.bks (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/support/
harmony/enhanced/classlib/trunk/modules/x-net/src/test/support/common/
harmony/enhanced/classlib/trunk/modules/x-net/src/test/support/common/java/
harmony/enhanced/classlib/trunk/modules/x-net/src/test/support/common/java/org/
harmony/enhanced/classlib/trunk/modules/x-net/src/test/support/common/java/org/apache/
harmony/enhanced/classlib/trunk/modules/x-net/src/test/support/common/java/org/apache/harmony/
harmony/enhanced/classlib/trunk/modules/x-net/src/test/support/common/java/org/apache/harmony/xnet/
harmony/enhanced/classlib/trunk/modules/x-net/src/test/support/common/java/org/apache/harmony/xnet/provider/
harmony/enhanced/classlib/trunk/modules/x-net/src/test/support/common/java/org/apache/harmony/xnet/provider/jsse/
harmony/enhanced/classlib/trunk/modules/x-net/src/test/support/common/java/org/apache/harmony/xnet/provider/jsse/JSSETestData.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/support/common/java/org/apache/harmony/xnet/tests/
harmony/enhanced/classlib/trunk/modules/x-net/src/test/support/common/java/org/apache/harmony/xnet/tests/support/
harmony/enhanced/classlib/trunk/modules/x-net/src/test/support/common/java/org/apache/harmony/xnet/tests/support/MyKeyManagerFactorySpi.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/support/common/java/org/apache/harmony/xnet/tests/support/MySSLContextSpi.java (with props)
harmony/enhanced/classlib/trunk/modules/x-net/src/test/support/common/java/org/apache/harmony/xnet/tests/support/MyTrustManagerFactorySpi.java (with props)
Modified:
harmony/enhanced/classlib/trunk/modules/x-net/.classpath
harmony/enhanced/classlib/trunk/modules/x-net/META-INF/MANIFEST.MF
harmony/enhanced/classlib/trunk/modules/x-net/build.xml
harmony/enhanced/classlib/trunk/modules/x-net/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLContextImpl.java
harmony/enhanced/classlib/trunk/modules/x-net/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLParameters.java
Modified: harmony/enhanced/classlib/trunk/modules/x-net/.classpath
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/x-net/.classpath?view=diff&rev=503371&r1=503370&r2=503371
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/x-net/.classpath (original)
+++ harmony/enhanced/classlib/trunk/modules/x-net/.classpath Sun Feb 4 00:10:09 2007
@@ -1,11 +1,13 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
- <classpathentry output="bin/main" kind="src" path="src/main/java"/>
- <classpathentry output="bin/test/impl.injected" kind="src" path="src/test/impl/java.injected"/>
- <classpathentry output="bin/test/impl" kind="src" path="src/test/impl/java"/>
- <classpathentry output="bin/test/api" kind="src" path="src/test/api/java"/>
- <classpathentry output="bin/test/api" kind="src" path="src/test/java"/>
+ <classpathentry kind="src" output="bin/main" path="src/main/java"/>
+ <classpathentry kind="src" output="bin/test/support" path="src/test/support/common/java"/>
+ <classpathentry kind="src" output="bin/test/support" path="src/test/resources"/>
+ <classpathentry kind="src" output="bin/test/impl.injected" path="src/test/impl/java.injected"/>
+ <classpathentry kind="src" output="bin/test/impl" path="src/test/impl/java"/>
+ <classpathentry kind="src" output="bin/test/api" path="src/test/api/java"/>
+ <classpathentry kind="src" output="bin/test/api" path="src/test/java"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
- <classpathentry sourcepath="JUNIT_SRC_HOME/junitsrc.zip" kind="var" path="JUNIT_HOME/junit.jar"/>
+ <classpathentry kind="var" path="JUNIT_HOME/junit.jar" sourcepath="JUNIT_SRC_HOME/junitsrc.zip"/>
<classpathentry kind="output" path="bin/main"/>
</classpath>
Modified: harmony/enhanced/classlib/trunk/modules/x-net/META-INF/MANIFEST.MF
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/x-net/META-INF/MANIFEST.MF?view=diff&rev=503371&r1=503370&r2=503371
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/x-net/META-INF/MANIFEST.MF (original)
+++ harmony/enhanced/classlib/trunk/modules/x-net/META-INF/MANIFEST.MF Sun Feb 4 00:10:09 2007
@@ -30,7 +30,8 @@
org.apache.harmony.luni.util,
org.apache.harmony.security.fortress,
org.apache.harmony.security.tests.support;hy_usage=test;resolution:=optional,
- org.apache.harmony.testframework.serialization;hy_usage=test;resolution:=optional
+ org.apache.harmony.testframework.serialization;hy_usage=test;resolution:=optional,
+ tests.support.resource;hy_usage=test;resolution:=optional
Export-Package: javax.net,
javax.net.ssl,
org.apache.harmony.xnet.provider.jsse;hy_usage="suncompat";mandatory:="hy_usage"
Modified: harmony/enhanced/classlib/trunk/modules/x-net/build.xml
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/x-net/build.xml?view=diff&rev=503371&r1=503370&r2=503371
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/x-net/build.xml (original)
+++ harmony/enhanced/classlib/trunk/modules/x-net/build.xml Sun Feb 4 00:10:09 2007
@@ -125,7 +125,8 @@
<compile-tests description="test support files" destdir="../../build/tests">
<javac-elements>
<src>
- <!-- FIXME: X-NET tests should not reach into security module code -->
+ <pathelement location="${hy.x-net.src.test}/support/common/java" />
+ <!-- FIXME: X-NET tests should not reach into security module code -->
<pathelement location="${hy.x-net}/../security/src/test/support/common/java"/>
</src>
@@ -208,7 +209,7 @@
<run-tests description="impl injected tests">
<junit-elements>
<!-- to pick up junit.jar -->
- <jvmarg value="-Xbootclasspath/a:${hy.x-net.bin.test}/impl.injected${path.separator}../../${junit.jar}${path.separator}../../build/tests"/>
+ <jvmarg value="-Xbootclasspath/a:${hy.x-net.bin.test}/impl.injected${path.separator}../../${junit.jar}${path.separator}../../build/tests;${path.separator}${hy.hdk}/build/test/support.jar"/>
<batchtest todir="${hy.tests.reports}" haltonfailure="no" unless="test.case">
<fileset dir="${hy.x-net.src.test}/impl/java.injected">
Modified: harmony/enhanced/classlib/trunk/modules/x-net/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLContextImpl.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/x-net/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLContextImpl.java?view=diff&rev=503371&r1=503370&r2=503371
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/x-net/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLContextImpl.java (original)
+++ harmony/enhanced/classlib/trunk/modules/x-net/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLContextImpl.java Sun Feb 4 00:10:09 2007
@@ -43,6 +43,15 @@
*/
public class SSLContextImpl extends SSLContextSpi {
+ // client session context contains the set of reusable
+ // client-side SSL sessions
+ private SSLSessionContextImpl clientSessionContext =
+ new SSLSessionContextImpl();
+ // server session context contains the set of reusable
+ // server-side SSL sessions
+ private SSLSessionContextImpl serverSessionContext =
+ new SSLSessionContextImpl();
+
protected SSLParameters sslParameters;
public SSLContextImpl() {
@@ -51,7 +60,8 @@
public void engineInit(KeyManager[] kms, TrustManager[] tms,
SecureRandom sr) throws KeyManagementException {
- sslParameters = new SSLParameters(kms, tms, sr);
+ sslParameters = new SSLParameters(kms, tms, sr, clientSessionContext,
+ serverSessionContext);
}
public SSLSocketFactory engineGetSocketFactory() {
@@ -84,11 +94,11 @@
}
public SSLSessionContext engineGetServerSessionContext() {
- return sslParameters.getServerSessionContext();
+ return serverSessionContext;
}
public SSLSessionContext engineGetClientSessionContext() {
- return sslParameters.getClientSessionContext();
+ return clientSessionContext;
}
}
Modified: harmony/enhanced/classlib/trunk/modules/x-net/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLParameters.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/x-net/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLParameters.java?view=diff&rev=503371&r1=503370&r2=503371
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/x-net/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLParameters.java (original)
+++ harmony/enhanced/classlib/trunk/modules/x-net/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLParameters.java Sun Feb 4 00:10:09 2007
@@ -58,12 +58,10 @@
// client session context contains the set of reusable
// client-side SSL sessions
- private SSLSessionContextImpl clientSessionContext =
- new SSLSessionContextImpl();
+ private SSLSessionContextImpl clientSessionContext;
// server session context contains the set of reusable
// server-side SSL sessions
- private SSLSessionContextImpl serverSessionContext =
- new SSLSessionContextImpl();
+ private SSLSessionContextImpl serverSessionContext;
// source of authentication keys
private X509KeyManager keyManager;
// source of authentication trust decisions
@@ -104,8 +102,12 @@
* for more information
*/
protected SSLParameters(KeyManager[] kms, TrustManager[] tms,
- SecureRandom sr) throws KeyManagementException {
+ SecureRandom sr, SSLSessionContextImpl clientSessionContext,
+ SSLSessionContextImpl serverSessionContext)
+ throws KeyManagementException {
this();
+ this.serverSessionContext = serverSessionContext;
+ this.clientSessionContext = clientSessionContext;
try {
// initialize key manager
boolean initialize_default = false;
@@ -188,7 +190,8 @@
protected static SSLParameters getDefault() throws KeyManagementException {
if (defaultParameters == null) {
- defaultParameters = new SSLParameters(null, null, null);
+ defaultParameters = new SSLParameters(null, null, null,
+ new SSLSessionContextImpl(), new SSLSessionContextImpl());
}
return (SSLParameters) defaultParameters.clone();
}
Added: harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/KeyManagerFactory1Test.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/KeyManagerFactory1Test.java?view=auto&rev=503371
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/KeyManagerFactory1Test.java (added)
+++ harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/KeyManagerFactory1Test.java Sun Feb 4 00:10:09 2007
@@ -0,0 +1,447 @@
+/*
+ * 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.tests.javax.net.ssl;
+
+import java.security.InvalidAlgorithmParameterException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.NoSuchProviderException;
+import java.security.Provider;
+import java.security.Security;
+import java.security.UnrecoverableKeyException;
+
+import javax.net.ssl.ManagerFactoryParameters;
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.KeyManagerFactorySpi;
+
+import org.apache.harmony.security.tests.support.SpiEngUtils;
+import org.apache.harmony.xnet.tests.support.MyKeyManagerFactorySpi;
+import junit.framework.TestCase;
+
+/**
+ * Tests for <code>KeyManagerFactory</code> class constructors and methods.
+ *
+ */
+
+public class KeyManagerFactory1Test extends TestCase {
+
+ private static final String srvKeyManagerFactory = "KeyManagerFactory";
+
+ private static String defaultAlgorithm = null;
+
+ private static String defaultProviderName = null;
+
+ private static Provider defaultProvider = null;
+
+ private static boolean DEFSupported = false;
+
+ private static final String NotSupportedMsg = "There is no suitable provider for KeyManagerFactory";
+
+ private static final String[] invalidValues = SpiEngUtils.invalidValues;
+
+ private static String[] validValues = new String[3];
+ static {
+ defaultAlgorithm = Security
+ .getProperty("ssl.KeyManagerFactory.algorithm");
+ if (defaultAlgorithm != null) {
+ defaultProvider = SpiEngUtils.isSupport(defaultAlgorithm,
+ srvKeyManagerFactory);
+ DEFSupported = (defaultProvider != null);
+ defaultProviderName = (DEFSupported ? defaultProvider.getName()
+ : null);
+ validValues[0] = defaultAlgorithm;
+ validValues[1] = defaultAlgorithm.toUpperCase();
+ validValues[2] = defaultAlgorithm.toLowerCase();
+ }
+ }
+
+ protected KeyManagerFactory[] createKMFac() {
+ if (!DEFSupported) {
+ fail(defaultAlgorithm + " algorithm is not supported");
+ return null;
+ }
+ KeyManagerFactory[] kMF = new KeyManagerFactory[3];
+ try {
+ kMF[0] = KeyManagerFactory.getInstance(defaultAlgorithm);
+ kMF[1] = KeyManagerFactory.getInstance(defaultAlgorithm,
+ defaultProvider);
+ kMF[2] = KeyManagerFactory.getInstance(defaultAlgorithm,
+ defaultProviderName);
+ return kMF;
+ } catch (Exception e) {
+ e.printStackTrace();
+ return null;
+ }
+ }
+
+ /**
+ * Test for <code>getDefaultAlgorithm()</code> method
+ * Assertion: returns value which is specifoed in security property
+ */
+ public void testGetDefaultAlgorithm() {
+ if (!DEFSupported) {
+ fail(NotSupportedMsg);
+ return;
+ }
+ String def = KeyManagerFactory.getDefaultAlgorithm();
+ if (defaultAlgorithm == null) {
+ assertNull("DefaultAlgorithm must be null", def);
+ } else {
+ assertEquals("Invalid default algorithm", def, defaultAlgorithm);
+ }
+ String defA = "Proba.keymanagerfactory.defaul.type";
+ Security.setProperty("ssl.KeyManagerFactory.algorithm", defA);
+ assertEquals("Incorrect defaultAlgorithm",
+ KeyManagerFactory.getDefaultAlgorithm(), defA);
+ if (def == null) {
+ def = "";
+ }
+ Security.setProperty("ssl.KeyManagerFactory.algorithm", def);
+ assertEquals("Incorrect defaultAlgorithm",
+ KeyManagerFactory.getDefaultAlgorithm(), def);
+ }
+
+ /**
+ * Test for <code>getInstance(String algorithm)</code> method
+ * Assertions:
+ * returns security property "ssl.KeyManagerFactory.algorithm";
+ * returns instance of KeyManagerFactory
+ */
+ public void testKeyManagerFactory01() throws NoSuchAlgorithmException {
+ if (!DEFSupported) {
+ fail(NotSupportedMsg);
+ return;
+ }
+ KeyManagerFactory keyMF;
+ for (int i = 0; i < validValues.length; i++) {
+ keyMF = KeyManagerFactory.getInstance(validValues[i]);
+ assertTrue("Not KeyManagerFactory object",
+ keyMF instanceof KeyManagerFactory);
+ assertEquals("Invalid algorithm", keyMF.getAlgorithm(),
+ validValues[i]);
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String algorithm)</code> method
+ * Assertion:
+ * throws NullPointerException when algorithm is null;
+ * throws NoSuchAlgorithmException when algorithm is not correct;
+ */
+ public void testKeyManagerFactory02() {
+ try {
+ KeyManagerFactory.getInstance(null);
+ fail("NoSuchAlgorithmException or NullPointerException should be thrown (algorithm is null");
+ } catch (NoSuchAlgorithmException e) {
+ } catch (NullPointerException e) {
+ }
+ for (int i = 0; i < invalidValues.length; i++) {
+ try {
+ KeyManagerFactory.getInstance(invalidValues[i]);
+ fail("NoSuchAlgorithmException was not thrown as expected for algorithm: "
+ .concat(invalidValues[i]));
+ } catch (NoSuchAlgorithmException e) {
+ }
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String algorithm, String provider)</code>
+ * method
+ * Assertion: throws IllegalArgumentException when provider is null or empty
+ */
+ public void testKeyManagerFactory03() throws NoSuchProviderException,
+ NoSuchAlgorithmException {
+ if (!DEFSupported) {
+ fail(NotSupportedMsg);
+ return;
+ }
+ String provider = null;
+ for (int i = 0; i < validValues.length; i++) {
+ try {
+ KeyManagerFactory.getInstance(validValues[i], provider);
+ fail("Expected IllegalArgumentException was not thrown for null provider");
+ } catch (IllegalArgumentException e) {
+ }
+ try {
+ KeyManagerFactory.getInstance(validValues[i], "");
+ fail("Expected IllegalArgumentException was not thrown for empty provider");
+ } catch (IllegalArgumentException e) {
+ }
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String algorithm, String provider)</code>
+ * method
+ * Assertion:
+ * throws NullPointerException when algorithm is null;
+ * throws NoSuchAlgorithmException when algorithm is not correct;
+ */
+ public void testKeyManagerFactory04() throws NoSuchProviderException {
+ if (!DEFSupported) {
+ fail(NotSupportedMsg);
+ return;
+ }
+ try {
+ KeyManagerFactory.getInstance(null, defaultProviderName);
+ fail("NoSuchAlgorithmException or NullPointerException should be thrown (algorithm is null");
+ } catch (NoSuchAlgorithmException e) {
+ } catch (NullPointerException e) {
+ }
+ for (int i = 0; i < invalidValues.length; i++) {
+ try {
+ KeyManagerFactory.getInstance(invalidValues[i],
+ defaultProviderName);
+ fail("NoSuchAlgorithmException must be thrown (algorithm: "
+ .concat(invalidValues[i]).concat(")"));
+ } catch (NoSuchAlgorithmException e) {
+ }
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String algorithm, String provider)</code>
+ * method
+ * Assertion: throws NoSuchProviderException when provider has
+ * invalid value
+ */
+ public void testKeyManagerFactory05() throws NoSuchAlgorithmException {
+ if (!DEFSupported) {
+ fail(NotSupportedMsg);
+ return;
+ }
+ for (int i = 0; i < validValues.length; i++) {
+ for (int j = 1; j < invalidValues.length; j++) {
+ try {
+ KeyManagerFactory.getInstance(validValues[i],
+ invalidValues[j]);
+ fail("NuSuchProviderException must be thrown (algorithm: "
+ + validValues[i] + " provider: " + invalidValues[j]
+ + ")");
+ } catch (NoSuchProviderException e) {
+ }
+ }
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String algorithm, String provider)</code>
+ * method Assertion: returns instance of KeyManagerFactory
+ */
+ public void testKeyManagerFactory06() throws NoSuchProviderException,
+ NoSuchAlgorithmException {
+ if (!DEFSupported) {
+ fail(NotSupportedMsg);
+ return;
+ }
+ KeyManagerFactory kMF;
+ for (int i = 0; i < validValues.length; i++) {
+ kMF = KeyManagerFactory.getInstance(validValues[i],
+ defaultProviderName);
+ assertTrue("Not KeyManagerFactory object",
+ kMF instanceof KeyManagerFactory);
+ assertEquals("Incorrect algorithm", kMF.getAlgorithm(),
+ validValues[i]);
+ assertEquals("Incorrect provider", kMF.getProvider().getName(),
+ defaultProviderName);
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String algorithm, Provider provider)</code>
+ * method
+ * Assertion: throws IllegalArgumentException when provider is null
+ */
+ public void testKeyManagerFactory07() throws NoSuchAlgorithmException {
+ if (!DEFSupported) {
+ fail(NotSupportedMsg);
+ return;
+ }
+ Provider provider = null;
+ for (int i = 0; i < validValues.length; i++) {
+ try {
+ KeyManagerFactory.getInstance(validValues[i], provider);
+ fail("Expected IllegalArgumentException was not thrown when provider is null");
+ } catch (IllegalArgumentException e) {
+ }
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String algorithm, Provider provider)</code>
+ * method
+ * Assertion:
+ * throws NullPointerException when algorithm is null;
+ * throws NoSuchAlgorithmException when algorithm is not correct;
+ */
+ public void testKeyManagerFactory08() {
+ if (!DEFSupported) {
+ fail(NotSupportedMsg);
+ return;
+ }
+ try {
+ KeyManagerFactory.getInstance(null, defaultProvider);
+ fail("NoSuchAlgorithmException or NullPointerException should be thrown (algorithm is null");
+ } catch (NoSuchAlgorithmException e) {
+ } catch (NullPointerException e) {
+ }
+ for (int i = 0; i < invalidValues.length; i++) {
+ try {
+ KeyManagerFactory
+ .getInstance(invalidValues[i], defaultProvider);
+ fail("Expected NuSuchAlgorithmException was not thrown");
+ } catch (NoSuchAlgorithmException e) {
+ }
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String algorithm, Provider provider)</code>
+ * method
+ * Assertion: returns instance of KeyManagerFactory
+ */
+ public void testKeyManagerFactory09() throws NoSuchAlgorithmException,
+ IllegalArgumentException {
+ if (!DEFSupported) {
+ fail(NotSupportedMsg);
+ return;
+ }
+ KeyManagerFactory kMF;
+ for (int i = 0; i < validValues.length; i++) {
+ kMF = KeyManagerFactory
+ .getInstance(validValues[i], defaultProvider);
+ assertTrue(kMF instanceof KeyManagerFactory);
+ assertEquals(kMF.getAlgorithm(), validValues[i]);
+ assertEquals(kMF.getProvider(), defaultProvider);
+ }
+ }
+
+ /**
+ * Test for <code>KeyManagerFactory</code> constructor
+ * Assertion: returns KeyManagerFactory object
+ */
+ public void testKeyManagerFactory10() throws NoSuchAlgorithmException {
+ if (!DEFSupported) {
+ fail(NotSupportedMsg);
+ return;
+ }
+ KeyManagerFactorySpi spi = new MyKeyManagerFactorySpi();
+ KeyManagerFactory keyMF = new myKeyManagerFactory(spi, defaultProvider,
+ defaultAlgorithm);
+ assertTrue("Not CertStore object", keyMF instanceof KeyManagerFactory);
+ assertEquals("Incorrect algorithm", keyMF.getAlgorithm(),
+ defaultAlgorithm);
+ assertEquals("Incorrect provider", keyMF.getProvider(), defaultProvider);
+ try {
+ keyMF.init(null, new char[1]);
+ fail("UnrecoverableKeyException must be thrown");
+ } catch (UnrecoverableKeyException e) {
+ } catch (Exception e) {
+ fail("Unexpected: "+e.toString()+" was thrown");
+ }
+ keyMF = new myKeyManagerFactory(null, null, null);
+ assertTrue("Not CertStore object", keyMF instanceof KeyManagerFactory);
+ assertNull("Aalgorithm must be null", keyMF.getAlgorithm());
+ assertNull("Provider must be null", keyMF.getProvider());
+ try {
+ keyMF.getKeyManagers();
+ } catch (NullPointerException e) {
+ }
+ }
+
+ /**
+ * Test for <code>init(KeyStore keyStore, char[] password)</code> and
+ * <code>getKeyManagers()</code>
+ * Assertion: returns not empty KeyManager array
+ */
+ public void testKeyManagerFactory11() throws NoSuchAlgorithmException,
+ KeyStoreException, UnrecoverableKeyException {
+ if (!DEFSupported) {
+ fail(NotSupportedMsg);
+ return;
+ }
+ KeyManagerFactory[] keyMF = createKMFac();
+ assertNotNull("KeyManagerFactory object were not created", keyMF);
+ KeyStore ksNull = null;
+ KeyManager[] km;
+ for (int i = 0; i < keyMF.length; i++) {
+ keyMF[i].init(ksNull, new char[10]);
+ km = keyMF[i].getKeyManagers();
+ assertNotNull("Result should not be null", km);
+ assertTrue("Length of result KeyManager array should not be 0",
+ (km.length > 0));
+ }
+ KeyStore ks;
+ try {
+ ks = KeyStore.getInstance(KeyStore.getDefaultType());
+ ks.load(null, null);
+ } catch (KeyStoreException e) {
+ fail(e.toString() + "default KeyStore type is not supported");
+ return;
+ } catch (Exception e) {
+ fail("Unexpected: " + e.toString());
+ return;
+ }
+ for (int i = 0; i < keyMF.length; i++) {
+ try {
+ keyMF[i].init(ks, new char[10]);
+ } catch (KeyStoreException e) {
+ }
+ km = keyMF[i].getKeyManagers();
+ assertNotNull("Result has not be null", km);
+ assertTrue("Length of result KeyManager array should not be 0",
+ (km.length > 0));
+ }
+ }
+
+ /**
+ * Test for <code>init(ManagerFactoryParameters params)</code>
+ * Assertion:
+ * throws InvalidAlgorithmParameterException when params is null
+ */
+ public void testKeyManagerFactory12() throws NoSuchAlgorithmException {
+ if (!DEFSupported) {
+ fail(NotSupportedMsg);
+ return;
+ }
+ ManagerFactoryParameters par = null;
+ KeyManagerFactory[] keyMF = createKMFac();
+ assertNotNull("KeyManagerFactory object were not created", keyMF);
+ for (int i = 0; i < keyMF.length; i++) {
+ try {
+ keyMF[i].init(par);
+ fail("InvalidAlgorithmParameterException must be thrown");
+ } catch (InvalidAlgorithmParameterException e) {
+ }
+ }
+ }
+
+}
+
+/**
+ * Additional class for KeyManagerFactory constructor verification
+ */
+class myKeyManagerFactory extends KeyManagerFactory {
+ public myKeyManagerFactory(KeyManagerFactorySpi spi, Provider prov,
+ String alg) {
+ super(spi, prov, alg);
+ }
+}
Propchange: harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/KeyManagerFactory1Test.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/KeyManagerFactory2Test.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/KeyManagerFactory2Test.java?view=auto&rev=503371
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/KeyManagerFactory2Test.java (added)
+++ harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/KeyManagerFactory2Test.java Sun Feb 4 00:10:09 2007
@@ -0,0 +1,282 @@
+/*
+ * 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.tests.javax.net.ssl;
+
+import java.security.InvalidAlgorithmParameterException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.NoSuchProviderException;
+import java.security.Provider;
+import java.security.Security;
+import java.security.UnrecoverableKeyException;
+
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.ManagerFactoryParameters;
+
+import org.apache.harmony.security.tests.support.SpiEngUtils;
+import org.apache.harmony.xnet.tests.support.MyKeyManagerFactorySpi;
+import junit.framework.TestCase;
+
+/**
+ * Tests for KeyManagerFactory class constructors and methods
+ *
+ */
+
+public class KeyManagerFactory2Test extends TestCase {
+ private static final String srvKeyManagerFactory = "KeyManagerFactory";
+
+ private static final String defaultAlg = "KeyMF";
+
+ private static final String KeyManagerFactoryProviderClass = "org.apache.harmony.xnet.tests.support.MyKeyManagerFactorySpi";
+
+ private static final String[] invalidValues = SpiEngUtils.invalidValues;
+
+ private static final String[] validValues;
+
+ static {
+ validValues = new String[4];
+ validValues[0] = defaultAlg;
+ validValues[1] = defaultAlg.toLowerCase();
+ validValues[2] = "Keymf";
+ validValues[3] = "kEYMF";
+ }
+
+ Provider mProv;
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ mProv = (new SpiEngUtils()).new MyProvider("MyKMFProvider",
+ "Provider for testing", srvKeyManagerFactory.concat(".")
+ .concat(defaultAlg), KeyManagerFactoryProviderClass);
+ Security.insertProviderAt(mProv, 2);
+ }
+
+ /*
+ * @see TestCase#tearDown()
+ */
+ protected void tearDown() throws Exception {
+ super.tearDown();
+ Security.removeProvider(mProv.getName());
+ }
+
+ private void checkResult(KeyManagerFactory keyMF)
+ throws NoSuchAlgorithmException, UnrecoverableKeyException,
+ KeyStoreException {
+ KeyStore kStore = null;
+ ManagerFactoryParameters mfp = null;
+
+ char[] pass = { 'a', 'b', 'c' };
+
+ try {
+ keyMF.init(kStore, null);
+ fail("KeyStoreException must be thrown");
+ } catch (KeyStoreException e) {
+ }
+ try {
+ keyMF.init(kStore, pass);
+ fail("UnrecoverableKeyException must be thrown");
+ } catch (UnrecoverableKeyException e) {
+ }
+ try {
+ keyMF.init(mfp);
+ fail("InvalidAlgorithmParameterException must be thrown");
+ } catch (InvalidAlgorithmParameterException e) {
+ }
+ assertNull("getKeyManagers() should return null object", keyMF
+ .getKeyManagers());
+
+ try {
+ kStore = KeyStore.getInstance(KeyStore.getDefaultType());
+ kStore.load(null, null);
+ } catch (KeyStoreException e) {
+ fail("default keystore is not supported");
+ return;
+ } catch (Exception e) {
+ fail("Unexpected: "+e.toString());
+ return;
+ }
+ try {
+ keyMF.init(kStore, pass);
+ } catch (KeyStoreException e) {
+ fail("Unexpected KeyStoreException was thrown");
+ }
+ mfp = (ManagerFactoryParameters) new MyKeyManagerFactorySpi.Parameters(kStore, null);
+ try {
+ keyMF.init(mfp);
+ fail("InvalidAlgorithmParameterException must be thrown");
+ } catch (InvalidAlgorithmParameterException e) {
+ }
+ mfp = (ManagerFactoryParameters) new MyKeyManagerFactorySpi.Parameters(kStore, pass);
+ try {
+ keyMF.init(mfp);
+ } catch (InvalidAlgorithmParameterException e) {
+ fail("Unexpected InvalidAlgorithmParameterException was thrown");
+ }
+ }
+ /**
+ * Test for <code>getInstance(String algorithm)</code> method
+ * Assertions:
+ * throws NullPointerException when algorithm is null;
+ * throws NoSuchAlgorithmException when algorithm is not correct;
+ * returns KeyManagerFactory object
+ */
+ public void testGetInstance01() throws NoSuchAlgorithmException,
+ KeyStoreException, UnrecoverableKeyException {
+ try {
+ KeyManagerFactory.getInstance(null);
+ fail("NoSuchAlgorithmException or NullPointerException should be thrown (algorithm is null");
+ } catch (NoSuchAlgorithmException e) {
+ } catch (NullPointerException e) {
+ }
+ for (int i = 0; i < invalidValues.length; i++) {
+ try {
+ KeyManagerFactory.getInstance(invalidValues[i]);
+ fail("NoSuchAlgorithmException must be thrown (algorithm: "
+ .concat(invalidValues[i]).concat(")"));
+ } catch (NoSuchAlgorithmException e) {
+ }
+ }
+ KeyManagerFactory keyMF;
+ for (int i = 0; i < validValues.length; i++) {
+ keyMF = KeyManagerFactory.getInstance(validValues[i]);
+ assertTrue("Not instanceof KeyManagerFactory object",
+ keyMF instanceof KeyManagerFactory);
+ assertEquals("Incorrect algorithm", keyMF.getAlgorithm(),
+ validValues[i]);
+ assertEquals("Incorrect provider", keyMF.getProvider(), mProv);
+ checkResult(keyMF);
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String algorithm, String provider)</code>
+ * method
+ * Assertions:
+ * throws NullPointerException when algorithm is null;
+ * throws NoSuchAlgorithmException when algorithm is not correct;
+ * throws IllegalArgumentException when provider is null or empty;
+ * throws NoSuchProviderException when provider is available;
+ * returns KeyManagerFactory object
+ */
+ public void testGetInstance02() throws NoSuchAlgorithmException,
+ NoSuchProviderException, IllegalArgumentException,
+ KeyStoreException, UnrecoverableKeyException {
+ try {
+ KeyManagerFactory.getInstance(null, mProv.getName());
+ fail("NoSuchAlgorithmException or NullPointerException should be thrown (algorithm is null");
+ } catch (NoSuchAlgorithmException e) {
+ } catch (NullPointerException e) {
+ }
+ for (int i = 0; i < invalidValues.length; i++) {
+ try {
+ KeyManagerFactory
+ .getInstance(invalidValues[i], mProv.getName());
+ fail("NoSuchAlgorithmException must be thrown (algorithm: "
+ .concat(invalidValues[i]).concat(")"));
+ } catch (NoSuchAlgorithmException e) {
+ }
+ }
+ String prov = null;
+ for (int i = 0; i < validValues.length; i++) {
+ try {
+ KeyManagerFactory.getInstance(validValues[i], prov);
+ fail("IllegalArgumentException must be thrown when provider is null (algorithm: "
+ .concat(invalidValues[i]).concat(")"));
+ } catch (IllegalArgumentException e) {
+ }
+ try {
+ KeyManagerFactory.getInstance(validValues[i], "");
+ fail("IllegalArgumentException must be thrown when provider is empty (algorithm: "
+ .concat(invalidValues[i]).concat(")"));
+ } catch (IllegalArgumentException e) {
+ }
+ }
+ for (int i = 0; i < validValues.length; i++) {
+ for (int j = 1; j < invalidValues.length; j++) {
+ try {
+ KeyManagerFactory.getInstance(validValues[i],
+ invalidValues[j]);
+ fail("NoSuchProviderException must be thrown (algorithm: "
+ .concat(invalidValues[i]).concat(" provider: ")
+ .concat(invalidValues[j]).concat(")"));
+ } catch (NoSuchProviderException e) {
+ }
+ }
+ }
+ KeyManagerFactory keyMF;
+ for (int i = 0; i < validValues.length; i++) {
+ keyMF = KeyManagerFactory.getInstance(validValues[i], mProv
+ .getName());
+ assertTrue("Not instanceof KeyManagerFactory object",
+ keyMF instanceof KeyManagerFactory);
+ assertEquals("Incorrect algorithm", keyMF.getAlgorithm(),
+ validValues[i]);
+ assertEquals("Incorrect provider", keyMF.getProvider().getName(),
+ mProv.getName());
+ checkResult(keyMF);
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String algorithm, Provider provider)</code>
+ * method
+ * Assertions:
+ * throws NullPointerException when algorithm is null;
+ * throws NoSuchAlgorithmException when algorithm is not correct;
+ * throws IllegalArgumentException when provider is null;
+ * returns KeyManagerFactory object
+ */
+ public void testGetInstance03() throws NoSuchAlgorithmException,
+ IllegalArgumentException, KeyStoreException,
+ UnrecoverableKeyException {
+ try {
+ KeyManagerFactory.getInstance(null, mProv);
+ fail("NoSuchAlgorithmException or NullPointerException should be thrown (algorithm is null");
+ } catch (NoSuchAlgorithmException e) {
+ } catch (NullPointerException e) {
+ }
+ for (int i = 0; i < invalidValues.length; i++) {
+ try {
+ KeyManagerFactory.getInstance(invalidValues[i], mProv);
+ fail("NoSuchAlgorithmException must be thrown (algorithm: "
+ .concat(invalidValues[i]).concat(")"));
+ } catch (NoSuchAlgorithmException e) {
+ }
+ }
+ Provider prov = null;
+ for (int i = 0; i < validValues.length; i++) {
+ try {
+ KeyManagerFactory.getInstance(validValues[i], prov);
+ fail("IllegalArgumentException must be thrown when provider is null (algorithm: "
+ .concat(invalidValues[i]).concat(")"));
+ } catch (IllegalArgumentException e) {
+ }
+ }
+ KeyManagerFactory keyMF;
+ for (int i = 0; i < validValues.length; i++) {
+ keyMF = KeyManagerFactory.getInstance(validValues[i], mProv);
+ assertTrue("Not instanceof KeyManagerFactory object",
+ keyMF instanceof KeyManagerFactory);
+ assertEquals("Incorrect algorithm", keyMF.getAlgorithm(),
+ validValues[i]);
+ assertEquals("Incorrect provider", keyMF.getProvider(), mProv);
+ checkResult(keyMF);
+ }
+ }
+}
\ No newline at end of file
Propchange: harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/KeyManagerFactory2Test.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/SSLContext1Test.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/SSLContext1Test.java?view=auto&rev=503371
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/SSLContext1Test.java (added)
+++ harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/SSLContext1Test.java Sun Feb 4 00:10:09 2007
@@ -0,0 +1,419 @@
+/*
+ * 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.tests.javax.net.ssl;
+
+import java.security.KeyManagementException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.NoSuchProviderException;
+import java.security.Provider;
+import java.security.SecureRandom;
+import java.security.UnrecoverableKeyException;
+
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLContextSpi;
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.SSLSessionContext;
+import javax.net.ssl.SSLServerSocketFactory;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+
+import org.apache.harmony.security.tests.support.SpiEngUtils;
+import org.apache.harmony.xnet.tests.support.MySSLContextSpi;
+import junit.framework.TestCase;
+
+/**
+ * Tests for <code>SSLContext</code> class constructors and methods.
+ *
+ */
+
+public class SSLContext1Test extends TestCase {
+
+ private static String srvSSLContext = "SSLContext";
+
+ public static String defaultProtocol = "TLS";
+
+ private static final String NotSupportMsg = "Default protocol is not supported";
+
+ private static String defaultProviderName = null;
+
+ private static Provider defaultProvider = null;
+
+ private static final String[] invalidValues = SpiEngUtils.invalidValues;
+
+ private static boolean DEFSupported = false;
+
+ private static final String NotSupportedMsg = "There is no suitable provider for SSLContext";
+
+ private static String[] validValues = new String[3];
+ static {
+ defaultProvider = SpiEngUtils.isSupport(defaultProtocol, srvSSLContext);
+ DEFSupported = (defaultProvider != null);
+ if (DEFSupported) {
+ defaultProviderName = (DEFSupported ? defaultProvider.getName()
+ : null);
+ validValues[0] = defaultProtocol;
+ validValues[1] = defaultProtocol.toUpperCase();
+ validValues[2] = defaultProtocol.toLowerCase();
+ } else {
+ defaultProtocol = null;
+ }
+ }
+
+ protected SSLContext[] createSSLCon() {
+ if (!DEFSupported) {
+ fail(defaultProtocol + " protocol is not supported");
+ return null;
+ }
+ SSLContext[] sslC = new SSLContext[3];
+ try {
+ sslC[0] = SSLContext.getInstance(defaultProtocol);
+ sslC[1] = SSLContext.getInstance(defaultProtocol, defaultProvider);
+ sslC[2] = SSLContext.getInstance(defaultProtocol,
+ defaultProviderName);
+ return sslC;
+ } catch (Exception e) {
+ e.printStackTrace();
+ return null;
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String protocol)</code> method Assertion:
+ * returns SSLContext object
+ */
+ public void testSSLContext01() throws NoSuchAlgorithmException {
+ if (!DEFSupported) {
+ fail(NotSupportMsg);
+ return;
+ }
+ SSLContext sslContext;
+ for (int i = 0; i < validValues.length; i++) {
+ sslContext = SSLContext.getInstance(validValues[i]);
+ assertTrue("Not SSLContext object",
+ sslContext instanceof SSLContext);
+ assertEquals("Invalid protocol", sslContext.getProtocol(),
+ validValues[i]);
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String protocol)</code> method Assertion:
+ * throws NullPointerException when protocol is null; throws
+ * NoSuchAlgorithmException when protocol is not correct;
+ */
+ public void testSSLContext02() {
+ try {
+ SSLContext.getInstance(null);
+ fail("NoSuchAlgorithmException or NullPointerException should be thrown (protocol is null");
+ } catch (NoSuchAlgorithmException e) {
+ } catch (NullPointerException e) {
+ }
+ for (int i = 0; i < invalidValues.length; i++) {
+ try {
+ SSLContext.getInstance(invalidValues[i]);
+ fail("NoSuchAlgorithmException was not thrown as expected for provider: "
+ .concat(invalidValues[i]));
+ } catch (NoSuchAlgorithmException e) {
+ }
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String protocol, String provider)</code>
+ * method Assertion: throws IllegalArgumentException when provider is null
+ * or empty
+ */
+ public void testSSLContext03() throws NoSuchProviderException,
+ NoSuchAlgorithmException {
+ if (!DEFSupported) {
+ fail(NotSupportMsg);
+ return;
+ }
+ String provider = null;
+ for (int i = 0; i < validValues.length; i++) {
+ try {
+ SSLContext.getInstance(defaultProtocol, provider);
+ fail("IllegalArgumentException must be thrown when provider is null");
+ } catch (IllegalArgumentException e) {
+ }
+ try {
+ SSLContext.getInstance(defaultProtocol, "");
+ fail("IllegalArgumentException must be thrown when provider is empty");
+ } catch (IllegalArgumentException e) {
+ }
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String protocol, String provider)</code>
+ * method Assertion: throws NullPointerException when protocol is null;
+ * throws NoSuchAlgorithmException when protocol is not correct;
+ */
+ public void testSSLContext04() throws NoSuchProviderException {
+ if (!DEFSupported) {
+ fail(NotSupportMsg);
+ return;
+ }
+ try {
+ SSLContext.getInstance(null, defaultProviderName);
+ fail("NoSuchAlgorithmException or NullPointerException should be thrown (protocol is null");
+ } catch (NoSuchAlgorithmException e) {
+ } catch (NullPointerException e) {
+ }
+ for (int i = 0; i < invalidValues.length; i++) {
+ try {
+ SSLContext.getInstance(invalidValues[i], defaultProviderName);
+ fail("NoSuchAlgorithmException was not thrown as expected (protocol: "
+ .concat(invalidValues[i]).concat(")"));
+ } catch (NoSuchAlgorithmException e) {
+ }
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String protocol, String provider)</code>
+ * method Assertion: throws NoSuchProviderException when provider has
+ * invalid value
+ */
+ public void testSSLContext05() throws NoSuchAlgorithmException {
+ if (!DEFSupported) {
+ fail(NotSupportMsg);
+ return;
+ }
+ for (int i = 1; i < invalidValues.length; i++) {
+ for (int j = 0; j < validValues.length; j++) {
+ try {
+ SSLContext.getInstance(validValues[j], invalidValues[i]);
+ fail("NuSuchProviderException must be thrown (protocol: "
+ .concat(validValues[j]).concat(" provider: ")
+ .concat(invalidValues[i]).concat(")"));
+ } catch (NoSuchProviderException e) {
+ }
+ }
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String protocol, String provider)</code>
+ * method Assertion: returns instance of SSLContext
+ */
+ public void testSSLContext06() throws NoSuchAlgorithmException,
+ NoSuchProviderException {
+ if (!DEFSupported) {
+ fail(NotSupportMsg);
+ return;
+ }
+ SSLContext sslContext;
+ for (int i = 0; i < validValues.length; i++) {
+ sslContext = SSLContext.getInstance(validValues[i],
+ defaultProviderName);
+ assertTrue("Not SSLContext object",
+ sslContext instanceof SSLContext);
+ assertEquals("Invalid protocol", sslContext.getProtocol(),
+ validValues[i]);
+ assertEquals("Invalid provider", sslContext.getProvider(),
+ defaultProvider);
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String protocol, Provider provider)</code>
+ * method Assertion: throws IllegalArgumentException when provider is null
+ */
+ public void testSSLContext07() throws NoSuchAlgorithmException {
+ if (!DEFSupported) {
+ fail(NotSupportMsg);
+ return;
+ }
+ Provider provider = null;
+ for (int i = 0; i < validValues.length; i++) {
+ try {
+ SSLContext.getInstance(validValues[i], provider);
+ fail("IllegalArgumentException must be thrown when provider is null");
+ } catch (IllegalArgumentException e) {
+ }
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String protocol, Provider provider)</code>
+ * method Assertion: throws NullPointerException when protocol is null;
+ * throws NoSuchAlgorithmException when protocol is not correct;
+ */
+ public void testSSLContext08() {
+ if (!DEFSupported) {
+ fail(NotSupportMsg);
+ return;
+ }
+ try {
+ SSLContext.getInstance(null, defaultProvider);
+ fail("NoSuchAlgorithmException or NullPointerException should be thrown (protocol is null");
+ } catch (NoSuchAlgorithmException e) {
+ } catch (NullPointerException e) {
+ }
+ for (int i = 0; i < invalidValues.length; i++) {
+ try {
+ SSLContext.getInstance(invalidValues[i], defaultProvider);
+ fail("Expected NoSuchAlgorithmException was not thrown as expected");
+ } catch (NoSuchAlgorithmException e) {
+ }
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String protocol, Provider provider)</code>
+ * method Assertion: returns instance of SSLContext
+ */
+ public void testSSLContext09() throws NoSuchAlgorithmException {
+ if (!DEFSupported) {
+ fail(NotSupportMsg);
+ return;
+ }
+ SSLContext sslContext;
+ for (int i = 0; i < validValues.length; i++) {
+ sslContext = SSLContext
+ .getInstance(validValues[i], defaultProvider);
+ assertTrue("Not SSLContext object",
+ sslContext instanceof SSLContext);
+ assertEquals("Invalid protocol", sslContext.getProtocol(),
+ validValues[i]);
+ assertEquals("Invalid provider", sslContext.getProvider(),
+ defaultProvider);
+ }
+ }
+
+ /**
+ * Test for <code>getClientSessionContext()</code>
+ * <code>getServiceSessionContext()</code>
+ * methods Assertion: returns correspondent object
+ */
+ public void testSSLContext10() throws NoSuchAlgorithmException {
+ if (!DEFSupported) {
+ fail(NotSupportMsg);
+ return;
+ }
+ SSLContext[] sslC = createSSLCon();
+ assertNotNull("SSLContext objects were not created", sslC);
+ for (int i = 0; i < sslC.length; i++) {
+ assertTrue(sslC[i].getClientSessionContext() instanceof SSLSessionContext);
+ assertTrue(sslC[i].getServerSessionContext() instanceof SSLSessionContext);
+ }
+ }
+
+ /**
+ * Test for <code>getServerSocketFactory()</code>
+ * <code>getSocketFactory()</code>
+ * <code>init(KeyManager[] km, TrustManager[] tm, SecureRandom random)</code>
+ * methods Assertion: returns correspondent object
+ *
+ */
+
+ public void testSSLContext11() throws NoSuchAlgorithmException,
+ KeyManagementException, KeyStoreException,
+ UnrecoverableKeyException {
+ if (!DEFSupported) {
+ fail(NotSupportMsg);
+ return;
+ }
+ SSLContext[] sslC = createSSLCon();
+ assertNotNull("SSLContext objects were not created", sslC);
+ String tAlg = TrustManagerFactory.getDefaultAlgorithm();
+ String kAlg = KeyManagerFactory.getDefaultAlgorithm();
+ if (tAlg == null) {
+ fail("TrustManagerFactory default algorithm is not defined");
+ return;
+ }
+ if (kAlg == null) {
+ fail("KeyManagerFactory default algorithm is not defined");
+ return;
+ }
+ KeyManagerFactory kmf = KeyManagerFactory.getInstance(kAlg);
+ KeyStore ks = null;
+ kmf.init(ks, new char[10]);
+ KeyManager[] kms = kmf.getKeyManagers();
+ TrustManagerFactory tmf = TrustManagerFactory.getInstance(tAlg);
+ tmf.init(ks);
+ TrustManager[] tms = tmf.getTrustManagers();
+ for (int i = 0; i < sslC.length; i++) {
+ sslC[i].init(kms, tms, new SecureRandom());
+ assertTrue(sslC[i].getServerSocketFactory() instanceof SSLServerSocketFactory);
+ assertTrue(sslC[i].getSocketFactory() instanceof SSLSocketFactory);
+ }
+ }
+
+ /**
+ * Test for <code>SSLContext</code> constructor Assertion: returns
+ * SSLContext object
+ */
+ public void testSSLContext12() throws NoSuchAlgorithmException,
+ KeyManagementException {
+ if (!DEFSupported) {
+ fail(NotSupportMsg);
+ return;
+ }
+ SSLContextSpi spi = new MySSLContextSpi();
+ SSLContext sslContext = new mySSLContext(spi, defaultProvider,
+ defaultProtocol);
+ assertTrue("Not CertStore object", sslContext instanceof SSLContext);
+ assertEquals("Incorrect protocol", sslContext.getProtocol(),
+ defaultProtocol);
+ assertEquals("Incorrect provider", sslContext.getProvider(),
+ defaultProvider);
+ TrustManager[] tm = null;
+ KeyManager[] km = null;
+ sslContext.init(km, tm, new SecureRandom());
+ assertTrue(sslContext.createSSLEngine() instanceof SSLEngine);
+ assertTrue(sslContext.createSSLEngine("host host", 8888) instanceof SSLEngine);
+ try {
+ sslContext.init(km, tm, null);
+ fail("KeyManagementException should be thrown for null SEcureRandom");
+ } catch (KeyManagementException e) {
+ }
+
+ sslContext = new mySSLContext(null, null, null);
+ assertTrue("Not CertStore object", sslContext instanceof SSLContext);
+ assertNull("Incorrect protocol", sslContext.getProtocol());
+ assertNull("Incorrect provider", sslContext.getProvider());
+ try {
+ sslContext.createSSLEngine();
+ fail("NullPointerException should be thrown");
+ } catch (NullPointerException e) {
+ }
+ try {
+ sslContext.getSocketFactory();
+ fail("NullPointerException should be thrown");
+ } catch (NullPointerException e) {
+ }
+ }
+
+}
+
+/**
+ * Addifional class to verify SSLContext constructor
+ */
+
+class mySSLContext extends SSLContext {
+ public mySSLContext(SSLContextSpi spi, Provider prov, String alg) {
+ super(spi, prov, alg);
+ }
+}
\ No newline at end of file
Propchange: harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/SSLContext1Test.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/SSLContext2Test.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/SSLContext2Test.java?view=auto&rev=503371
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/SSLContext2Test.java (added)
+++ harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/SSLContext2Test.java Sun Feb 4 00:10:09 2007
@@ -0,0 +1,299 @@
+/*
+ * 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.tests.javax.net.ssl;
+
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+import java.security.NoSuchProviderException;
+import java.security.Provider;
+import java.security.SecureRandom;
+import java.security.Security;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.TrustManager;
+
+import org.apache.harmony.security.tests.support.SpiEngUtils;
+import org.apache.harmony.xnet.tests.support.MySSLContextSpi;
+import junit.framework.TestCase;
+
+/**
+ * Tests for SSLContext class constructors and methods
+ *
+ */
+
+public class SSLContext2Test extends TestCase {
+
+ private static String srvSSLContext = "SSLContext";
+
+ private static final String defaultProtocol = "S+S+L";
+
+ public static final String SSLContextProviderClass = "org.apache.harmony.xnet.tests.support.MySSLContextSpi";
+
+ private static final String[] invalidValues = SpiEngUtils.invalidValues;
+
+ private static final String[] validValues;
+ static {
+ validValues = new String[4];
+ validValues[0] = defaultProtocol;
+ validValues[1] = defaultProtocol.toLowerCase();
+ validValues[2] = "s+S+L";
+ validValues[3] = "S+s+L";
+ }
+
+ Provider mProv;
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ mProv = (new SpiEngUtils()).new MyProvider("MySSLContextProvider", "Provider for testing",
+ srvSSLContext.concat(".").concat(defaultProtocol),
+ SSLContextProviderClass);
+ Security.insertProviderAt(mProv, 1);
+ }
+
+ /*
+ * @see TestCase#tearDown()
+ */
+ protected void tearDown() throws Exception {
+ super.tearDown();
+ Security.removeProvider(mProv.getName());
+ }
+
+ private void checkSSLContext(SSLContext sslC)
+ throws KeyManagementException {
+
+ try {
+ sslC.getSocketFactory();
+ fail("RuntimeException must be thrown");
+ } catch (RuntimeException e) {
+ assertEquals("Incorrect message", e.getMessage(),"Not initialiazed");
+ }
+ try {
+ sslC.getServerSocketFactory();
+ fail("RuntimeException must be thrown");
+ } catch (RuntimeException e) {
+ assertEquals("Incorrect message", e.getMessage(),"Not initialiazed");
+ }
+ try {
+ sslC.getServerSessionContext();
+ fail("RuntimeException must be thrown");
+ } catch (RuntimeException e) {
+ assertEquals("Incorrect message", e.getMessage(),"Not initialiazed");
+ }
+ try {
+ sslC.getClientSessionContext();
+ fail("RuntimeException must be thrown");
+ } catch (RuntimeException e) {
+ assertEquals("Incorrect message", e.getMessage(),"Not initialiazed");
+ }
+ try {
+ sslC.createSSLEngine();
+ fail("RuntimeException must be thrown");
+ } catch (RuntimeException e) {
+ assertEquals("Incorrect message", e.getMessage(),"Not initialiazed");
+ }
+ try {
+ sslC.createSSLEngine("host",1);
+ fail("RuntimeException must be thrown");
+ } catch (RuntimeException e) {
+ assertEquals("Incorrect message", e.getMessage(),"Not initialiazed");
+ }
+ TrustManager [] tm = new TManager[10];
+ KeyManager [] km = new KManager[5];
+ try {
+ sslC.init(km, tm, null);
+ fail("KeyManagementException must be thrown");
+ } catch (KeyManagementException e) {
+ }
+ sslC.init(km, tm, new SecureRandom());
+
+ SSLEngine sslE = sslC.createSSLEngine();
+ assertTrue("Not null result",sslE instanceof SSLEngine);
+ assertNull("Incorrect host", sslE.getPeerHost());
+ assertEquals("Incorrect port", sslE.getPeerPort(), 0);
+ String host = "ZZZ";
+ int port = 8080;
+ sslE = sslC.createSSLEngine(host, port);
+ assertTrue("Not null result",sslE instanceof SSLEngine);
+ assertEquals("Incorrect host", sslE.getPeerHost(), host);
+ assertEquals("Incorrect port", sslE.getPeerPort(), port);
+ try {
+ assertNull("Not null result", sslC.getServerSessionContext());
+ } catch (NullPointerException e) {
+ }
+ try {
+ assertNull("Not null result", sslC.getClientSessionContext());
+ } catch (NullPointerException e) {
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String protocol)</code> method
+ * Assertions:
+ * throws NullPointerException when protocol is null;
+ * throws NoSuchAlgorithmException when protocol is not correct;
+ * returns SSLContext object
+ */
+ public void testGetInstance01() throws NoSuchAlgorithmException,
+ KeyManagementException {
+ try {
+ SSLContext.getInstance(null);
+ fail("NoSuchAlgorithmException or NullPointerException should be thrown (protocol is null");
+ } catch (NoSuchAlgorithmException e) {
+ } catch (NullPointerException e) {
+ }
+ for (int i = 0; i < invalidValues.length; i++) {
+ try {
+ SSLContext.getInstance(invalidValues[i]);
+ fail("NoSuchAlgorithmException must be thrown (protocol: "
+ .concat(invalidValues[i]).concat(")"));
+ } catch (NoSuchAlgorithmException e) {
+ }
+ }
+ SSLContext sslC;
+ for (int i = 0; i < validValues.length; i++) {
+ sslC = SSLContext.getInstance(validValues[i]);
+ assertTrue("Not instanceof SSLContext object",
+ sslC instanceof SSLContext);
+ assertEquals("Incorrect protocol", sslC.getProtocol(),
+ validValues[i]);
+ assertEquals("Incorrect provider", sslC.getProvider(), mProv);
+ checkSSLContext(sslC);
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String protocol, String provider)</code>
+ * method
+ * Assertions:
+ * throws NullPointerException when protocol is null;
+ * throws NoSuchAlgorithmException when protocol is not correct;
+ * throws IllegalArgumentException when provider is null or empty;
+ * throws NoSuchProviderException when provider is available;
+ * returns SSLContext object
+ */
+ public void testGetInstance02() throws NoSuchAlgorithmException,
+ NoSuchProviderException, IllegalArgumentException,
+ KeyManagementException {
+ try {
+ SSLContext.getInstance(null, mProv.getName());
+ fail("NoSuchAlgorithmException or NullPointerException should be thrown (protocol is null");
+ } catch (NoSuchAlgorithmException e) {
+ } catch (NullPointerException e) {
+ }
+ for (int i = 0; i < invalidValues.length; i++) {
+ try {
+ SSLContext.getInstance(invalidValues[i], mProv.getName());
+ fail("NoSuchAlgorithmException must be thrown (protocol: "
+ .concat(invalidValues[i]).concat(")"));
+ } catch (NoSuchAlgorithmException e) {
+ }
+ }
+ String prov = null;
+ for (int i = 0; i < validValues.length; i++) {
+ try {
+ SSLContext.getInstance(validValues[i], prov);
+ fail("IllegalArgumentException must be thrown when provider is null (protocol: "
+ .concat(invalidValues[i]).concat(")"));
+ } catch (IllegalArgumentException e) {
+ }
+ try {
+ SSLContext.getInstance(validValues[i], "");
+ fail("IllegalArgumentException must be thrown when provider is empty (protocol: "
+ .concat(invalidValues[i]).concat(")"));
+ } catch (IllegalArgumentException e) {
+ }
+ }
+ for (int i = 0; i < validValues.length; i++) {
+ for (int j = 1; j < invalidValues.length; j++) {
+ try {
+ SSLContext.getInstance(validValues[i], invalidValues[j]);
+ fail("NoSuchProviderException must be thrown (protocol: "
+ .concat(invalidValues[i]).concat(" provider: ")
+ .concat(invalidValues[j]).concat(")"));
+ } catch (NoSuchProviderException e) {
+ }
+ }
+ }
+ SSLContext sslC;
+ for (int i = 0; i < validValues.length; i++) {
+ sslC = SSLContext.getInstance(validValues[i], mProv.getName());
+ assertTrue("Not instanceof SSLContext object",
+ sslC instanceof SSLContext);
+ assertEquals("Incorrect protocol", sslC.getProtocol(),
+ validValues[i]);
+ assertEquals("Incorrect provider", sslC.getProvider().getName(),
+ mProv.getName());
+ checkSSLContext(sslC);
+ }
+ }
+
+ /**
+ * Test for <code>getInstance(String protocol, Provider provider)</code>
+ * method
+ * Assertions:
+ * throws NullPointerException when protocol is null;
+ * throws NoSuchAlgorithmException when protocol is not correct;
+ * throws IllegalArgumentException when provider is null;
+ * returns SSLContext object
+ */
+ public void testGetInstance03() throws NoSuchAlgorithmException,
+ IllegalArgumentException, KeyManagementException {
+ try {
+ SSLContext.getInstance(null, mProv);
+ fail("NoSuchAlgorithmException or NullPointerException should be thrown (protocol is null");
+ } catch (NoSuchAlgorithmException e) {
+ } catch (NullPointerException e) {
+ }
+ for (int i = 0; i < invalidValues.length; i++) {
+ try {
+ SSLContext.getInstance(invalidValues[i], mProv);
+ fail("NoSuchAlgorithmException must be thrown (protocol: "
+ .concat(invalidValues[i]).concat(")"));
+ } catch (NoSuchAlgorithmException e) {
+ }
+ }
+ Provider prov = null;
+ for (int i = 0; i < validValues.length; i++) {
+ try {
+ SSLContext.getInstance(validValues[i], prov);
+ fail("IllegalArgumentException must be thrown when provider is null (protocol: "
+ .concat(invalidValues[i]).concat(")"));
+ } catch (IllegalArgumentException e) {
+ }
+ }
+ SSLContext sslC;
+ for (int i = 0; i < validValues.length; i++) {
+ sslC = SSLContext.getInstance(validValues[i], mProv);
+ assertTrue("Not instanceof SSLContext object",
+ sslC instanceof SSLContext);
+ assertEquals("Incorrect protocol", sslC.getProtocol(),
+ validValues[i]);
+ assertEquals("Incorrect provider", sslC.getProvider(), mProv);
+ checkSSLContext(sslC);
+ }
+ }
+
+ class TManager implements TrustManager {
+
+ }
+ class KManager implements KeyManager {
+
+ }
+}
\ No newline at end of file
Propchange: harmony/enhanced/classlib/trunk/modules/x-net/src/test/api/java/org/apache/harmony/xnet/tests/javax/net/ssl/SSLContext2Test.java
------------------------------------------------------------------------------
svn:eol-style = native