/*
 *  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.
 */

/**
 * @author Vera Y. Petrashkova
 */

package org.apache.harmony.security.tests.java.security;

import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.KeyStoreSpi;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.Provider;
import java.security.UnrecoverableEntryException;
import java.security.UnrecoverableKeyException;
import java.security.cert.Certificate;
import java.util.Arrays;

import org.apache.harmony.security.tests.support.KeyStoreTestSupport;
import org.apache.harmony.security.tests.support.MyKeyStoreSpi;
import org.apache.harmony.security.tests.support.MyLoadStoreParams;
import org.apache.harmony.security.tests.support.SpiEngUtils;
import org.apache.harmony.security.tests.support.TestKeyPair;

import junit.framework.TestCase;

/**
 * Tests for <code>KeyStore</code> constructor and methods
 */

public class KeyStore_Impl1Test extends TestCase {

    public static final String srvKeyStore = KeyStoreTestSupport.srvKeyStore;
    public static String[] validValues = KeyStoreTestSupport.validValues;

    private static final String[] aliases = { "", "alias", "Alias", "ALIAS",
            "new alias", "another alias", "ADDITIONAL", "THE SAME ALIAS" };

    private static String[] invalidValues = SpiEngUtils.invalidValues;

    public static String defaultType = KeyStoreTestSupport.defaultType;
    public static boolean JKSSupported = KeyStoreTestSupport.JKSSupported;
    public static String defaultProviderName = KeyStoreTestSupport.defaultProviderName;
    public static Provider defaultProvider = KeyStoreTestSupport.defaultProvider;

    private static String NotSupportMsg = "Default KeyStore type is not supported";

    public KeyStore[] createKS() throws Exception {
        assertTrue(NotSupportMsg, JKSSupported);
        KeyStore[] kpg = new KeyStore[3];

        kpg[0] = KeyStore.getInstance(defaultType);
        kpg[1] = KeyStore.getInstance(defaultType, defaultProvider);
        kpg[2] = KeyStore.getInstance(defaultType, defaultProviderName);
        return kpg;
    }

    /**
     * Test for <code>getInstance(String type)</code> method
     * Assertion:
     * returns KeyStoreException object
     */
    public void testKeyStore03() throws KeyStoreException {
        assertTrue(NotSupportMsg, JKSSupported);
        KeyStore ks;
        for (int i = 0; i < validValues.length; i++) {
            ks = KeyStore.getInstance(validValues[i]);
            assertEquals("Incorrect type", ks.getType(), validValues[i]);
        }
    }

    /**
     * Test for <code>getInstance(String type, String provider)</code> method
     * Assertion: throws IllegalArgumentException when provider is null or empty
     */
    public void testKeyStore04() throws Exception {
        assertTrue(NotSupportMsg, JKSSupported);
        String provider = null;
        for (int i = 0; i < validValues.length; i++) {
            try {
                KeyStore.getInstance(validValues[i], provider);
                fail("IllegalArgumentException must be thrown when provider is null (type: "
                        .concat(validValues[i]).concat(" )"));
            } catch (IllegalArgumentException e) {
            }
            try {
                KeyStore.getInstance(validValues[i], "");
                fail("IllegalArgumentException must be thrown when provider is empty (type: "
                        .concat(validValues[i]).concat(" )"));
            } catch (IllegalArgumentException e) {
            }
        }
    }

    /**
     * Test for <code>getInstance(String type, String provider)</code> method
     * Assertion: throws NoSuchProviderException when provider is not available
     */
    public void testKeyStore05() throws KeyStoreException {
        assertTrue(NotSupportMsg, JKSSupported);
        for (int i = 0; i < validValues.length; i++) {
            for (int j = 1; j < invalidValues.length; j++) {
                try {
                    KeyStore.getInstance(validValues[i], invalidValues[j]);
                    fail("NoSuchProviderException must be thrown (type: "
                            .concat(validValues[i]).concat("  provider: ")
                            .concat(invalidValues[j]).concat(" )"));
                } catch (NoSuchProviderException e) {
                }
            }
        }
    }

    /**
     * Test for <code>getInstance(String type, String provider)</code> method
     * Assertion:
     * throws NullPointerException when type is null
     * throws KeyStoreException when type is not available
     */
    public void testKeyStore06() throws NoSuchProviderException {
        assertTrue(NotSupportMsg, JKSSupported);
        try {
            KeyStore.getInstance(null, defaultProviderName);
            fail("KeyStoreException must be thrown  when type is null");
        } catch (KeyStoreException e) {
        } catch (NullPointerException e) {
        }
        for (int i = 0; i < invalidValues.length; i++) {
            try {
                KeyStore.getInstance(invalidValues[i], defaultProviderName);
                fail("KeyStoreException must be thrown (type: ".concat(
                        invalidValues[i]).concat("  provider: ").concat(
                        defaultProviderName).concat(" )"));
            } catch (KeyStoreException e) {
            }
        }
    }

    /**
     * Test for <code>getInstance(String type, String provider)</code> method
     * Assertion: returns KeyStore object
     */
    public void testKeyStore07() throws Exception {
        assertTrue(NotSupportMsg, JKSSupported);
        KeyStore ks;
        for (int i = 0; i < validValues.length; i++) {
            ks = KeyStore.getInstance(validValues[i], defaultProviderName);
            assertEquals("Incorrect type", ks.getType(), validValues[i]);
            assertEquals("Incorrect provider", ks.getProvider().getName(),
                    defaultProviderName);
        }
    }

    /**
     * Test for <code>getInstance(String type, Provider provider)</code> method
     * Assertion: throws IllegalArgumentException when provider is null
     */
    public void testKeyStore08() throws KeyStoreException {
        assertTrue(NotSupportMsg, JKSSupported);
        Provider provider = null;
        for (int i = 0; i < validValues.length; i++) {
            try {
                KeyStore.getInstance(validValues[i], provider);
                fail("IllegalArgumentException must be thrown when provider is null (type: "
                        .concat(validValues[i]).concat(" )"));
            } catch (IllegalArgumentException e) {
            }
        }
    }

    /**
     * Test for <code>getInstance(String type, Provider provider)</code>
     * method
     * Assertions:
     * throws NullPointerException when type is null
     * throws KeyStoreException when type is not available
     */
    public void testKeyStore09() {
        assertTrue(NotSupportMsg, JKSSupported);
        try {
            KeyStore.getInstance(null, defaultProvider);
            fail("KeyStoreException must be thrown when type is null");
        } catch (KeyStoreException e) {
        } catch (NullPointerException e) {
        }
        for (int i = 0; i < invalidValues.length; i++) {
            try {
                KeyStore.getInstance(invalidValues[i], defaultProvider);
                fail("KeyStoreException must be thrown when type is null (type: "
                        .concat(invalidValues[i]).concat(" provider: ").concat(
                                defaultProvider.getName()).concat(" )"));
            } catch (KeyStoreException e) {
            }
        }
    }

    /**
     * Test for <code>getInstance(String type, Provider provider)</code>
     * method
     * Assertion: returns KeyStore object
     */
    public void testKeyStore10() throws KeyStoreException {
        assertTrue(NotSupportMsg, JKSSupported);
        KeyStore ks;
        for (int i = 0; i < validValues.length; i++) {
            ks = KeyStore.getInstance(validValues[i], defaultProvider);
            assertEquals("Incorrect type", ks.getType(), validValues[i]);
            assertEquals("Incorrect provider", ks.getProvider(),
                    defaultProvider);
        }
    }

    /**
     * Test for methods:
     * <code>getKey(String alias, char[] password)</code>
     * <code>getCertificateChain(String alias)</code>
     * <code>getCertificate(String alias)</code>
     * <code>getCreationDate(String alias)</code>
     * <code>setKeyEntry(String alias, Key key, char[] password, Certificate[] chain)</code>
     * <code>setKeyEntry(String alias, byte[] key, Certificate[] chain)</code>
     * <code>setCertificateEntry(String alias, Certificate cert)</code>
     * <code>deleteEntry(String alias)</code>
     * <code>Enumeration aliases()</code>
     * <code>containsAlias(String alias)</code>
     * <code>size()</code>
     * <code>isKeyEntry(String alias)</code>
     * <code>isCertificateEntry(String alias)</code>
     * <code>getCertificateAlias(Certificate cert)</code>
     * <code>store(OutputStream stream, char[] password)</code>
     * Assertion: throws KeyStoreException when KeyStore was not initialized
     */
    public void testKeyStore11() throws Exception {
        assertTrue(NotSupportMsg, JKSSupported);
        String msgF = "KeyStoreException must be thrown because KeyStore was not initialized";
        KeyStore[] kss = createKS();
        assertNotNull("KeyStore objects were not created", kss);
        for (int i = 0; i < kss.length; i++) {
            try {
                kss[i].getKey("", new char[1]);
                fail(msgF);
            } catch (KeyStoreException e) {
            }
            try {
                kss[i].getCertificateChain("");
                fail(msgF);
            } catch (KeyStoreException e) {
            }
            try {
                kss[i].getCertificate("");
                fail(msgF);
            } catch (KeyStoreException e) {
            }
            try {
                kss[i].getCreationDate("");
                fail(msgF);
            } catch (KeyStoreException e) {
            }
            try {
                kss[i].aliases();
                fail(msgF);
            } catch (KeyStoreException e) {
            }
            try {
                kss[i].containsAlias("");
                fail(msgF);
            } catch (KeyStoreException e) {
            }
            try {
                kss[i].size();
                fail(msgF);
            } catch (KeyStoreException e) {
            }
            try {
                kss[i].setKeyEntry("", null, new char[0], new Certificate[0]);
                fail(msgF);
            } catch (KeyStoreException e) {
            }
            try {
                kss[i].setKeyEntry("", new byte[0], new Certificate[0]);
                fail(msgF);
            } catch (KeyStoreException e) {
            }
            try {
                kss[i].setCertificateEntry("", null);
                fail(msgF);
            } catch (KeyStoreException e) {
            }
            try {
                kss[i].deleteEntry("");
                fail(msgF);
            } catch (KeyStoreException e) {
            }
            try {
                kss[i].isKeyEntry("");
                fail(msgF);
            } catch (KeyStoreException e) {
            }
            try {
                kss[i].isCertificateEntry("");
                fail(msgF);
            } catch (KeyStoreException e) {
            }
            try {
                kss[i].getCertificateAlias(null);
                fail(msgF);
            } catch (KeyStoreException e) {
            }
            ByteArrayOutputStream ba = new ByteArrayOutputStream();
            try {
                kss[i].store(ba, new char[0]);
                fail(msgF);
            } catch (KeyStoreException e) {
            }
            try {
                kss[i].store(new MyLoadStoreParams(
                        new KeyStore.PasswordProtection(new char[0])));
                fail(msgF);
            } catch (KeyStoreException e) {
            }
            KeyStore.TrustedCertificateEntry entry = new KeyStore.TrustedCertificateEntry(
                    new KeyStoreTestSupport.MCertificate("type", new byte[0]));
            try {
                kss[i].setEntry("aaa", entry, null);
                fail(msgF);
            } catch (KeyStoreException e) {
            }
            try {
                kss[i].getEntry("aaa", null);
                fail(msgF);
            } catch (KeyStoreException e) {
            }
        }
    }

    /**
     * Test for
     * <code>setEntry(String alias, KeyStore.Entry entry, KeyStore.ProtectionParameter params)</code>
     * <code>containsAlias(String alias)</code>
     * <code>getEntry(String alias)</code>
     * <code>getCertificate(String alias)</code>
     * <code>isCertificateEntry(String alias)</code>
     * <code>isKeyEntry(String alias)</code>
     * methods Assertions: setEntry(..) throws NullPointerException when alias
     * or entry is null;
     * <p/>
     * containsAlias(..), getEntry(..), isCertificateEntry(..), isKeyEntry(...)
     * throw NullPointerException when alias is null;
     * <p/>
     * setEntry(..) stores Entry and getEntry(..) returns it when
     * KeyStore.TrustedCertificateEntry is used; getCertificate(...) returns
     * used trusted certificate.
     */
    public void testEntry01() throws Exception {
        assertTrue(NotSupportMsg, JKSSupported);
        KeyStoreTestSupport.MCertificate trust = new KeyStoreTestSupport.MCertificate(
                "type", new byte[0]);
        KeyStore.TrustedCertificateEntry entry = new KeyStore.TrustedCertificateEntry(
                trust);
        KeyStore[] kss = createKS();
        assertNotNull("KeyStore objects were not created", kss);

        for (int i = 0; i < kss.length; i++) {
            kss[i].load(null, null);
            try {
                kss[i].setEntry(null, entry, null);
                fail("NullPointerException should be thrown when alias is null");
            } catch (NullPointerException e) {
            }
            try {
                kss[i].setEntry("ZZZ", null, null);
                fail("NullPointerException should be thrown when entry is null");
            } catch (NullPointerException e) {
            }
            for (int j = 0; j < aliases.length; j++) {
                kss[i].setEntry(aliases[j], entry, null);
            }
        }
        for (int i = 0; i < kss.length; i++) {
            try {
                kss[i].containsAlias(null);
                fail("NullPointerException should be thrown when alias is null");
            } catch (NullPointerException e) {
            }
            try {
                kss[i].isCertificateEntry(null);
                fail("NullPointerException should be thrown when alias is null");
            } catch (NullPointerException e) {
            }
            try {
                kss[i].isKeyEntry(null);
                fail("NullPointerException should be thrown when alias is null");
            } catch (NullPointerException e) {
            }
            try {
                kss[i].getEntry(null, null);
                fail("NullPointerException should be thrown when alias is null");
            } catch (NullPointerException e) {
            }
            KeyStore.Entry en;
            for (int j = 0; j < aliases.length; j++) {
                assertFalse("Incorrect alias", kss[i].containsAlias("Bad"
                        .concat(aliases[j])));
                assertTrue("Incorrect alias", kss[i].containsAlias(aliases[j]));
                assertTrue("Not CertificateEntry", kss[i]
                        .isCertificateEntry(aliases[j]));
                assertFalse("Incorrect KeyEntry", kss[i].isKeyEntry(aliases[j]));
                en = kss[i].getEntry(aliases[j], null);
                assertTrue("Incorrect Entry",
                        en instanceof KeyStore.TrustedCertificateEntry);
                assertEquals("Incorrect certificate",
                        ((KeyStore.TrustedCertificateEntry) en)
                                .getTrustedCertificate(), entry
                        .getTrustedCertificate());
                assertEquals("Incorrect certificate", kss[i]
                        .getCertificate(aliases[j]), trust);
            }
        }
    }


    /**
     * Test for
     * <code>setEntry(String alias, KeyStore.Entry entry, KeyStore.ProtectionParameter params)</code>
     * <code>containsAlias(String alias)</code>
     * <code>getEntry(String alias)</code>
     * <code>isCertificateEntry(String alias)</code>
     * <code>isKeyEntry(String alias)</code>
     * methods
     * Assertions:
     * getEntry(...) throws KeyStoreException if password is incorrect;
     * setEntry(..) throws KeyStoreException if password is destroyed;
     * <p/>
     * setEntry(..) throws KeyStoreException when incorrect Entry is used;
     * <p/>
     * setEntry(..) stores Entry and getEntry(...) returns it when
     * KeyStore.PrivateKeyEntry is used.
     */
    public void testEntry02() throws Exception {
        assertTrue(NotSupportMsg, JKSSupported);
        TestKeyPair tkp = new TestKeyPair("DSA");
        KeyStoreTestSupport.MCertificate certs[] = {
                new KeyStoreTestSupport.MCertificate("DSA", tkp.getPrivate()
                        .getEncoded()),
                new KeyStoreTestSupport.MCertificate("DSA", tkp.getPrivate()
                        .getEncoded()) };
        PrivateKey privKey = tkp.getPrivate();
        KeyStore.PrivateKeyEntry pKey = new KeyStore.PrivateKeyEntry(privKey,
                certs);
        char[] pwd = { 'p', 'a', 's', 's', 'w', 'd' };
        KeyStore.PasswordProtection pPath = new KeyStore.PasswordProtection(pwd);
        KeyStore.PasswordProtection anotherPath = new KeyStore.PasswordProtection(
                new char[0]);
        KeyStoreTestSupport.ProtPar pPar = new KeyStoreTestSupport.ProtPar();
        KeyStore[] kss = createKS();
        assertNotNull("KeyStore objects were not created", kss);
        for (int i = 0; i < kss.length; i++) {
            kss[i].load(null, null);
            for (int j = 0; j < aliases.length; j++) {
                kss[i].setEntry(aliases[j], pKey, pPath);
            }
            KeyStore.Entry en;
            Certificate[] cc;
            for (int j = 0; j < aliases.length; j++) {
                assertTrue("Incorrect alias", kss[i].containsAlias(aliases[j]));
                assertTrue("Not KeyEntry", kss[i].isKeyEntry(aliases[j]));
                assertFalse("Incorrect CertificateEntry", kss[i]
                        .isCertificateEntry(aliases[j]));

                en = kss[i].getEntry(aliases[j], pPath);
                assertTrue("Incorrect Entry",
                        en instanceof KeyStore.PrivateKeyEntry);
                Key key = pKey.getPrivateKey();
                Key key1 = ((KeyStore.PrivateKeyEntry) en).getPrivateKey();
                if (!key.getAlgorithm().equals(key1.getAlgorithm()) ||
                        !key.getFormat().equals(key1.getFormat())) {
                    fail("Incorrect key");
                }
                byte[] enc = key.getEncoded();
                byte[] enc1 = key1.getEncoded();
                assertTrue("Diff. keys encoding", Arrays.equals(enc, enc1));

                cc = ((KeyStore.PrivateKeyEntry) en).getCertificateChain();
                assertEquals("Incorrect CertificateChain", cc.length,
                        certs.length);
                for (int t = 0; t < cc.length; t++) {
                    assertEquals("Incorrect CertificateChain", cc[t], certs[t]);
                }

                key = kss[i].getKey(aliases[j], pwd);
                key1 = privKey;
                if (!key.getAlgorithm().equals(key1.getAlgorithm()) ||
                        !key.getFormat().equals(key1.getFormat())) {
                    fail("Incorrect Entry: key");
                }
                enc = key.getEncoded();
                enc1 = key1.getEncoded();
                assertTrue("Incorrect Entry: Diff. keys encoding", Arrays.equals(enc, enc1));

                cc = kss[i].getCertificateChain(aliases[j]);
                assertEquals("Incorrect CertificateChain", cc.length,
                        certs.length);
                for (int t = 0; t < cc.length; t++) {
                    assertEquals("Incorrect CertificateChain", cc[t], certs[t]);
                }
                try {
                    kss[i].getEntry(aliases[j], anotherPath);
                    fail("KeyStoreException or UnrecoverableEntryException should be thrown "
                            + "because password is incorrect");
                } catch (KeyStoreException e) {
                } catch (UnrecoverableEntryException e) {
                }
            }
        }
        pPath.destroy();
        for (int i = 0; i < kss.length; i++) {
            try {
                kss[i].setEntry("ZZZ", pKey, pPath);
                fail("KeyStoreException should be thrown because password is destroyed");
            } catch (KeyStoreException e) {
            }

            for (int j = 0; j < aliases.length; j++) {
                try {
                    kss[i].getEntry(aliases[j], pPath);
                    fail("KeyStoreException should be thrown because password is destroyed");
                } catch (KeyStoreException e) {
                }

                try {
                    kss[i].getEntry(aliases[j], pPar);
                    fail("UnrecoverableEntryException should be thrown");
                } catch (UnrecoverableEntryException e) {
                }
            }
        }
    }

    /**
     * Test for
     * <code>setEntry(String alias, KeyStore.Entry entry, KeyStore.ProtectionParameter params)</code>
     * <code>containsAlias(String alias)</code>
     * <code>getEntry(String alias)</code>
     * <code>isCertificateEntry(String alias)</code>
     * <code>isKeyEntry(String alias)</code>
     * methods
     * Assertions:
     * setEntry(..) stores used entry and getEntry(..) returns it when
     * KeyStore.SecretKeyEntry is used;
     * <p/>
     * setEntry(..) throws KeyStoreException when incorrect Entry is used.
     * <p/>
     * FIXME: this test should be changed to verify SecretKeyEntry.
     * It is not supported.
     */
    public void testEntry03() throws Exception {
        assertTrue(NotSupportMsg, JKSSupported);
        TestKeyPair tkp = new TestKeyPair("DSA");
        KeyStoreTestSupport.SKey secKey = new KeyStoreTestSupport.SKey("DSA",
                tkp.getPrivate().getEncoded());
        KeyStore.SecretKeyEntry sKey = new KeyStore.SecretKeyEntry(
                secKey);
        char[] pwd = { 'p', 'a', 's', 's', 'w', 'd' };
        KeyStore.PasswordProtection pPath = new KeyStore.PasswordProtection(pwd);
        KeyStoreTestSupport.AnotherEntry aEntry = new KeyStoreTestSupport.AnotherEntry();
        KeyStoreTestSupport.ProtPar pPar = new KeyStoreTestSupport.ProtPar();
        KeyStore[] kss = createKS();
        assertNotNull("KeyStore objects were not created", kss);
        for (int i = 0; i < kss.length; i++) {
            kss[i].load(null, null);
            for (int j = 0; j < aliases.length; j++) {
                try {
                    kss[i].setEntry(aliases[j], sKey, pPath);
                } catch (KeyStoreException e) {
                    //logln("testEntry03: non-PrivateKeys not supported.");
                    return;
                }
            }

            for (int j = 0; j < aliases.length; j++) {
                assertTrue("Incorrect alias", kss[i].containsAlias(aliases[j]));
                assertTrue("Not KeyEntry", kss[i].isKeyEntry(aliases[j]));
                assertFalse("Incorrect CertificateEntry", kss[i].isCertificateEntry(aliases[j]));
                Key key1;
                try {
                    key1 = kss[i].getKey(aliases[j], pwd);
                } catch (UnrecoverableKeyException e) {
                    //logln("testEntry03: non-PrivateKeys not supported.");
                    return;
                }
                if (!secKey.getAlgorithm().equals(key1.getAlgorithm()) ||
                        !secKey.getFormat().equals(key1.getFormat())) {
                    fail("Incorrect key");
                }
                byte[] enc = secKey.getEncoded();
                byte[] enc1 = key1.getEncoded();
                assertTrue("Diff. keys encoding", Arrays.equals(enc, enc1));
                assertNull("Incorrect CertificateChain", kss[i].getCertificateChain(aliases[j]));
            }
        }
        pPath.destroy();
        for (int i = 0; i < kss.length; i++) {
            try {
                kss[i].setEntry("ZZZ", aEntry, pPath);
                fail("KeyStoreException should be thrown because password is destroyed");
            } catch (KeyStoreException e) {
            }
            for (int j = 0; j < aliases.length; j++) {
                try {
                    kss[i].getEntry(aliases[j], pPath);
                    fail("KeyStoreException should be thrown because password is destroyed");
                } catch (KeyStoreException e) {
                }
                try {
                    kss[i].getEntry(aliases[j], pPar);
                    fail("UnrecoverableEntryException should be thrown");
                } catch (UnrecoverableEntryException e) {
                }
            }
        }
    }


    /**
     * Test for
     * <code>setCertificateEntry(String alias, Certificate cert)</code>
     * <code>containsAlias(String alias)</code>
     * <code>getCertificate(String alias)</code>
     * <code>isCertificateEntry(String alias)</code>
     * methods
     * Assertions:
     * setCertificateEntry(..), containsAlias(..), getCertificate(..) and isCertificateEntry(..)
     * throw NullPointerException when alias is null
     * <p/>
     * setCertificateEntry(..) stores used entry and getCertificate(..) returns it
     */
    public void testEntry04() throws Exception {
        assertTrue(NotSupportMsg, JKSSupported);
        KeyStoreTestSupport.MCertificate cert = new KeyStoreTestSupport.MCertificate(
                "type", new byte[0]);
        KeyStore[] kss = createKS();
        assertNotNull("KeyStore objects were not created", kss);

        for (int i = 0; i < kss.length; i++) {
            kss[i].load(null, null);
            try {
                kss[i].setCertificateEntry(null, cert);
                fail("NullPointerException should be thrown when alias is null");
            } catch (NullPointerException e) {
            }
            for (int j = 0; j < aliases.length; j++) {
                kss[i].setCertificateEntry(aliases[j], cert);
            }
        }
        for (int i = 0; i < kss.length; i++) {
            try {
                kss[i].containsAlias(null);
                fail("NullPointerException should be thrown when alias is null");
            } catch (NullPointerException e) {
            }
            try {
                kss[i].isCertificateEntry(null);
                fail("NullPointerException should be thrown when alias is null");
            } catch (NullPointerException e) {
            }
            try {
                kss[i].getCertificate(null);
                fail("NullPointerException should be thrown when alias is null");
            } catch (NullPointerException e) {
            }
            for (int j = 0; j < aliases.length; j++) {
                assertFalse("Incorrect alias", kss[i].containsAlias("Bad".concat(aliases[j])));
                assertTrue("Incorrect alias", kss[i].containsAlias(aliases[j]));
                assertTrue("Not CertificateEntry", kss[i].isCertificateEntry(aliases[j]));
                assertFalse("Incorrect KeyEntry", kss[i].isKeyEntry(aliases[j]));
                assertEquals("Incorrect Certificate", kss[i].getCertificate(aliases[j]),
                        cert);
            }
        }
    }

    /**
     * Test for
     * <code>setKeyEntry(String alias, Key key, char[] password, Certificate[] chain)</code>
     * <code>containsAlias(String alias)</code>
     * <code>getKey(String alias, char[] password)</code>
     * <code>isCertificateEntry(String alias)</code>
     * <code>isKeyEntry(String alias)</code>
     * <code>setCerificateEntry(String alias, Certificate cert)</code>
     * <code>getCertificateChain(String alias)</code>
     * <code>getCertificateAlias(Certificate cert)</code>
     * methods
     * <p/>
     * Assertions:
     * setKeyEntry(..), getKeyEntry(..) and isKeyEntry(..)
     * throw NullPointerException when alias is null
     * <p/>
     * setKeyEntry(...) throws KeyStoreException when key or password
     * is null
     * <p/>
     * setCertificateEntry(..) throws KeyStoreException when KeyEntry was overwritten
     * <p/>
     * setKeyEntry(..) stores used entry, getKey(..) returns it and getCertificateChain(...)
     * returns cert
     */
    public void testEntry05() throws Exception {
        assertTrue(NotSupportMsg, JKSSupported);
        KeyStoreTestSupport.MCertificate certs[] = {
                new KeyStoreTestSupport.MCertificate("type1", new byte[10]),
                new KeyStoreTestSupport.MCertificate("type2", new byte[10]) };
        KeyStoreTestSupport.MCertificate cert = new KeyStoreTestSupport.MCertificate(
                "type", new byte[0]);
        char[] pwd = new char[0];
        TestKeyPair tkp = new TestKeyPair("DSA");
        PrivateKey key = tkp.getPrivate();
        KeyStore[] kss = createKS();
        assertNotNull("KeyStore objects were not created", kss);
        for (int i = 0; i < kss.length; i++) {
            kss[i].load(null, null);

            // Null as alias does not necessarily lead to NullPointerException

            try {
                kss[i].setKeyEntry("ZZZ", null, pwd, certs);
                fail("KeyStoreException should be thrown when key is null");
            } catch (KeyStoreException e) {
            }
            try {
                kss[i].setKeyEntry("ZZZ", key, pwd, null);
                fail("KeyStoreException or IllegalArgumentException should be thrown "
                        + "when chain is null and key is private");
            } catch (IllegalArgumentException e) {
            }
            try {
                kss[i].setKeyEntry("ZZZ", key, pwd,
                        new KeyStoreTestSupport.MCertificate[0]);
                fail("KeyStoreException or IllegalArgumentException should be thrown "
                        + "when chain is empty and key is private");
            } catch (IllegalArgumentException e) {
            }

            for (int j = 0; j < aliases.length; j++) {
                kss[i].setKeyEntry(aliases[j], key, pwd, certs);
            }

            kss[i].setKeyEntry("KeyAlias", key, pwd, certs);
            try {
                kss[i].setCertificateEntry("KeyAlias", cert);
                fail("KeyStoreException should be thrown when we try to overwrite KeyEntry to Certificate");
            } catch (KeyStoreException e) {
            }

            try {
                kss[i].isKeyEntry(null);
                fail("NullPointerException should be thrown when alias is null");
            } catch (NullPointerException e) {
            }
            try {
                kss[i].getKey(null, pwd);
                fail("NullPointerException should be thrown when alias is null");
            } catch (NullPointerException e) {
            }
            try {
                kss[i].getCertificateChain(null);
                fail("NullPointerException should be thrown when alias is null");
            } catch (NullPointerException e) {
            }
            for (int j = 0; j < aliases.length; j++) {
                assertFalse("Incorrect alias", kss[i].containsAlias("Bad".concat(aliases[j])));
                assertTrue("Incorrect alias", kss[i].containsAlias(aliases[j]));
                assertTrue("Not KeyEntry", kss[i].isKeyEntry(aliases[j]));
                assertFalse("Incorrect CertificateEntry", kss[i].isCertificateEntry(aliases[j]));
                Key key1 = kss[i].getKey(aliases[j], pwd);
                if (!key.getAlgorithm().equals(key1.getAlgorithm()) ||
                        !key.getFormat().equals(key1.getFormat())) {
                    fail("Incorrect key");
                }
                byte[] enc = key.getEncoded();
                byte[] enc1 = key1.getEncoded();
                assertTrue("Diff. keys encoding", Arrays.equals(enc, enc1));
                Certificate[] cc = kss[i].getCertificateChain(aliases[j]);
                assertEquals("Incorrect chain", cc.length, certs.length);
                for (int t = 0; t < cc.length; t++) {
                    assertEquals("Incorrect certificate", cc[t], certs[t]);
                }
            }
            assertNull(kss[i].getCertificateAlias(cert));
            String ss = kss[i].getCertificateAlias(certs[0]);
            boolean ans = false;
            for (int j = 1; j < aliases.length; j++) {
                if (ss.equals(aliases[j])) {
                    ans = true;
                    break;
                }
            }
            assertTrue("There is no alias for certificate <type1, new byte[10]>", ans);
        }
    }

    /**
     * Test for
     * <code>deleteEntry(String alias)</code>
     * <code>size()</code>
     * methods
     * Assertions:
     * throws NullPointerException when alias is null;
     * <p/>
     * deletes entry from KeyStore.
     */
    public void testEntry06() throws Exception {
        assertTrue(NotSupportMsg, JKSSupported);
        KeyStore.TrustedCertificateEntry tCert = new KeyStore.TrustedCertificateEntry(
                new KeyStoreTestSupport.MCertificate("type", new byte[0]));

        TestKeyPair tkp = new TestKeyPair("DSA");
        KeyStoreTestSupport.MCertificate certs[] = {
                new KeyStoreTestSupport.MCertificate("DSA", tkp.getPrivate()
                        .getEncoded()),
                new KeyStoreTestSupport.MCertificate("DSA", tkp.getPrivate()
                        .getEncoded()) };
        KeyStore.PrivateKeyEntry pKey = new KeyStore.PrivateKeyEntry(tkp
                .getPrivate(), certs);
        char[] pwd = { 'p', 'a', 's', 's', 'w', 'd' };
        KeyStore.PasswordProtection pp = new KeyStore.PasswordProtection(pwd);

        String[] aliases = { "Alias1", "Alias2", "Alias3", "Alias4", "Alias5" };

        KeyStore[] kss = createKS();
        assertNotNull("KeyStore objects were not created", kss);

        for (int i = 0; i < kss.length; i++) {
            kss[i].load(null, null);
            kss[i].setEntry(aliases[0], tCert, null);
            kss[i].setEntry(aliases[1], pKey, pp);
            kss[i].setEntry(aliases[2], pKey, pp);

            kss[i].setKeyEntry(aliases[3], tkp.getPrivate(), pwd, certs);

            kss[i].setCertificateEntry(aliases[4], certs[0]);

            assertEquals("Incorrect size", kss[i].size(), 5);
            try {
                kss[i].deleteEntry(null);
                fail("NullPointerException should be thrown when alias is null");
            } catch (NullPointerException e) {
            }
            kss[i].deleteEntry(aliases[0]);
            kss[i].deleteEntry(aliases[3]);
            assertEquals("Incorrect size", kss[i].size(), 3);
            for (int j = 1; j < 5; j++) {
                if ((j == 0) || (j == 3)) {
                    assertFalse("Incorrect deleted alias", kss[i]
                            .containsAlias(aliases[j]));
                } else {
                    assertTrue("Incorrect alias", kss[i]
                            .containsAlias(aliases[j]));
                }
            }
        }
    }

    /**
     * Test for
     * <code>entryInstanceOf(String alias, Class class)</code>
     * method
     * Assertions:
     * throws NullPointerException when alias is null
     * returns false if KeyStore does not contain entry with defined alias
     * returns false if defined alias is not correspond Entry
     * returns false
     * setEntry(..) throws KeyStoreException when incorrect Entry is used;
     * <p/>
     * setEntry(..) stores Entry and getEntry(...) returns it when
     * KeyStore.PrivateKeyEntry is used.
     */
    public void testEntry07() throws Exception {
        assertTrue(NotSupportMsg, JKSSupported);
        TestKeyPair tkp = new TestKeyPair("DSA");
        KeyStoreTestSupport.MCertificate certs[] = {
                new KeyStoreTestSupport.MCertificate("DSA", tkp.getPrivate()
                        .getEncoded()),
                new KeyStoreTestSupport.MCertificate("DSA", tkp.getPrivate()
                        .getEncoded()) };
        PrivateKey privKey = tkp.getPrivate();
        KeyStore.PrivateKeyEntry pKey = new KeyStore.PrivateKeyEntry(privKey, certs);
        char[] pwd = { 'p', 'a', 's', 's', 'w', 'd' };
        String aliasKE = "KeyAlias";
        KeyStore.PasswordProtection pp = new KeyStore.PasswordProtection(pwd);
        new KeyStore.PasswordProtection(new char[0]);
        KeyStore[] kss = createKS();
        assertNotNull("KeyStore objects were not created", kss);

        for (int i = 0; i < kss.length; i++) {
            kss[i].load(null, null);
            // set entries
            for (int j = 0; j < aliases.length; j++) {
                kss[i].setEntry(aliases[j], pKey, pp);
            }
            kss[i].setKeyEntry(aliasKE, privKey, pwd, certs);
            try {
                kss[i].entryInstanceOf(null, pKey.getClass());
                fail("NullPointerEXception must be thrown");
            } catch (NullPointerException e) {
            }
            assertFalse("Incorrect class entry 1",
                    kss[i].entryInstanceOf("ZZZ", pKey.getClass()));
            for (int j = 0; j < aliases.length; j++) {
                assertTrue("Incorrect class entry 2",
                        kss[i].entryInstanceOf(aliases[j], pKey.getClass()));

                //make it compilable on 1.5
                Class c = privKey.getClass();
                assertFalse("Incorrect class entry 3",
                        kss[i].entryInstanceOf(aliases[j], c));
            }

            //make it compilable on 1.5
            Class c = privKey.getClass();
            assertFalse("Incorrect class entry 4",
                    kss[i].entryInstanceOf(aliasKE, c));
            assertTrue("Incorrect class entry 5",
                    kss[i].entryInstanceOf(aliasKE, pKey.getClass()));
        }
    }


    /**
     * Test for <code>KeyStore(KeyStoreSpi spi, Provider prov, String type)</code>
     * constructor
     * Assertion: constructs KeyStore object
     */
    public void testKeyStoreConstr() throws Exception {
        assertTrue(NotSupportMsg, JKSSupported);
        KeyStoreSpi spi = new MyKeyStoreSpi();
        KeyStore keySt = new tmpKeyStore(spi, defaultProvider,
                defaultType);
        assertEquals("Incorrect name", keySt.getType(),
                defaultType);
        assertEquals("Incorrect provider", keySt.getProvider(), defaultProvider);
        char[] pwd = new char[0];
        try {
            keySt.store(null, pwd);
            fail("KeyStoreException must be thrown");
        } catch (KeyStoreException e) {
        }
        keySt = new tmpKeyStore(null, null, null);
        assertNull("Algorithm must be null", keySt.getType());
        assertNull("Provider must be null", keySt.getProvider());
        try {
            keySt.load(null, pwd);
            fail("NullPointerException must be thrown");
        } catch (NullPointerException e) {
        }
    }

}

/**
 * Additional class to verify KeyStore constructor
 */
class tmpKeyStore extends KeyStore {
    public tmpKeyStore(KeyStoreSpi spi, Provider prov, String alg) {
        super(spi, prov, alg);
    }
}