/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
 * test_comcertselparams.c
 *
 * Test Common Cert Selector Params
 *
 */

#include "testutil.h"
#include "testutil_nss.h"

static void *plContext = NULL;

static
void test_CreateOIDList(PKIX_List *certPolicyInfos, PKIX_List **pPolicyOIDs)
{
        PKIX_UInt32 i = 0;
        PKIX_UInt32 numInfos = 0;
        PKIX_PL_CertPolicyInfo *certPolicyInfo = NULL;
        PKIX_PL_OID *policyOID = NULL;
        PKIX_List *certPolicies = NULL;

        PKIX_TEST_STD_VARS();

        /* Convert from List of CertPolicyInfos to List of OIDs */
        if (certPolicyInfos) {
                PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength
                        (certPolicyInfos, &numInfos, plContext));
        }

        if (numInfos > 0) {
                PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create
                        (&certPolicies, plContext));
        }
        for (i = 0; i < numInfos; i++) {
            PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetItem
                (certPolicyInfos,
                i,
                (PKIX_PL_Object **)&certPolicyInfo,
                plContext));
            PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_CertPolicyInfo_GetPolicyId
                (certPolicyInfo, &policyOID, plContext));
            PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem
                (certPolicies, (PKIX_PL_Object *)policyOID, plContext));
            PKIX_TEST_DECREF_BC(certPolicyInfo);
            PKIX_TEST_DECREF_BC(policyOID);
        }

        *pPolicyOIDs = certPolicies;

cleanup:

        PKIX_TEST_DECREF_AC(certPolicyInfo);
        PKIX_TEST_DECREF_AC(policyOID);

        PKIX_TEST_RETURN();
}

static
void test_NameConstraints(char *dirName)
{
        PKIX_PL_Cert *goodCert = NULL;
        PKIX_PL_CertNameConstraints *getNameConstraints = NULL;
        PKIX_PL_CertNameConstraints *setNameConstraints = NULL;
        PKIX_ComCertSelParams *goodParams = NULL;
        char *expectedAscii =
                "[\n"
                "\t\tPermitted Name:  (OU=permittedSubtree1,"
                "O=Test Certificates,C=US, OU=permittedSubtree2,"
                "O=Test Certificates,C=US)\n"
                "\t\tExcluded Name:   (EMPTY)\n"
                "\t]\n";

        PKIX_TEST_STD_VARS();

        subTest("Create Cert for NameConstraints test");

        goodCert = createCert
                (dirName, "nameConstraintsDN2CACert.crt", plContext);

        subTest("PKIX_PL_Cert_GetNameConstraints");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Cert_GetNameConstraints
                (goodCert, &setNameConstraints, plContext));

        subTest("PKIX_ComCertSelParams_Create");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_Create
                (&goodParams, plContext));

        subTest("PKIX_ComCertSelParams_SetNameConstraints");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetNameConstraints
                (goodParams, setNameConstraints, plContext));

        subTest("PKIX_ComCertSelParams_GetNameConstraints");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetNameConstraints
                (goodParams, &getNameConstraints, plContext));

        subTest("Compare NameConstraints");
        testEqualsHelper((PKIX_PL_Object *)setNameConstraints,
                (PKIX_PL_Object *)getNameConstraints,
                PKIX_TRUE,
                plContext);

        subTest("Compare NameConstraints with canned string");
        testToStringHelper
                ((PKIX_PL_Object *)getNameConstraints,
                expectedAscii,
                plContext);

cleanup:

        PKIX_TEST_DECREF_AC(goodCert);
        PKIX_TEST_DECREF_AC(getNameConstraints);
        PKIX_TEST_DECREF_AC(setNameConstraints);
        PKIX_TEST_DECREF_AC(goodParams);

        PKIX_TEST_RETURN();
}

static
void test_PathToNames(void)
{
        PKIX_ComCertSelParams *goodParams = NULL;
        PKIX_List *setGenNames = NULL;
        PKIX_List *getGenNames = NULL;
        PKIX_PL_GeneralName *rfc822GenName = NULL;
        PKIX_PL_GeneralName *dnsGenName = NULL;
        PKIX_PL_GeneralName *dirGenName = NULL;
        PKIX_PL_GeneralName *uriGenName = NULL;
        PKIX_PL_GeneralName *oidGenName = NULL;
        char *rfc822Name = "john.doe@labs.com";
        char *dnsName = "comcast.net";
        char *dirName = "cn=john, ou=labs, o=sun, c=us";
        char *uriName = "http://comcast.net";
        char *oidName = "1.2.840.11";
        char *expectedAscii =
                "(john.doe@labs.com, "
                "comcast.net, "
                "CN=john,OU=labs,O=sun,C=us, "
                "http://comcast.net)";
        char *expectedAsciiAll =
                "(john.doe@labs.com, "
                "comcast.net, "
                "CN=john,OU=labs,O=sun,C=us, "
                "http://comcast.net, "
                "1.2.840.11)";

        PKIX_TEST_STD_VARS();

        subTest("PKIX_PL_GeneralName_Create");
        dnsGenName = createGeneralName(PKIX_DNS_NAME, dnsName, plContext);
        uriGenName = createGeneralName(PKIX_URI_NAME, uriName, plContext);
        oidGenName = createGeneralName(PKIX_OID_NAME, oidName, plContext);
        dirGenName = createGeneralName(PKIX_DIRECTORY_NAME, dirName, plContext);
        rfc822GenName = createGeneralName
                (PKIX_RFC822_NAME,
                rfc822Name,
                plContext);

        subTest("PKIX_PL_GeneralName List create and append");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&setGenNames, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem
                (setGenNames, (PKIX_PL_Object *)rfc822GenName, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem
                (setGenNames, (PKIX_PL_Object *)dnsGenName, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem
                (setGenNames, (PKIX_PL_Object *)dirGenName, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem
                (setGenNames, (PKIX_PL_Object *)uriGenName, plContext));

        subTest("PKIX_ComCertSelParams_Create");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_Create
                (&goodParams, plContext));

        subTest("PKIX_ComCertSelParams_SetPathToNames");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetPathToNames
                (goodParams, setGenNames, plContext));

        subTest("PKIX_ComCertSelParams_GetPathToNames");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetPathToNames
                (goodParams, &getGenNames, plContext));

        subTest("Compare GeneralName List");
        testEqualsHelper((PKIX_PL_Object *)setGenNames,
                (PKIX_PL_Object *)getGenNames,
                PKIX_TRUE,
                plContext);

        subTest("Compare GeneralName List with canned string");
        testToStringHelper
                ((PKIX_PL_Object *)getGenNames,
                expectedAscii,
                plContext);

        subTest("PKIX_ComCertSelParams_AddPathToName");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_AddPathToName
                (goodParams, oidGenName, plContext));

        PKIX_TEST_DECREF_BC(getGenNames);

        subTest("PKIX_ComCertSelParams_GetPathToNames");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetPathToNames
                (goodParams, &getGenNames, plContext));

        subTest("Compare GeneralName List with canned string");
        testToStringHelper
                ((PKIX_PL_Object *)getGenNames,
                expectedAsciiAll,
                plContext);

cleanup:

        PKIX_TEST_DECREF_AC(goodParams);
        PKIX_TEST_DECREF_AC(setGenNames);
        PKIX_TEST_DECREF_AC(getGenNames);
        PKIX_TEST_DECREF_AC(rfc822GenName);
        PKIX_TEST_DECREF_AC(dnsGenName);
        PKIX_TEST_DECREF_AC(dirGenName);
        PKIX_TEST_DECREF_AC(uriGenName);
        PKIX_TEST_DECREF_AC(oidGenName);

        PKIX_TEST_RETURN();
}

static
void test_SubjAltNames(void)
{
        PKIX_ComCertSelParams *goodParams = NULL;
        PKIX_List *setGenNames = NULL;
        PKIX_List *getGenNames = NULL;
        PKIX_PL_GeneralName *rfc822GenName = NULL;
        PKIX_PL_GeneralName *dnsGenName = NULL;
        PKIX_PL_GeneralName *dirGenName = NULL;
        PKIX_PL_GeneralName *uriGenName = NULL;
        PKIX_PL_GeneralName *oidGenName = NULL;
        PKIX_Boolean matchAll = PKIX_TRUE;
        char *rfc822Name = "john.doe@labs.com";
        char *dnsName = "comcast.net";
        char *dirName = "cn=john, ou=labs, o=sun, c=us";
        char *uriName = "http://comcast.net";
        char *oidName = "1.2.840.11";
        char *expectedAscii =
                "(john.doe@labs.com, "
                "comcast.net, "
                "CN=john,OU=labs,O=sun,C=us, "
                "http://comcast.net)";
        char *expectedAsciiAll =
                "(john.doe@labs.com, "
                "comcast.net, "
                "CN=john,OU=labs,O=sun,C=us, "
                "http://comcast.net, "
                "1.2.840.11)";

        PKIX_TEST_STD_VARS();

        subTest("PKIX_PL_GeneralName_Create");
        dnsGenName = createGeneralName(PKIX_DNS_NAME, dnsName, plContext);
        uriGenName = createGeneralName(PKIX_URI_NAME, uriName, plContext);
        oidGenName = createGeneralName(PKIX_OID_NAME, oidName, plContext);
        dirGenName = createGeneralName(PKIX_DIRECTORY_NAME, dirName, plContext);
        rfc822GenName = createGeneralName
                (PKIX_RFC822_NAME,
                rfc822Name,
                plContext);

        subTest("PKIX_PL_GeneralName List create and append");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&setGenNames, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem
                (setGenNames, (PKIX_PL_Object *)rfc822GenName, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem
                (setGenNames, (PKIX_PL_Object *)dnsGenName, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem
                (setGenNames, (PKIX_PL_Object *)dirGenName, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem
                (setGenNames, (PKIX_PL_Object *)uriGenName, plContext));

        subTest("PKIX_ComCertSelParams_Create");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_Create
                (&goodParams, plContext));

        subTest("PKIX_ComCertSelParams_SetSubjAltNames");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetSubjAltNames
                (goodParams, setGenNames, plContext));

        subTest("PKIX_ComCertSelParams_GetSubjAltNames");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetSubjAltNames
                (goodParams, &getGenNames, plContext));

        subTest("Compare GeneralName List");
        testEqualsHelper((PKIX_PL_Object *)setGenNames,
                (PKIX_PL_Object *)getGenNames,
                PKIX_TRUE,
                plContext);

        subTest("Compare GeneralName List with canned string");
        testToStringHelper
                ((PKIX_PL_Object *)getGenNames,
                expectedAscii,
                plContext);


        subTest("PKIX_ComCertSelParams_AddSubjAltName");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_AddSubjAltName
                (goodParams, oidGenName, plContext));

        PKIX_TEST_DECREF_BC(getGenNames);

        subTest("PKIX_ComCertSelParams_GetSubjAltNames");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetSubjAltNames
                (goodParams, &getGenNames, plContext));

        subTest("Compare GeneralName List with canned string");
        testToStringHelper
                ((PKIX_PL_Object *)getGenNames,
                expectedAsciiAll,
                plContext);

        subTest("PKIX_ComCertSelParams_GetMatchAllSubjAltNames");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetMatchAllSubjAltNames
                (goodParams, &matchAll, plContext));
        if (matchAll != PKIX_TRUE) {
                testError("unexpected mismatch <expect TRUE>");
        }

        subTest("PKIX_ComCertSelParams_SetMatchAllSubjAltNames");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetMatchAllSubjAltNames
                (goodParams, PKIX_FALSE, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetMatchAllSubjAltNames
                (goodParams, &matchAll, plContext));
        if (matchAll != PKIX_FALSE) {
                testError("unexpected mismatch <expect FALSE>");
        }

cleanup:

        PKIX_TEST_DECREF_AC(goodParams);
        PKIX_TEST_DECREF_AC(setGenNames);
        PKIX_TEST_DECREF_AC(getGenNames);
        PKIX_TEST_DECREF_AC(rfc822GenName);
        PKIX_TEST_DECREF_AC(dnsGenName);
        PKIX_TEST_DECREF_AC(dirGenName);
        PKIX_TEST_DECREF_AC(uriGenName);
        PKIX_TEST_DECREF_AC(oidGenName);

        PKIX_TEST_RETURN();
}

static
void test_KeyUsages(void)
{
        PKIX_ComCertSelParams *goodParams = NULL;
        PKIX_PL_OID *ekuOid = NULL;
        PKIX_List *setExtKeyUsage = NULL;
        PKIX_List *getExtKeyUsage = NULL;
        PKIX_UInt32 getKeyUsage = 0;
        PKIX_UInt32 setKeyUsage = 0x1FF;
        PKIX_Boolean isEqual = PKIX_FALSE;

        PKIX_TEST_STD_VARS();

        subTest("PKIX_ComCertSelParams_Create");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_Create
                (&goodParams, plContext));

        subTest("PKIX_ComCertSelParams_SetKeyUsage");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetKeyUsage
                (goodParams, setKeyUsage, plContext));

        subTest("PKIX_ComCertSelParams_GetKeyUsage");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetKeyUsage
                (goodParams, &getKeyUsage, plContext));

        if (setKeyUsage != getKeyUsage) {
                testError("unexpected KeyUsage mismatch <expect equal>");
        }

        subTest("PKIX_PL_OID List create and append");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&setExtKeyUsage, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_OID_Create
                ("1.3.6.1.5.5.7.3.1",   &ekuOid, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem
                (setExtKeyUsage, (PKIX_PL_Object *)ekuOid, plContext));
        PKIX_TEST_DECREF_BC(ekuOid);

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_OID_Create
                ("1.3.6.1.5.5.7.3.8",   &ekuOid, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem
                (setExtKeyUsage, (PKIX_PL_Object *)ekuOid, plContext));
        PKIX_TEST_DECREF_BC(ekuOid);

        subTest("PKIX_ComCertSelParams_SetExtendedKeyUsage");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetExtendedKeyUsage
                (goodParams, setExtKeyUsage, plContext));

        subTest("PKIX_ComCertSelParams_GetExtendedKeyUsage");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetExtendedKeyUsage
                (goodParams, &getExtKeyUsage, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_Equals
                ((PKIX_PL_Object *)setExtKeyUsage,
                (PKIX_PL_Object *)getExtKeyUsage,
                &isEqual,
                plContext));

        if (isEqual == PKIX_FALSE) {
                testError("unexpected ExtKeyUsage mismatch <expect equal>");
        }

cleanup:

        PKIX_TEST_DECREF_AC(ekuOid);
        PKIX_TEST_DECREF_AC(setExtKeyUsage);
        PKIX_TEST_DECREF_AC(getExtKeyUsage);
        PKIX_TEST_DECREF_AC(goodParams);

        PKIX_TEST_RETURN();
}

static
void test_Version_Issuer_SerialNumber(void)
{
        PKIX_ComCertSelParams *goodParams = NULL;
        PKIX_UInt32 version = 0;
        PKIX_PL_X500Name *setIssuer = NULL;
        PKIX_PL_X500Name *getIssuer = NULL;
        PKIX_PL_String *str = NULL;
        PKIX_PL_BigInt *setSerialNumber = NULL;
        PKIX_PL_BigInt *getSerialNumber = NULL;
        PKIX_Boolean isEqual = PKIX_FALSE;
        char *bigInt = "999999999999999999";

        PKIX_TEST_STD_VARS();

        subTest("PKIX_ComCertSelParams_Create");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_Create
                (&goodParams, plContext));

        /* Version */
        subTest("PKIX_ComCertSelParams_SetVersion");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetVersion
                (goodParams, 2, plContext));

        subTest("PKIX_ComCertSelParams_GetVersion");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetVersion
                (goodParams, &version, plContext));

        if (version != 2) {
                testError("unexpected Version mismatch <expect 2>");
        }

        /* Issuer */
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create
                (PKIX_ESCASCII, "CN=Test,O=Sun,C=US", 0, &str, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_X500Name_Create
                (str, &setIssuer, plContext));

        PKIX_TEST_DECREF_BC(str);

        subTest("PKIX_ComCertSelParams_SetIssuer");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetIssuer
                (goodParams, setIssuer, plContext));

        subTest("PKIX_ComCertSelParams_GetIssuer");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetIssuer
                (goodParams, &getIssuer, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_Equals
                ((PKIX_PL_Object *)setIssuer,
                (PKIX_PL_Object *)getIssuer,
                &isEqual,
                plContext));

        if (isEqual == PKIX_FALSE) {
                testError("unexpected Issuer mismatch <expect equal>");
        }

        /* Serial Number */
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create
                (PKIX_ESCASCII, bigInt, PL_strlen(bigInt), &str, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_BigInt_Create
                (str, &setSerialNumber, plContext));

        subTest("PKIX_ComCertSelParams_SetSerialNumber");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetSerialNumber
                (goodParams, setSerialNumber, plContext));

        subTest("PKIX_ComCertSelParams_GetSerialNumber");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetSerialNumber
                (goodParams, &getSerialNumber, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_Equals
                ((PKIX_PL_Object *)setSerialNumber,
                (PKIX_PL_Object *)getSerialNumber,
                &isEqual,
                plContext));

        if (isEqual == PKIX_FALSE) {
                testError("unexpected Serial Number mismatch <expect equal>");
        }

cleanup:

        PKIX_TEST_DECREF_AC(str);
        PKIX_TEST_DECREF_AC(setIssuer);
        PKIX_TEST_DECREF_AC(getIssuer);
        PKIX_TEST_DECREF_AC(setSerialNumber);
        PKIX_TEST_DECREF_AC(getSerialNumber);
        PKIX_TEST_DECREF_AC(goodParams);

        PKIX_TEST_RETURN();
}

static
void test_SubjKeyId_AuthKeyId(void)
{
        PKIX_ComCertSelParams *goodParams = NULL;
        PKIX_PL_ByteArray *setKeyId = NULL;
        PKIX_PL_ByteArray *getKeyId = NULL;
        PKIX_Boolean isEqual = PKIX_FALSE;

        PKIX_TEST_STD_VARS();

        /* Subject Key Identifier */
        subTest("PKIX_PL_ByteArray_Create");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_ByteArray_Create
                ((void*)"66099", 1, &setKeyId, plContext));

        subTest("PKIX_ComCertSelParams_Create");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_Create
                (&goodParams, plContext));

        subTest("PKIX_ComCertSelParams_SetSubjectKeyIdentifier");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetSubjKeyIdentifier
                (goodParams, setKeyId, plContext));

        subTest("PKIX_ComCertSelParams_GetSubjectKeyIdentifier");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetSubjKeyIdentifier
                (goodParams, &getKeyId, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_Equals
                ((PKIX_PL_Object *)setKeyId,
                (PKIX_PL_Object *)getKeyId,
                &isEqual,
                plContext));

        if (isEqual == PKIX_FALSE) {
                testError("unexpected Subject Key Id mismatch <expect equal>");
        }

        PKIX_TEST_DECREF_BC(setKeyId);
        PKIX_TEST_DECREF_BC(getKeyId);

        /* Authority Key Identifier */
        subTest("PKIX_PL_ByteArray_Create");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_ByteArray_Create
                ((void*)"11022", 1, &setKeyId, plContext));

        subTest("PKIX_ComCertSelParams_SetAuthorityKeyIdentifier");
        PKIX_TEST_EXPECT_NO_ERROR
                (PKIX_ComCertSelParams_SetAuthorityKeyIdentifier
                (goodParams, setKeyId, plContext));

        subTest("PKIX_ComCertSelParams_GetAuthorityKeyIdentifier");
        PKIX_TEST_EXPECT_NO_ERROR
                (PKIX_ComCertSelParams_GetAuthorityKeyIdentifier
                (goodParams, &getKeyId, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_Equals
                ((PKIX_PL_Object *)setKeyId,
                (PKIX_PL_Object *)getKeyId,
                &isEqual,
                plContext));

        if (isEqual == PKIX_FALSE) {
                testError("unexpected Auth Key Id mismatch <expect equal>");
        }

cleanup:

        PKIX_TEST_DECREF_AC(setKeyId);
        PKIX_TEST_DECREF_AC(getKeyId);
        PKIX_TEST_DECREF_AC(goodParams);

        PKIX_TEST_RETURN();
}

static
void test_SubjAlgId_SubjPublicKey(char *dirName)
{
        PKIX_ComCertSelParams *goodParams = NULL;
        PKIX_PL_OID *setAlgId = NULL;
        PKIX_PL_OID *getAlgId = NULL;
        PKIX_PL_Cert *goodCert = NULL;
        PKIX_PL_PublicKey *setPublicKey = NULL;
        PKIX_PL_PublicKey *getPublicKey = NULL;
        PKIX_Boolean isEqual = PKIX_FALSE;

        PKIX_TEST_STD_VARS();

        /* Subject Algorithm Identifier */
        subTest("PKIX_PL_OID_Create");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_OID_Create
                ("1.1.2.3", &setAlgId, plContext));

        subTest("PKIX_ComCertSelParams_Create");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_Create
                (&goodParams, plContext));

        subTest("PKIX_ComCertSelParams_SetSubjPKAlgId");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetSubjPKAlgId
                (goodParams, setAlgId, plContext));

        subTest("PKIX_ComCertSelParams_GetSubjPKAlgId");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetSubjPKAlgId
                (goodParams, &getAlgId, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_Equals
                ((PKIX_PL_Object *)setAlgId,
                (PKIX_PL_Object *)getAlgId,
                &isEqual,
                plContext));

        if (isEqual == PKIX_FALSE) {
                testError("unexpected Subject Public Key Alg mismatch "
                            "<expect equal>");
        }

        /* Subject Public Key */
        subTest("Getting Cert for Subject Public Key");

        goodCert = createCert
                (dirName, "nameConstraintsDN2CACert.crt", plContext);

        subTest("PKIX_PL_Cert_GetSubjectPublicKey");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Cert_GetSubjectPublicKey
                (goodCert, &setPublicKey, plContext));

        subTest("PKIX_ComCertSelParams_SetSubjPubKey");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetSubjPubKey
                (goodParams, setPublicKey, plContext));

        subTest("PKIX_ComCertSelParams_GetSubjPubKey");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetSubjPubKey
                (goodParams, &getPublicKey, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_Equals
                ((PKIX_PL_Object *)setPublicKey,
                (PKIX_PL_Object *)getPublicKey,
                &isEqual,
                plContext));

        if (isEqual == PKIX_FALSE) {
                testError("unexpected Subject Public Key mismatch "
                            "<expect equal>");
        }

cleanup:

        PKIX_TEST_DECREF_AC(setAlgId);
        PKIX_TEST_DECREF_AC(getAlgId);
        PKIX_TEST_DECREF_AC(goodParams);
        PKIX_TEST_DECREF_AC(goodCert);
        PKIX_TEST_DECREF_AC(setPublicKey);
        PKIX_TEST_DECREF_AC(getPublicKey);

        PKIX_TEST_RETURN();
}

static
void printUsage(void) {
        (void) printf("\nUSAGE:\ttest_comcertselparams <NIST_FILES_DIR> \n\n");
}

int test_comcertselparams(int argc, char *argv[]) {

        PKIX_UInt32 actualMinorVersion;
        PKIX_UInt32 j = 0;

        PKIX_PL_Cert *testCert = NULL;
        PKIX_PL_Cert *goodCert = NULL;
        PKIX_PL_Cert *equalCert = NULL;
        PKIX_PL_Cert *diffCert = NULL;
        PKIX_PL_CertBasicConstraints *goodBasicConstraints = NULL;
        PKIX_PL_CertBasicConstraints *diffBasicConstraints = NULL;
        PKIX_List *testPolicyInfos = NULL; /* CertPolicyInfos */
        PKIX_List *cert2PolicyInfos = NULL; /* CertPolicyInfos */

        PKIX_ComCertSelParams *goodParams = NULL;
        PKIX_ComCertSelParams *equalParams = NULL;
        PKIX_PL_X500Name *goodSubject = NULL;
        PKIX_PL_X500Name *equalSubject = NULL;
        PKIX_PL_X500Name *diffSubject = NULL;
        PKIX_PL_X500Name *testSubject = NULL;
        PKIX_Int32 goodMinPathLength = 0;
        PKIX_Int32 equalMinPathLength = 0;
        PKIX_Int32 diffMinPathLength = 0;
        PKIX_Int32 testMinPathLength = 0;
        PKIX_List *goodPolicies = NULL; /* OIDs */
        PKIX_List *equalPolicies = NULL; /* OIDs */
        PKIX_List *testPolicies = NULL; /* OIDs */
        PKIX_List *cert2Policies = NULL; /* OIDs */

        PKIX_PL_Date *testDate = NULL;
        PKIX_PL_Date *goodDate = NULL;
        PKIX_PL_Date *equalDate = NULL;
        PKIX_PL_String *stringRep = NULL;
        char *asciiRep = NULL;
        char *dirName = NULL;

        PKIX_TEST_STD_VARS();

        if (argc < 2) {
                printUsage();
                return (0);
        }

        startTests("ComCertSelParams");

        PKIX_TEST_EXPECT_NO_ERROR(
            PKIX_PL_NssContext_Create(0, PKIX_FALSE, NULL, &plContext));

        dirName = argv[j+1];

        asciiRep = "050501000000Z";

        PKIX_TEST_EXPECT_NO_ERROR
                (PKIX_PL_String_Create
                (PKIX_ESCASCII, asciiRep, 0, &stringRep, plContext));
        PKIX_TEST_EXPECT_NO_ERROR
                (PKIX_PL_Date_Create_UTCTime(stringRep, &testDate, plContext));

        testCert = createCert
                (dirName, "PoliciesP1234CACert.crt",  plContext);

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Cert_GetSubject
                (testCert, &testSubject, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Cert_GetBasicConstraints
                (testCert, &goodBasicConstraints, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_BasicConstraints_GetPathLenConstraint
                (goodBasicConstraints, &testMinPathLength, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Cert_GetPolicyInformation
                (testCert, &testPolicyInfos, plContext));

        /* Convert from List of CertPolicyInfos to List of OIDs */
        test_CreateOIDList(testPolicyInfos, &testPolicies);

        subTest("Create goodParams and set its fields");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_Create
                (&goodParams, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetSubject
                (goodParams, testSubject, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetBasicConstraints
                (goodParams, testMinPathLength, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetCertificateValid
                (goodParams, testDate, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetPolicy
                (goodParams, testPolicies, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetCertificate
                (goodParams, testCert, plContext));

        subTest("Duplicate goodParams and verify copy");
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_Duplicate
                ((PKIX_PL_Object *)goodParams,
                (PKIX_PL_Object **)&equalParams,
                plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetSubject
                (goodParams, &goodSubject, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetBasicConstraints
                (goodParams, &goodMinPathLength, plContext));
        PKIX_TEST_EXPECT_NO_ERROR
                (PKIX_ComCertSelParams_GetCertificate
                (goodParams, &goodCert, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetCertificateValid
                (goodParams, &goodDate, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetPolicy
                (goodParams, &goodPolicies, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetSubject
                (equalParams, &equalSubject, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetBasicConstraints
                (equalParams, &equalMinPathLength, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetPolicy
                (equalParams, &equalPolicies, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetCertificate
                (equalParams, &equalCert, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetCertificateValid
                (equalParams, &equalDate, plContext));

        testEqualsHelper
                ((PKIX_PL_Object *)goodSubject,
                (PKIX_PL_Object *)equalSubject,
                PKIX_TRUE,
                plContext);

        if (goodMinPathLength != equalMinPathLength) {
                testError("unexpected mismatch");
                (void) printf("goodMinPathLength:\t%d\n", goodMinPathLength);
                (void) printf("equalMinPathLength:\t%d\n", equalMinPathLength);
        }

        testEqualsHelper((PKIX_PL_Object *)goodPolicies,
                (PKIX_PL_Object *)equalPolicies,
                PKIX_TRUE,
                plContext);

        testEqualsHelper((PKIX_PL_Object *)goodCert,
                (PKIX_PL_Object *)equalCert,
                PKIX_TRUE,
                plContext);

        testEqualsHelper((PKIX_PL_Object *)goodDate,
                (PKIX_PL_Object *)equalDate,
                PKIX_TRUE,
                plContext);

        PKIX_TEST_DECREF_BC(equalSubject);
        PKIX_TEST_DECREF_BC(equalPolicies);
        PKIX_TEST_DECREF_BC(equalCert);
        PKIX_TEST_DECREF_AC(equalDate);

        subTest("Set different values and verify differences");

        diffCert = createCert
                (dirName, "pathLenConstraint6CACert.crt", plContext);

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Cert_GetSubject
                (diffCert, &diffSubject, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Cert_GetBasicConstraints
                (diffCert, &diffBasicConstraints, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_BasicConstraints_GetPathLenConstraint
                (diffBasicConstraints, &diffMinPathLength, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Cert_GetPolicyInformation
                (diffCert, &cert2PolicyInfos, plContext));
        test_CreateOIDList(cert2PolicyInfos, &cert2Policies);

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetSubject(
                equalParams, diffSubject, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetBasicConstraints
                (equalParams, diffMinPathLength, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_SetPolicy
                (equalParams, cert2Policies, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetSubject
                (equalParams, &equalSubject, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetBasicConstraints
                (equalParams, &equalMinPathLength, plContext));
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ComCertSelParams_GetPolicy
                (equalParams, &equalPolicies, plContext));

        testEqualsHelper
                ((PKIX_PL_Object *)goodSubject,
                (PKIX_PL_Object *)equalSubject,
                PKIX_FALSE,
                plContext);

        if (goodMinPathLength == equalMinPathLength) {
                testError("unexpected match");
                (void) printf("goodMinPathLength:\t%d\n", goodMinPathLength);
                (void) printf("equalMinPathLength:\t%d\n", equalMinPathLength);
        }

        testEqualsHelper
                ((PKIX_PL_Object *)goodPolicies,
                (PKIX_PL_Object *)equalPolicies,
                PKIX_FALSE,
                plContext);

        test_NameConstraints(dirName);
        test_PathToNames();
        test_SubjAltNames();
        test_KeyUsages();
        test_Version_Issuer_SerialNumber();
        test_SubjKeyId_AuthKeyId();
        test_SubjAlgId_SubjPublicKey(dirName);

cleanup:

        PKIX_TEST_DECREF_AC(testSubject);
        PKIX_TEST_DECREF_AC(goodSubject);
        PKIX_TEST_DECREF_AC(equalSubject);
        PKIX_TEST_DECREF_AC(diffSubject);
        PKIX_TEST_DECREF_AC(testSubject);
        PKIX_TEST_DECREF_AC(goodPolicies);
        PKIX_TEST_DECREF_AC(equalPolicies);
        PKIX_TEST_DECREF_AC(testPolicies);
        PKIX_TEST_DECREF_AC(cert2Policies);
        PKIX_TEST_DECREF_AC(goodParams);
        PKIX_TEST_DECREF_AC(equalParams);
        PKIX_TEST_DECREF_AC(goodCert);
        PKIX_TEST_DECREF_AC(diffCert);
        PKIX_TEST_DECREF_AC(testCert);
        PKIX_TEST_DECREF_AC(goodBasicConstraints);
        PKIX_TEST_DECREF_AC(diffBasicConstraints);
        PKIX_TEST_DECREF_AC(testPolicyInfos);
        PKIX_TEST_DECREF_AC(cert2PolicyInfos);
        PKIX_TEST_DECREF_AC(stringRep);
        PKIX_TEST_DECREF_AC(testDate);
        PKIX_TEST_DECREF_AC(goodDate);


        PKIX_Shutdown(plContext);

        PKIX_TEST_RETURN();

        endTests("ComCertSelParams");

        return (0);
}