luni/src/test/java/tests/api/javax/net/ssl/KeyManagerFactory1Test.java - platform/libcore-snapshot - Git at Google

 /*
  *  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.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 java.security.cert.CertificateException;

 import javax.net.ssl.KeyStoreBuilderParameters;
 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;
         }
     }

     /**
      * avax.net.ssl.KeyManagerFactory#getAlgorithm()
      */
     public void test_getAlgorithm()
         throws NoSuchAlgorithmException, NoSuchProviderException {
         if (!DEFSupported) fail(NotSupportedMsg);
         assertEquals("Incorrect algorithm",
                 defaultAlgorithm,
                 KeyManagerFactory
                 .getInstance(defaultAlgorithm).getAlgorithm());
         assertEquals("Incorrect algorithm",
                 defaultAlgorithm,
                 KeyManagerFactory
                 .getInstance(defaultAlgorithm, defaultProviderName)
                 .getAlgorithm());
         assertEquals("Incorrect algorithm",
                 defaultAlgorithm,
                 KeyManagerFactory.getInstance(defaultAlgorithm, defaultProvider)
                 .getAlgorithm());
     }

        /**
      *  Test for <code>getDefaultAlgorithm()</code> method
      * Assertion: returns value which is specifoed in security property
      */
     public void test_getDefaultAlgorithm() {
         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 test_getInstanceLjava_lang_String01() throws NoSuchAlgorithmException {
         if (!DEFSupported) {
             fail(NotSupportedMsg);
             return;
         }
         KeyManagerFactory keyMF;
         for (int i = 0; i < validValues.length; i++) {
             keyMF = KeyManagerFactory.getInstance(validValues[i]);
             assertNotNull("No KeyManagerFactory created", keyMF);
             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 test_getInstanceLjava_lang_String02() {
         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 test_getInstanceLjava_lang_StringLjava_lang_String01() 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 test_getInstanceLjava_lang_StringLjava_lang_String02() 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 test_getInstanceLjava_lang_StringLjava_lang_String03()
         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 test_getInstanceLjava_lang_StringLjava_lang_String04()
         throws NoSuchProviderException,
             NoSuchAlgorithmException {
         if (!DEFSupported) {
             fail(NotSupportedMsg);
             return;
         }
         KeyManagerFactory kMF;
         for (int i = 0; i < validValues.length; i++) {
             kMF = KeyManagerFactory.getInstance(validValues[i],
                     defaultProviderName);
             assertNotNull("No KeyManagerFactory created", kMF);
             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 test_getInstanceLjava_lang_StringLjava_security_Provider01()
         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 test_getInstanceLjava_lang_StringLjava_security_Provider02() {
         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 test_getInstanceLjava_lang_StringLjava_security_Provider03()
         throws NoSuchAlgorithmException,
             IllegalArgumentException {
         if (!DEFSupported) {
             fail(NotSupportedMsg);
             return;
         }
         KeyManagerFactory kMF;
         for (int i = 0; i < validValues.length; i++) {
             kMF = KeyManagerFactory
                     .getInstance(validValues[i], defaultProvider);
             assertNotNull("No KeyManagerFactory created", kMF);
             assertEquals(kMF.getAlgorithm(), validValues[i]);
             assertEquals(kMF.getProvider(), defaultProvider);
         }
     }

     /**
      * Test for <code>KeyManagerFactory</code> constructor
      * Assertion: returns KeyManagerFactory object
      */
     public void test_Constructor() throws NoSuchAlgorithmException {
         if (!DEFSupported) {
             fail(NotSupportedMsg);
             return;
         }
         KeyManagerFactorySpi spi = new MyKeyManagerFactorySpi();
         KeyManagerFactory keyMF = new myKeyManagerFactory(spi, defaultProvider,
                 defaultAlgorithm);
         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);
         assertNull("Aalgorithm must be null", keyMF.getAlgorithm());
         assertNull("Provider must be null", keyMF.getProvider());
         try {
             keyMF.getKeyManagers();
         } catch (NullPointerException e) {
         }
     }

     /**
      * avax.net.ssl.KeyManagerFactory#getKeyManagers()
      * @throws NoSuchAlgorithmException
      * @throws KeyStoreException
      * @throws IOException
      * @throws CertificateException
      * @throws UnrecoverableKeyException
      */
     public void test_getKeyManagers()
         throws Exception {
         if (!DEFSupported) fail(NotSupportedMsg);
         KeyManagerFactory kmf = KeyManagerFactory.getInstance(defaultAlgorithm);
         char[] pass = "password".toCharArray();
         kmf.init(null, pass);
         assertNotNull("Key manager array is null", kmf.getKeyManagers());
         assertEquals("Incorrect size of array",
                 1, kmf.getKeyManagers().length);
     }

     /**
      * avax.net.ssl.KeyManagerFactory#getProvider()
      */
     public void test_getProvider()
         throws Exception {
         if (!DEFSupported) fail(NotSupportedMsg);
         assertEquals("Incorrect provider",
                 defaultProvider,
                 KeyManagerFactory
                 .getInstance(defaultAlgorithm).getProvider());
         assertEquals("Incorrect provider",
                 defaultProvider,
                 KeyManagerFactory
                 .getInstance(defaultAlgorithm, defaultProviderName)
                 .getProvider());
         assertEquals("Incorrect provider",
                 defaultProvider,
                 KeyManagerFactory.getInstance(defaultAlgorithm, defaultProvider)
                 .getProvider());
     }

     /**
      * Test for <code>init(KeyStore keyStore, char[] password)</code> and
      * <code>getKeyManagers()</code>
      * Assertion: returns not empty KeyManager array
      */
     public void test_initLjava_security_KeyStore$C()
         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 test_initLjavax_net_ssl_ManagerFactoryParameters()
         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) {
             }
         }

         KeyStore.ProtectionParameter pp = new ProtectionParameterImpl();
         KeyStore.Builder bld = KeyStore.Builder.newInstance("testType", null, pp);
         assertNotNull("Null object KeyStore.Builder", bld);

         try {
             KeyManagerFactory kmf = KeyManagerFactory.getInstance(defaultAlgorithm);
             KeyStoreBuilderParameters ksp = new KeyStoreBuilderParameters(bld);
             assertNotNull(ksp.getParameters());
             kmf.init(ksp);
             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);
     }
 }

 class ProtectionParameterImpl implements KeyStore.ProtectionParameter {
     ProtectionParameterImpl(){}
 }
	/*
	* 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.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 java.security.cert.CertificateException;

	import javax.net.ssl.KeyStoreBuilderParameters;
	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;
	}
	}

	/**
	* avax.net.ssl.KeyManagerFactory#getAlgorithm()
	*/
	public void test_getAlgorithm()
	throws NoSuchAlgorithmException, NoSuchProviderException {
	if (!DEFSupported) fail(NotSupportedMsg);
	assertEquals("Incorrect algorithm",
	defaultAlgorithm,
	KeyManagerFactory
	.getInstance(defaultAlgorithm).getAlgorithm());
	assertEquals("Incorrect algorithm",
	defaultAlgorithm,
	KeyManagerFactory
	.getInstance(defaultAlgorithm, defaultProviderName)
	.getAlgorithm());
	assertEquals("Incorrect algorithm",
	defaultAlgorithm,
	KeyManagerFactory.getInstance(defaultAlgorithm, defaultProvider)
	.getAlgorithm());
	}

	/**
	* Test for <code>getDefaultAlgorithm()</code> method
	* Assertion: returns value which is specifoed in security property
	*/
	public void test_getDefaultAlgorithm() {
	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 test_getInstanceLjava_lang_String01() throws NoSuchAlgorithmException {
	if (!DEFSupported) {
	fail(NotSupportedMsg);
	return;
	}
	KeyManagerFactory keyMF;
	for (int i = 0; i < validValues.length; i++) {
	keyMF = KeyManagerFactory.getInstance(validValues[i]);
	assertNotNull("No KeyManagerFactory created", keyMF);
	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 test_getInstanceLjava_lang_String02() {
	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 test_getInstanceLjava_lang_StringLjava_lang_String01() 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 test_getInstanceLjava_lang_StringLjava_lang_String02() 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 test_getInstanceLjava_lang_StringLjava_lang_String03()
	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 test_getInstanceLjava_lang_StringLjava_lang_String04()
	throws NoSuchProviderException,
	NoSuchAlgorithmException {
	if (!DEFSupported) {
	fail(NotSupportedMsg);
	return;
	}
	KeyManagerFactory kMF;
	for (int i = 0; i < validValues.length; i++) {
	kMF = KeyManagerFactory.getInstance(validValues[i],
	defaultProviderName);
	assertNotNull("No KeyManagerFactory created", kMF);
	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 test_getInstanceLjava_lang_StringLjava_security_Provider01()
	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 test_getInstanceLjava_lang_StringLjava_security_Provider02() {
	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 test_getInstanceLjava_lang_StringLjava_security_Provider03()
	throws NoSuchAlgorithmException,
	IllegalArgumentException {
	if (!DEFSupported) {
	fail(NotSupportedMsg);
	return;
	}
	KeyManagerFactory kMF;
	for (int i = 0; i < validValues.length; i++) {
	kMF = KeyManagerFactory
	.getInstance(validValues[i], defaultProvider);
	assertNotNull("No KeyManagerFactory created", kMF);
	assertEquals(kMF.getAlgorithm(), validValues[i]);
	assertEquals(kMF.getProvider(), defaultProvider);
	}
	}

	/**
	* Test for <code>KeyManagerFactory</code> constructor
	* Assertion: returns KeyManagerFactory object
	*/
	public void test_Constructor() throws NoSuchAlgorithmException {
	if (!DEFSupported) {
	fail(NotSupportedMsg);
	return;
	}
	KeyManagerFactorySpi spi = new MyKeyManagerFactorySpi();
	KeyManagerFactory keyMF = new myKeyManagerFactory(spi, defaultProvider,
	defaultAlgorithm);
	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);
	assertNull("Aalgorithm must be null", keyMF.getAlgorithm());
	assertNull("Provider must be null", keyMF.getProvider());
	try {
	keyMF.getKeyManagers();
	} catch (NullPointerException e) {
	}
	}

	/**
	* avax.net.ssl.KeyManagerFactory#getKeyManagers()
	* @throws NoSuchAlgorithmException
	* @throws KeyStoreException
	* @throws IOException
	* @throws CertificateException
	* @throws UnrecoverableKeyException
	*/
	public void test_getKeyManagers()
	throws Exception {
	if (!DEFSupported) fail(NotSupportedMsg);
	KeyManagerFactory kmf = KeyManagerFactory.getInstance(defaultAlgorithm);
	char[] pass = "password".toCharArray();
	kmf.init(null, pass);
	assertNotNull("Key manager array is null", kmf.getKeyManagers());
	assertEquals("Incorrect size of array",
	1, kmf.getKeyManagers().length);
	}

	/**
	* avax.net.ssl.KeyManagerFactory#getProvider()
	*/
	public void test_getProvider()
	throws Exception {
	if (!DEFSupported) fail(NotSupportedMsg);
	assertEquals("Incorrect provider",
	defaultProvider,
	KeyManagerFactory
	.getInstance(defaultAlgorithm).getProvider());
	assertEquals("Incorrect provider",
	defaultProvider,
	KeyManagerFactory
	.getInstance(defaultAlgorithm, defaultProviderName)
	.getProvider());
	assertEquals("Incorrect provider",
	defaultProvider,
	KeyManagerFactory.getInstance(defaultAlgorithm, defaultProvider)
	.getProvider());
	}

	/**
	* Test for <code>init(KeyStore keyStore, char[] password)</code> and
	* <code>getKeyManagers()</code>
	* Assertion: returns not empty KeyManager array
	*/
	public void test_initLjava_security_KeyStore$C()
	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 test_initLjavax_net_ssl_ManagerFactoryParameters()
	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) {
	}
	}

	KeyStore.ProtectionParameter pp = new ProtectionParameterImpl();
	KeyStore.Builder bld = KeyStore.Builder.newInstance("testType", null, pp);
	assertNotNull("Null object KeyStore.Builder", bld);

	try {
	KeyManagerFactory kmf = KeyManagerFactory.getInstance(defaultAlgorithm);
	KeyStoreBuilderParameters ksp = new KeyStoreBuilderParameters(bld);
	assertNotNull(ksp.getParameters());
	kmf.init(ksp);
	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);
	}
	}

	class ProtectionParameterImpl implements KeyStore.ProtectionParameter {
	ProtectionParameterImpl(){}
	}