/*
 * 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
* @version $Revision$
*/

package tests.security.cert;

import junit.framework.TestCase;

import org.apache.harmony.security.tests.support.SpiEngUtils;
import org.apache.harmony.security.tests.support.cert.MyCertStoreParameters;
import org.apache.harmony.security.tests.support.cert.MyCertStoreSpi;

import java.security.InvalidAlgorithmParameterException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.Provider;
import java.security.Security;
import java.security.cert.CertStore;
import java.security.cert.CertStoreException;
import java.security.cert.CertStoreParameters;
import java.security.cert.CertStoreSpi;
import java.security.cert.CollectionCertStoreParameters;
import java.security.cert.LDAPCertStoreParameters;
import java.util.Collection;

/**
 * Tests for <code>CertStore</code> class constructors and
 * methods.
 *
 */
public class CertStore1Test extends TestCase {

    public static final String srvCertStore = "CertStore";

    private static final String defaultType = "LDAP";
    public static final String [] validValues =  {
            "LDAP", "ldap", "Ldap", "lDAP", "lDaP" };
    public static  String [] validValuesC = null;

    private static String [] invalidValues = SpiEngUtils.invalidValues;

    private static boolean LDAPSupport = false;
    private static final String CollectionType = "Collection";
    private static boolean CollectionSupport = false;

    private static Provider defaultProvider;
    private static String defaultProviderName;
    private static Provider defaultProviderCol;
    private static String defaultProviderColName;

    private static String NotSupportMsg = "";

    static {
        defaultProvider = SpiEngUtils.isSupport(defaultType,
                srvCertStore);
        LDAPSupport = (defaultProvider != null);
        defaultProviderName = (LDAPSupport ? defaultProvider.getName() : null);
        NotSupportMsg = "LDAP and Collection algorithm are not supported";

        defaultProviderCol = SpiEngUtils.isSupport(CollectionType,
                srvCertStore);
        CollectionSupport = (defaultProviderCol != null);
        defaultProviderColName = (CollectionSupport ? defaultProviderCol.getName() : null);
        if (CollectionSupport) {
            validValuesC = new String[3];
            validValuesC[0] = CollectionType;
            validValuesC[1] = CollectionType.toUpperCase();
            validValuesC[2] = CollectionType.toLowerCase();
        }
    }

    private Provider dProv = null;
    private String dName = null;
    private String dType = null;
    private CertStoreParameters dParams = null;
    private String[] dValid;

    private boolean initParams() {
        if (!LDAPSupport && !CollectionSupport) {
            fail(NotSupportMsg);
            return false;
        }
        dParams = (CollectionSupport ? (CertStoreParameters)new CollectionCertStoreParameters() :
            (CertStoreParameters)new LDAPCertStoreParameters());
        dType = (CollectionSupport ? CollectionType : defaultType );
        dProv = (CollectionSupport ? defaultProviderCol : defaultProvider );
        dName = (CollectionSupport ? defaultProviderColName : defaultProviderName );
        dValid = (CollectionSupport ? validValuesC : validValues );
        return true;
    }
    private CertStore [] createCS() {
        if (!LDAPSupport && !CollectionSupport) {
            fail(NotSupportMsg);
            return null;
        }
        try {
            CertStore [] ss = new CertStore[3];
            ss[0] = CertStore.getInstance(dType, dParams);
            ss[1] = CertStore.getInstance(dType, dParams, dProv);
            ss[2] = CertStore.getInstance(dType, dParams, dName);
            return ss;
        } catch (Exception e) {
            return null;
        }
    }


    /**
     * Test for <code>getDefaultType()</code> method
     * Assertion: returns security property "certstore.type" or "LDAP"
     */
    public void testCertStore01() {
        if (!LDAPSupport) {
            return;
        }
        String dt = CertStore.getDefaultType();
        String sn = Security.getProperty("certstore.type");
        String def = "Proba.cert.store.type";
        if (sn == null) {
            sn = defaultType;
        }
        assertNotNull("Default type have not be null", dt);
        assertEquals("Incorrect default type", dt, sn);

        Security.setProperty("certstore.type", def);
        dt = CertStore.getDefaultType();
        assertEquals("Incorrect default type", dt, def);
        Security.setProperty("certstore.type", sn);
        assertEquals("Incorrect default type", Security.getProperty("certstore.type"), sn );
    }
    /**
     * Test for
     * <code>CertStore</code> constructor
     * Assertion: returns CertStore object
     */
    public void testCertStore02() throws InvalidAlgorithmParameterException, CertStoreException {
        if (!initParams()) {
            return;
        }
        MyCertStoreParameters pp = new MyCertStoreParameters();
        CertStoreSpi spi = new MyCertStoreSpi(pp);
        CertStore certS = new myCertStore(spi, dProv, dType, pp);
        assertEquals("Incorrect algorithm", certS.getType(), dType);
        assertEquals("Incorrect provider", certS.getProvider(), dProv);
        assertTrue("Incorrect parameters", certS.getCertStoreParameters()
                instanceof MyCertStoreParameters);
        try {
            certS.getCertificates(null);
            fail("CertStoreException must be thrown");
        } catch (CertStoreException e) {
        }
        certS = new myCertStore(null, null, null, null);
        assertNull("Incorrect algorithm", certS.getType());
        assertNull("Incorrect provider", certS.getProvider());
        assertNull("Incorrect parameters", certS.getCertStoreParameters());
        try {
            certS.getCertificates(null);
            fail("NullPointerException must be thrown");
        } catch (NullPointerException e) {
        }
    }

    /**
     * Test for <code>getInstance(String type, CertStoreParameters params)</code> method
     * Assertion:
     * throws NullPointerException when type is null
     * throws NoSuchAlgorithmException when type is incorrect;
     */
    public void testCertStore03() throws InvalidAlgorithmParameterException {
        if (!initParams()) {
            return;
        }
        try {
            CertStore.getInstance(null, dParams);
            fail("NullPointerException or NoSuchAlgorithmException must be thrown when type is null");
        } catch (NullPointerException e) {
        } catch (NoSuchAlgorithmException e) {
        }
        for (int i = 0; i < invalidValues.length; i++ ) {
            try {
                CertStore.getInstance(invalidValues[i], dParams);
                fail("NoSuchAlgorithmException must be thrown");
            } catch (NoSuchAlgorithmException e) {
            }
        }
    }

    /**
     * Test for <code>getInstance(String type, CertStoreParameters params)</code> method
     * Assertion: return CertStore object
     */
    public void testCertStore05()
            throws InvalidAlgorithmParameterException, NoSuchAlgorithmException {
        if (!initParams()) {
            return;
        }
        CertStore certS;
        for (int i = 0; i < dValid.length; i++) {
            certS = CertStore.getInstance(dValid[i], dParams);
            assertEquals("Incorrect type", certS.getType(), dValid[i]);
            certS.getCertStoreParameters();
        }
    }
    /**
     * Test for method
     * <code>getInstance(String type, CertStoreParameters params, String provider)</code>
     * Assertion: throws IllegalArgumentException when provider is null or empty
     *
     */
    public void testCertStore06()
            throws InvalidAlgorithmParameterException, NoSuchAlgorithmException,
                NoSuchProviderException {
        if (!initParams()) {
            return;
        }
        String provider = null;
        for (int i = 0; i < dValid.length; i++) {
            try {
                CertStore.getInstance(dValid[i], dParams, provider);
                fail("IllegalArgumentException must be thrown");
            } catch (IllegalArgumentException e) {
            }
            try {
                CertStore.getInstance(dValid[i], dParams, "");
                fail("IllegalArgumentException must be thrown");
            } catch (IllegalArgumentException e) {
            }
        }
    }
    /**
     * Test for method
     * <code>getInstance(String type, CertStoreParameters params, String provider)</code>
     * Assertion: throws NoSuchProviderException when provider has invalid value
     */
    public void testCertStore07()
            throws InvalidAlgorithmParameterException, NoSuchAlgorithmException {
        if (!initParams()) {
            return;
        }
        for (int i = 0; i < dValid.length; i++) {
            for (int j = 1; j < invalidValues.length; j++ ) {
                try {
                    CertStore.getInstance(dValid[i], dParams, invalidValues[j]);
                    fail("NoSuchProviderException must be thrown");
                } catch (NoSuchProviderException e) {
                }
            }
        }
    }
    /**
     * Test for method
     * <code>getInstance(String type, CertStoreParameters params, String provider)</code>
     * Assertion:
     * throws NullPointerException when type is null
     * throws NoSuchAlgorithmException when type is incorrect;
     */
    public void testCertStore08() throws InvalidAlgorithmParameterException,
            NoSuchProviderException {
        if (!initParams()) {
            return;
        }
        for (int i = 0; i < invalidValues.length; i++) {
            try {
                CertStore.getInstance(invalidValues[i], dParams, dName);
                fail("NoSuchAlgorithmException must be thrown");
            } catch (NoSuchAlgorithmException e){
            }
        }
        try {
            CertStore.getInstance(null, dParams, dName);
            fail("NullPointerException or NoSuchAlgorithmException must be thrown when type is null");
        } catch (NullPointerException e) {
        } catch (NoSuchAlgorithmException e) {
        }
    }

    /**
     * Test for method
     * <code>getInstance(String type, CertStoreParameters params, String provider)</code>
     * Assertion: return CertStore object
     */
    public void testCertStore10()
            throws InvalidAlgorithmParameterException, NoSuchAlgorithmException, NoSuchProviderException {
        if (!initParams()) {
            return;
        }
        CertStore certS;
        for (int i = 0; i < dValid.length; i++) {
            certS = CertStore.getInstance(dValid[i], dParams, dName);
            assertEquals("Incorrect type", certS.getType(), dValid[i]);
            certS.getCertStoreParameters();
        }
    }

    /**
     * Test for method
     * <code>getInstance(String type, CertStoreParameters params, Provider provider)</code>
     * Assertion: throws IllegalArgumentException when provider is null
     */
    public void testCertStore11() throws InvalidAlgorithmParameterException,
            NoSuchAlgorithmException {
        if (!initParams()) {
            return;
        }
        Provider provider = null;
        for (int i = 0; i < dValid.length; i++) {
            try {
                CertStore.getInstance(dValid[i], dParams, provider);
                fail("IllegalArgumentException must be thrown");
            } catch (IllegalArgumentException e) {
            }
        }
    }
    /**
     * Test for <code>getInstance(String type, CertStoreParameters params, Provider provider)</code> method
     * Assertion:
     * throws NullPointerException when type is null
     * throws NoSuchAlgorithmException when type is incorrect;
     */
    public void testCertStore12() throws InvalidAlgorithmParameterException {
        if (!initParams()) {
            return;
        }
        try {
            CertStore.getInstance(null, dParams, dProv);
            fail("NullPointerException or NoSuchAlgorithmException must be thrown when type is null");
        } catch (NullPointerException e) {
        } catch (NoSuchAlgorithmException e) {
        }
        for (int i = 0; i < invalidValues.length; i++ ) {
            try {
                CertStore.getInstance(invalidValues[i], dParams, dProv);
                fail("NoSuchAlgorithmException must be thrown");
            } catch (NoSuchAlgorithmException e) {
            }
        }
    }

    /**
     * Test for method
     * <code>getInstance(String type, CertStoreParameters params, Provider provider)</code>
     * Assertion: return CertStore object
     */
    public void testCertStore14()
            throws InvalidAlgorithmParameterException, NoSuchAlgorithmException {
        if (!initParams()) {
            return;
        }
        CertStore certS;
        for (int i = 0; i < dValid.length; i++) {
            certS = CertStore.getInstance(dValid[i], dParams, dProv);
            assertEquals("Incorrect type", certS.getType(), dValid[i]);
            certS.getCertStoreParameters();
        }
    }
    /**
     * Test for methods
     * <code>getCertificates(CertSelector selector)</code>
     * <code>getCRLs(CRLSelector selector)</code>
     * Assertion: returns empty Collection when selector is null
     */
    public void testCertStore15() throws CertStoreException {
        if (!initParams()) {
            return;
        }
        CertStore [] certS = createCS();
        assertNotNull("CertStore object were not created", certS);
        Collection<?> coll;
        for (int i = 0; i < certS.length; i++) {
            coll = certS[i].getCertificates(null);
            assertTrue("Result collection not empty",coll.isEmpty());
            coll = certS[i].getCRLs(null);
            assertTrue("Result collection not empty",coll.isEmpty());
        }
    }

    /**
     * Test for <code>getType()</code> method
     */
    public void testCertStore16() throws NoSuchAlgorithmException,
            InvalidAlgorithmParameterException {
        if (!initParams()) {
            return;
        }

        CertStore certS;
        for (int i = 0; i < dValid.length; i++) {
            certS = CertStore.getInstance(dValid[i], dParams);
            assertEquals("Incorrect type", certS.getType(), dValid[i]);

            try {
                certS = CertStore.getInstance(dValid[i], dParams,
                        defaultProviderCol);
                assertEquals("Incorrect type", certS.getType(), dValid[i]);
            } catch (IllegalArgumentException e) {
                fail("Unexpected IllegalArgumentException " + e.getMessage());
            }

            try {
                certS = CertStore.getInstance(dValid[i], dParams,
                        defaultProviderColName);
                assertEquals("Incorrect type", certS.getType(), dValid[i]);
            } catch (NoSuchProviderException e) {
                fail("Unexpected IllegalArgumentException " + e.getMessage());
            }
        }
    }

    /**
     * Test for <code>getProvider()</code> method
     */
    public void testCertStore17() throws NoSuchAlgorithmException,
            InvalidAlgorithmParameterException {
        if (!initParams()) {
            return;
        }

        CertStore certS;
        for (int i = 0; i < dValid.length; i++) {
            try {
                certS = CertStore.getInstance(dValid[i], dParams,
                        defaultProviderCol);
                assertEquals("Incorrect provider", certS.getProvider(),
                        defaultProviderCol);
            } catch (IllegalArgumentException e) {
                fail("Unexpected IllegalArgumentException " + e.getMessage());
            }

            try {
                certS = CertStore.getInstance(dValid[i], dParams,
                        defaultProviderColName);
                assertEquals("Incorrect provider", certS.getProvider(),
                        defaultProviderCol);
            } catch (NoSuchProviderException e) {
                fail("Unexpected IllegalArgumentException " + e.getMessage());
            }
}
    }

    /**
     * Test for <code>getCertStoreParameters()</code> method
     */
    public void testCertStore18() throws NoSuchAlgorithmException,
            InvalidAlgorithmParameterException {
        if (!initParams()) {
            return;
        }

        CertStore certS;
        for (int i = 0; i < dValid.length; i++) {
            certS = CertStore.getInstance(dValid[i], dParams);
            assertEquals("Incorrect parameters",
                    ((CollectionCertStoreParameters) certS
                            .getCertStoreParameters()).getCollection(),
                    ((CollectionCertStoreParameters) dParams).getCollection());

            try {
                certS = CertStore.getInstance(dValid[i], dParams,
                        defaultProviderCol);
                assertEquals("Incorrect parameters",
                        ((CollectionCertStoreParameters) certS
                                .getCertStoreParameters()).getCollection(),
                        ((CollectionCertStoreParameters) dParams)
                                .getCollection());
            } catch (IllegalArgumentException e) {
                fail("Unexpected IllegalArgumentException " + e.getMessage());
            }

            try {
                certS = CertStore.getInstance(dValid[i], dParams,
                        defaultProviderColName);
                assertEquals("Incorrect parameters",
                        ((CollectionCertStoreParameters) certS
                                .getCertStoreParameters()).getCollection(),
                        ((CollectionCertStoreParameters) dParams)
                                .getCollection());
            } catch (NoSuchProviderException e) {
                fail("Unexpected IllegalArgumentException " + e.getMessage());
            }
        }
    }
}

/**
 * Additional class to verify CertStore constructor
 */
class myCertStore extends CertStore {
    public myCertStore(CertStoreSpi spi, Provider prov, String type, CertStoreParameters params) {
        super(spi, prov, type, params);
    }
}