| /* |
| * 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 Vladimir N. Molotkov |
| */ |
| |
| package org.apache.harmony.security.tests.java.security.cert; |
| |
| import java.io.IOException; |
| import java.security.InvalidAlgorithmParameterException; |
| import java.security.KeyStore; |
| import java.security.KeyStoreException; |
| import java.security.NoSuchAlgorithmException; |
| import java.security.cert.CertPathParameters; |
| import java.security.cert.CertPathValidatorException; |
| import java.security.cert.CertStore; |
| import java.security.cert.CollectionCertStoreParameters; |
| import java.security.cert.PKIXCertPathChecker; |
| import java.security.cert.PKIXParameters; |
| import java.security.cert.X509CertSelector; |
| import java.util.ArrayList; |
| import java.util.Date; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.apache.harmony.security.tests.support.cert.TestUtils; |
| |
| import junit.framework.TestCase; |
| |
| /** |
| * Tests for <code>PKIXParameters</code> fields and methods |
| */ |
| public class PKIXParametersTest extends TestCase { |
| /** |
| * Some valid issuer name |
| */ |
| private final static String testIssuer = |
| "CN=VM,OU=DRL Security,O=Intel,L=Novosibirsk,ST=NSO,C=RU"; |
| |
| /** |
| * Constructor for PKIXParametersTest. |
| * |
| * @param name |
| */ |
| public PKIXParametersTest(String name) { |
| super(name); |
| } |
| |
| // |
| // Tests |
| // |
| |
| /** |
| * Test #1 for <code>PKIXParameters(Set)</code> constructor<br> |
| * Assertion: Creates an instance of <code>PKIXParameters</code> with the |
| * specified <code>Set</code> of most-trusted CAs. Each element of the set |
| * is a <code>TrustAnchor</code> |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testPKIXParametersSet01() |
| throws InvalidAlgorithmParameterException { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| // use valid parameter |
| CertPathParameters cpp = new PKIXParameters(taSet); |
| assertTrue(cpp instanceof PKIXParameters); |
| } |
| |
| /** |
| * Test #2 for <code>PKIXParameters(Set)</code> constructor<br> |
| * Assertion: ... the <code>Set</code> is copied to protect against |
| * subsequent modifications |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testPKIXParametersSet02() |
| throws InvalidAlgorithmParameterException { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| HashSet originalSet = (HashSet) taSet; |
| HashSet originalSetCopy = (HashSet) originalSet.clone(); |
| // create test object using originalSet |
| PKIXParameters pp = new PKIXParameters(originalSetCopy); |
| // modify originalSet |
| originalSetCopy.clear(); |
| // check that test object's internal state |
| // has not been affected by the above modification |
| Set returnedSet = pp.getTrustAnchors(); |
| assertEquals(originalSet, returnedSet); |
| } |
| |
| /** |
| * Test #3 for <code>PKIXParameters(Set)</code> constructor<br> |
| * Assertion: <code>NullPointerException</code> - |
| * if the specified <code>Set</code> is null |
| */ |
| public final void testPKIXParametersSet03() throws Exception { |
| try { |
| // pass null |
| new PKIXParameters((Set) null); |
| fail("NPE expected"); |
| } catch (NullPointerException e) { |
| } |
| } |
| |
| /** |
| * Test #4 for <code>PKIXParameters(Set)</code> constructor<br> |
| * Assertion: <code>InvalidAlgorithmParameterException</code> - |
| * if the specified <code>Set</code> is empty |
| * (<code>trustAnchors.isEmpty() == true</code>) |
| */ |
| public final void testPKIXParametersSet04() { |
| try { |
| // use empty set |
| new PKIXParameters(new HashSet()); |
| fail("InvalidAlgorithmParameterException expected"); |
| } catch (InvalidAlgorithmParameterException e) { |
| } |
| } |
| |
| /** |
| * Test #5 for <code>PKIXParameters(Set)</code> constructor<br> |
| * Assertion: <code>ClassCastException</code> - |
| * if any of the elements in the <code>Set</code> are not of type |
| * <code>java.security.cert.TrustAnchor</code> |
| */ |
| public final void testPKIXParametersSet05() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| // add wrong object to valid set |
| assertTrue(taSet.add(new Object())); |
| try { |
| new PKIXParameters(taSet); |
| fail("ClassCastException expected"); |
| } catch (ClassCastException e) { |
| } |
| } |
| |
| /** |
| * Test #3 for <code>PKIXParameters(KeyStore)</code> constructor<br> |
| * Assertion: <code>NullPointerException</code> - |
| * if the <code>keystore</code> is <code>null</code> |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| * @throws KeyStoreException |
| */ |
| public final void testPKIXParametersKeyStore03() throws Exception { |
| try { |
| // pass null |
| new PKIXParameters((KeyStore) null); |
| fail("NPE expected"); |
| } catch (NullPointerException e) { |
| } |
| } |
| |
| /** |
| * Test #1 for <code>getPolicyQualifiersRejected()</code> method<br> |
| * Assertion: When a <code>PKIXParameters</code> object is created, |
| * this flag is set to <code>true</code><br> |
| * Assertion: returns the current value of the PolicyQualifiersRejected flag |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testGetPolicyQualifiersRejected() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| assertTrue(p.getPolicyQualifiersRejected()); |
| } |
| |
| /** |
| * Test for <code>setPolicyQualifiersRejected()</code> method<br> |
| * Assertion: set the new value of the |
| * <code>PolicyQualifiersRejected</code> flag |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetPolicyQualifiersRejected() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| p.setPolicyQualifiersRejected(false); |
| assertFalse("setFalse", p.getPolicyQualifiersRejected()); |
| p.setPolicyQualifiersRejected(true); |
| assertTrue("setTrue", p.getPolicyQualifiersRejected()); |
| } |
| |
| /** |
| * Test for <code>isAnyPolicyInhibited()</code> method<br> |
| * Assertion: returns <code>true</code> if the any policy |
| * OID is inhibited, <code>false</code> otherwise<br> |
| * Assertion: By default, the any policy OID is not inhibited |
| * (<code>isAnyPolicyInhibited()</code> returns false). |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testIsAnyPolicyInhibited() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| assertFalse(p.isAnyPolicyInhibited()); |
| } |
| |
| /** |
| * Test for <code>setAnyPolicyInhibited()</code> method<br> |
| * Assertion: sets state to determine if the any policy OID |
| * should be processed if it is included in a certificate |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetAnyPolicyInhibited() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| p.setAnyPolicyInhibited(true); |
| assertTrue("setTrue", p.isAnyPolicyInhibited()); |
| p.setAnyPolicyInhibited(false); |
| assertFalse("setFalse", p.isAnyPolicyInhibited()); |
| } |
| |
| /** |
| * Test for <code>isExplicitPolicyRequired()</code> method<br> |
| * Assertion: returns <code>true</code> if explicit policy is required, |
| * <code>false</code> otherwise<br> |
| * Assertion: by default, the ExplicitPolicyRequired flag is false |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testIsExplicitPolicyRequired() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| assertFalse(p.isExplicitPolicyRequired()); |
| } |
| |
| /** |
| * Test for <code>setExplicitPolicyRequired()</code> method<br> |
| * Assertion: sets the ExplicitPolicyRequired flag |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetExplicitPolicyRequired() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| p.setExplicitPolicyRequired(true); |
| assertTrue("setTrue", p.isExplicitPolicyRequired()); |
| p.setExplicitPolicyRequired(false); |
| assertFalse("setFalse", p.isExplicitPolicyRequired()); |
| } |
| |
| /** |
| * Test for <code>isPolicyMappingInhibited()</code> method<br> |
| * Assertion: returns true if policy mapping is inhibited, false otherwise |
| * Assertion: by default, policy mapping is not inhibited (the flag is false) |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testIsPolicyMappingInhibited() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| assertFalse(p.isPolicyMappingInhibited()); |
| } |
| |
| /** |
| * Test for <code>setPolicyMappingInhibited()</code> method<br> |
| * Assertion: sets the PolicyMappingInhibited flag |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetPolicyMappingInhibited() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| p.setPolicyMappingInhibited(true); |
| assertTrue("setTrue", p.isPolicyMappingInhibited()); |
| p.setPolicyMappingInhibited(false); |
| assertFalse("setFalse", p.isPolicyMappingInhibited()); |
| } |
| |
| /** |
| * Test for <code>isPolicyMappingInhibited()</code> method<br> |
| * Assertion: returns the current value of the RevocationEnabled flag |
| * Assertion: when a <code>PKIXParameters</code> object is created, |
| * this flag is set to true |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testIsRevocationEnabled() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| assertTrue(p.isRevocationEnabled()); |
| } |
| |
| /** |
| * Test for <code>isPolicyMappingInhibited()</code> method<br> |
| * Assertion: sets the RevocationEnabled flag |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetRevocationEnabled() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| p.setRevocationEnabled(false); |
| assertFalse("setFalse", p.isRevocationEnabled()); |
| p.setRevocationEnabled(true); |
| assertTrue("setTrue", p.isRevocationEnabled()); |
| } |
| |
| /** |
| * Test for <code>getSigProvider()</code> method<br> |
| * Assertion: returns the signature provider's name, |
| * or null if not set |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testGetSigProvider() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| assertNull("not set", p.getSigProvider()); |
| p.setSigProvider("Some Provider"); |
| assertNotNull("set", p.getSigProvider()); |
| } |
| |
| /** |
| * Test for <code>setSigProvider(String)</code> method<br> |
| * Assertion: sets the signature provider's name |
| */ |
| public final void testSetSigProvider() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| String sigProviderName = "Some Provider"; |
| p.setSigProvider(sigProviderName); |
| assertTrue("set", sigProviderName.equals(p.getSigProvider())); |
| p.setSigProvider(null); |
| assertNull("unset", p.getSigProvider()); |
| } |
| |
| /** |
| * Test #1 for <code>getTargetCertConstraints()</code> method<br> |
| * Assertion: returns a <code>CertSelector</code> specifying |
| * the constraints on the target certificate (or <code>null</code>) |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testGetTargetCertConstraints01() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| assertNull(p.getTargetCertConstraints()); |
| } |
| |
| /** |
| * Test #2 for <code>getTargetCertConstraints()</code> method<br> |
| * Assertion: note that the <code>CertSelector</code> returned |
| * is cloned to protect against subsequent modifications |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| * @throws IOException |
| */ |
| public final void testGetTargetCertConstraints02() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| X509CertSelector x509cs = new X509CertSelector(); |
| PKIXParameters p = new PKIXParameters(taSet); |
| p.setTargetCertConstraints(x509cs); |
| // get cert selector |
| X509CertSelector cs1 = (X509CertSelector) p.getTargetCertConstraints(); |
| // modify returned selector |
| cs1.setIssuer(testIssuer); |
| // get cert selector again |
| X509CertSelector cs2 = (X509CertSelector) p.getTargetCertConstraints(); |
| // check that selector is not the same |
| assertNotSame("notTheSame", cs1, cs2); |
| // check that selector's internal state has |
| // not been changed by above modification |
| assertFalse("stateNotChanged", testIssuer.equals(cs2.getIssuerAsString())); |
| } |
| |
| /** |
| * Test for <code>setTargetCertConstraints(CertSelector)</code> method<br> |
| * Assertion: sets the required constraints on the target certificate. |
| * The constraints are specified as an instance of CertSelector<br> |
| * Assertion: ... If <code>null</code>, no constraints are defined |
| * |
| * @throws IOException |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetTargetCertConstraints01() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| X509CertSelector x509cs = new X509CertSelector(); |
| x509cs.setIssuer(testIssuer); |
| PKIXParameters p = new PKIXParameters(taSet); |
| p.setTargetCertConstraints(x509cs); |
| assertEquals("set", |
| testIssuer, |
| ((X509CertSelector) p.getTargetCertConstraints()).getIssuerAsString()); |
| p.setTargetCertConstraints(null); |
| assertNull("unset", p.getTargetCertConstraints()); |
| } |
| |
| /** |
| * Test #2 for <code>setTargetCertConstraints(CertSelector)</code> method<br> |
| * Assertion: ... the CertSelector specified is cloned to protect against |
| * subsequent modifications |
| * |
| * @throws IOException |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetTargetCertConstraints02() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| X509CertSelector x509cs = new X509CertSelector(); |
| PKIXParameters p = new PKIXParameters(taSet); |
| p.setTargetCertConstraints(x509cs); |
| // modify selector |
| x509cs.setIssuer(testIssuer); |
| // get selector |
| X509CertSelector x509cs1 = (X509CertSelector) p.getTargetCertConstraints(); |
| // check that selector's internal state has |
| // not been changed by above modification |
| assertFalse(testIssuer.equals(x509cs1.getIssuerAsString())); |
| } |
| |
| /** |
| * Test #1 for <code>getCertStores()</code> method<br> |
| * Assertion: list ... (may be empty, but never <code>null</code>) |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testGetCertStores01() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| assertNotNull("notNull", p.getCertStores()); |
| assertTrue("isEmpty", p.getCertStores().isEmpty()); |
| } |
| |
| /** |
| * Test #2 for <code>getCertStores()</code> method<br> |
| * Assertion: returns an immutable <code>List</code> |
| * of <code>CertStores</code> |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testGetCertStores02() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| List cs = p.getCertStores(); |
| |
| try { |
| // try to modify returned list |
| cs.add(new Object()); |
| fail("must be immutable"); |
| } catch (Exception e) { |
| } |
| } |
| |
| /** |
| * Test #1 for <code>setCertStores(List)</code> method<br> |
| * Assertion: Sets the list of CertStores ... |
| * |
| * @throws NoSuchAlgorithmException |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetCertStores01() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| p.setCertStores(TestUtils.getCollectionCertStoresList()); |
| // check that list has been set |
| assertFalse(p.getCertStores().isEmpty()); |
| } |
| |
| /** |
| * Test #2 for <code>setCertStores(List)</code> method<br> |
| * Assertion: list ... may be <code>null</code> |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetCertStores02() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| // add null |
| p.setCertStores(null); |
| // check that we have non null empty list now |
| assertNotNull("notNull1", p.getCertStores()); |
| assertTrue("isEmpty1", p.getCertStores().isEmpty()); |
| // add empty |
| p.setCertStores(new ArrayList()); |
| assertNotNull("notNull2", p.getCertStores()); |
| assertTrue("isEmpty2", p.getCertStores().isEmpty()); |
| } |
| |
| /** |
| * Test #3 for <code>setCertStores(List)</code> method<br> |
| * Assertion: list is copied to protect against subsequent modifications |
| * |
| * @throws NoSuchAlgorithmException |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetCertStores03() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| List l = TestUtils.getCollectionCertStoresList(); |
| p.setCertStores(l); |
| // modify list just set |
| l.clear(); |
| // check that list maintained internally has |
| // not been changed by the above modification |
| assertFalse(p.getCertStores().isEmpty()); |
| } |
| |
| /** |
| * Test #4 for <code>setCertStores(List)</code> method<br> |
| * Assertion: <code>ClassCastException</code> - |
| * if any of the elements in the list are not of type |
| * <code>java.security.cert.CertStore</code> |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| * @throws NoSuchAlgorithmException |
| */ |
| public final void testSetCertStores04() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| List l = TestUtils.getCollectionCertStoresList(); |
| // add wrong object to valid set |
| assertTrue(l.add(new Object())); |
| |
| try { |
| p.setCertStores(l); |
| fail("ClassCastException expected"); |
| } catch (ClassCastException e) { |
| } |
| } |
| |
| /** |
| * Test #1 for <code>addCertStore(CertStore)</code> method<br> |
| * Assertion: adds a <code>CertStore</code> to the end of the |
| * list of <code>CertStores</code> |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| * @throws NoSuchAlgorithmException |
| */ |
| public final void testAddCertStore01() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| p.addCertStore(CertStore.getInstance("Collection", |
| new CollectionCertStoreParameters())); |
| assertFalse(p.getCertStores().isEmpty()); |
| } |
| |
| /** |
| * Test #2 for <code>addCertStore(CertStore)</code> method<br> |
| * Assertion: if <code>null</code>, the store is ignored (not added to list) |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testAddCertStore02() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| p.addCertStore(null); |
| assertTrue(p.getCertStores().isEmpty()); |
| } |
| |
| /** |
| * Test #1 for <code>getCertPathCheckers()</code> method<br> |
| * Assertion: list ... may be empty, but not <code>null</code> |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testGetCertPathCheckers01() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| List l = p.getCertPathCheckers(); |
| assertNotNull("notNull", l); |
| assertTrue("isEmpty", l.isEmpty()); |
| } |
| |
| /** |
| * Test #2 for <code>getCertPathCheckers()</code> method<br> |
| * Assertion: returns an immutable <code>List</code> |
| * of <code>PKIXCertPathChecker</code>s |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testGetCertPathCheckers02() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| List l = p.getCertPathCheckers(); |
| |
| try { |
| // try to modify returned list |
| l.add(new Object()); |
| fail("must be immutable"); |
| } catch (Exception e) { |
| } |
| } |
| |
| /** |
| * Test #3 for <code>getCertPathCheckers()</code> method<br> |
| * Assertion: The returned List is immutable, and each |
| * <code>PKIXCertPathChecker</code> in the <code>List</code> |
| * is cloned to protect against subsequent modifications |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| * @throws CertPathValidatorException |
| */ |
| public final void testGetCertPathCheckers03() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| PKIXCertPathChecker cpc = TestUtils.getTestCertPathChecker(); |
| List l = new ArrayList(); |
| assertTrue("addedOk", l.add(cpc)); |
| p.setCertPathCheckers(l); |
| // retrieve checker and modify it |
| PKIXCertPathChecker cpc1 = p.getCertPathCheckers().get(0); |
| cpc1.init(true); |
| assertTrue("modifiedOk", cpc1.isForwardCheckingSupported()); |
| // retrieve checker again and check |
| // that its state has not been changed |
| // by the above modification |
| PKIXCertPathChecker cpc2 = p.getCertPathCheckers().get(0); |
| assertFalse("isCloned", cpc2.isForwardCheckingSupported()); |
| } |
| |
| /** |
| * Test #1 for <code>setCertPathCheckers(List)</code> method<br> |
| * Assertion: sets a <code>List</code> of additional |
| * certification path checkers |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetCertPathCheckers01() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| PKIXCertPathChecker cpc = TestUtils.getTestCertPathChecker(); |
| List l = new ArrayList(); |
| assertTrue("addedOk", l.add(cpc)); |
| p.setCertPathCheckers(l); |
| List l1 = p.getCertPathCheckers(); |
| assertNotNull("notNull", l1); |
| assertFalse("isNotEmpty", l1.isEmpty()); |
| } |
| |
| /** |
| * Test #2 for <code>setCertPathCheckers(List)</code> method<br> |
| * Assertion: <code>List</code> ... may be null |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetCertPathCheckers02() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| p.setCertPathCheckers(null); |
| List l1 = p.getCertPathCheckers(); |
| assertNotNull("notNull1", l1); |
| assertTrue("isEmpty1", l1.isEmpty()); |
| p.setCertPathCheckers(new ArrayList()); |
| List l2 = p.getCertPathCheckers(); |
| assertNotNull("notNull2", l2); |
| assertTrue("isEmpty2", l2.isEmpty()); |
| } |
| |
| /** |
| * Test #3 for <code>setCertPathCheckers(List)</code> method<br> |
| * Assertion: <code>List</code> supplied here is copied and each |
| * <code>PKIXCertPathChecker</code> in the list is cloned to protect |
| * against subsequent modifications |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetCertPathCheckers03() throws Exception { |
| // checks that list copied |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| PKIXCertPathChecker cpc = TestUtils.getTestCertPathChecker(); |
| List l = new ArrayList(); |
| assertTrue("addedOk", l.add(cpc)); |
| p.setCertPathCheckers(l); |
| // modify list |
| l.clear(); |
| // retrieve list and check |
| // that its state has not been changed |
| // by the above modification |
| assertFalse("isCopied", p.getCertPathCheckers().isEmpty()); |
| } |
| |
| /** |
| * Test #4 for <code>setCertPathCheckers(List)</code> method<br> |
| * Assertion: <code>List</code> supplied here is copied and each |
| * <code>PKIXCertPathChecker</code> in the list is cloned to protect |
| * against subsequent modifications |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| * @throws CertPathValidatorException |
| */ |
| public final void testSetCertPathCheckers04() throws Exception { |
| // checks that checkers cloned |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| PKIXCertPathChecker cpc = TestUtils.getTestCertPathChecker(); |
| List l = new ArrayList(); |
| assertTrue("addedOk", l.add(cpc)); |
| p.setCertPathCheckers(l); |
| // modify checker |
| cpc.init(true); |
| // retrieve list and check that CertPathChecker's |
| // state it contains has not been changed by the |
| // above modification |
| PKIXCertPathChecker cpc1 = p.getCertPathCheckers().get(0); |
| assertFalse("isCopied", cpc1.isForwardCheckingSupported()); |
| } |
| |
| /** |
| * Test #5 for <code>setCertPathCheckers(List)</code> method<br> |
| * Assertion: <code>ClassCastException</code> - |
| * if any of the elements in the list are not of type |
| * <code>java.security.cert.PKIXCertPathChecker</code> |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetCertPathCheckers05() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| PKIXCertPathChecker cpc = TestUtils.getTestCertPathChecker(); |
| List l = new ArrayList(); |
| assertTrue("addedOk", l.add(cpc)); |
| // add wrong object to the list |
| assertTrue("addedOk", l.add(new Object())); |
| |
| try { |
| p.setCertPathCheckers(l); |
| fail("ClassCastException expected"); |
| } catch (ClassCastException e) { |
| } |
| } |
| |
| /** |
| * Test #1 for <code>addCertPathChecker(PKIXCertPathChecker)</code> method<br> |
| * Assertion: adds a <code>CertPathChecker</code> to the end of the |
| * list of <code>CertPathChecker</code>s |
| * |
| * @throws CertPathValidatorException |
| */ |
| public final void testAddCertPathChecker01() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| PKIXCertPathChecker cpc = TestUtils.getTestCertPathChecker(); |
| List l = new ArrayList(); |
| assertTrue("addedOk", l.add(cpc)); |
| p.setCertPathCheckers(l); |
| // create one more PKIXCertPathChecker |
| PKIXCertPathChecker cpc1 = TestUtils.getTestCertPathChecker(); |
| cpc1.init(true); |
| p.addCertPathChecker(cpc1); |
| // check that we have two PKIXCertPathCheckers and |
| // they are in right order |
| List l1 = p.getCertPathCheckers(); |
| assertEquals("listSize", 2, l1.size()); |
| assertFalse("order1", |
| ((PKIXCertPathChecker) l1.get(0)).isForwardCheckingSupported()); |
| assertTrue("order2", |
| ((PKIXCertPathChecker) l1.get(1)).isForwardCheckingSupported()); |
| } |
| |
| /** |
| * Test #2 for <code>addCertPathChecker(PKIXCertPathChecker)</code> method<br> |
| * Assertion: if null, the checker is ignored (not added to list). |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testAddCertPathChecker02() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| PKIXCertPathChecker cpc = TestUtils.getTestCertPathChecker(); |
| List l = new ArrayList(); |
| assertTrue("addedOk", l.add(cpc)); |
| p.setCertPathCheckers(l); |
| // try to add null |
| p.addCertPathChecker(null); |
| // check that we have one PKIXCertPathChecker |
| List l1 = p.getCertPathCheckers(); |
| assertEquals("listSize", 1, l1.size()); |
| } |
| |
| /** |
| * Test #3 for <code>addCertPathChecker(PKIXCertPathChecker)</code> method<br> |
| * Assertion: <code>PKIXCertPathChecker</code> is cloned to protect |
| * against subsequent modifications |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| * @throws CertPathValidatorException |
| */ |
| public final void testAddCertPathChecker03() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| // checks that checkers cloned |
| PKIXParameters p = new PKIXParameters(taSet); |
| PKIXCertPathChecker cpc = TestUtils.getTestCertPathChecker(); |
| |
| p.addCertPathChecker(cpc); |
| // modify checker |
| cpc.init(true); |
| // retrieve list and check that CertPathChecker's |
| // state it contains has not been changed by the |
| // above modification |
| List l = p.getCertPathCheckers(); |
| PKIXCertPathChecker cpc1 = (PKIXCertPathChecker) l.get(0); |
| assertEquals("listSize", 1, l.size()); |
| assertFalse("isCopied", cpc1.isForwardCheckingSupported()); |
| } |
| |
| /** |
| * Test #1 for <code>getDate()</code> method<br> |
| * Assertion: the <code>Date</code>, or <code>null</code> if not set |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testGetDate01() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| // the Date has not been set |
| // the method must return null |
| assertNull("null", p.getDate()); |
| Date currentDate = new Date(); |
| p.setDate(currentDate); |
| // the Date returned must match |
| assertEquals("notNull", currentDate, p.getDate()); |
| } |
| |
| /** |
| * Test #2 for <code>getDate()</code> method<br> |
| * Assertion: <code>Date</code> returned is copied to protect |
| * against subsequent modifications |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testGetDate02() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| Date currentDate = new Date(); |
| p.setDate((Date) currentDate.clone()); |
| Date ret1 = p.getDate(); |
| // modify Date returned |
| ret1.setTime(0L); |
| // check that internal Date has not been |
| // changed by the above modification |
| assertEquals(currentDate, p.getDate()); |
| } |
| |
| /** |
| * @tests java.security.cert.PKIXParameters#setDate(Date) |
| */ |
| public final void test_setDateLjava_util_Date() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| assertNotNull("could not create test TrustAnchor set", taSet); |
| |
| // test: 'date' is unset and param is null |
| PKIXParameters p = new PKIXParameters(taSet); |
| p.setDate(null); |
| assertNull(p.getDate()); |
| |
| // test: 'date' is not null |
| p = new PKIXParameters(taSet); |
| Date toBeSet = new Date(555L); |
| p.setDate(toBeSet); |
| assertEquals(555L, p.getDate().getTime()); |
| // modify initial 'date' - it should be copied by constructor |
| toBeSet.setTime(0L); |
| // check that internal 'date' has not been |
| // changed by the above modification |
| assertEquals(555L, p.getDate().getTime()); |
| // set another 'date' |
| p.setDate(new Date(333L)); |
| assertEquals(333L, p.getDate().getTime()); |
| |
| // Regression for HARMONY-2882 (non-bug difference from RI) |
| p = new PKIXParameters(taSet); |
| p.setDate(new Date(555L)); |
| p.setDate(null); // reset 'date' back to current time |
| assertNull(p.getDate()); |
| } |
| |
| /** |
| * Test #1 for <code>getInitialPolicies()</code> method<br> |
| * Assertion: The default return value is an empty <code>Set</code> |
| * Assertion: Never returns <code>null</code> |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testGetInitialPolicies01() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| assertNotNull("notNull", p.getInitialPolicies()); |
| assertTrue("isEmpty", p.getInitialPolicies().isEmpty()); |
| } |
| |
| /** |
| * Test #2 for <code>getInitialPolicies()</code> method<br> |
| * Assertion: returns an immutable <code>Set</code> of initial |
| * policy OIDs in <code>String</code> format<br> |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testGetInitialPolicies02() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| Set s = p.getInitialPolicies(); |
| try { |
| // try to modify returned set |
| s.add(new Object()); |
| fail("must be immutable"); |
| } catch (Exception e) { |
| } |
| } |
| |
| /** |
| * Test #1 for <code>setInitialPolicies(Set)</code> method<br> |
| * Assertion: sets the <code>Set</code> of initial policy |
| * identifiers (OID strings) |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetInitialPolicies01() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| Set s = new HashSet(); |
| s.add("1.2.3.4.5.6.7"); |
| PKIXParameters p = new PKIXParameters(taSet); |
| p.setInitialPolicies(s); |
| assertEquals(1, p.getInitialPolicies().size()); |
| } |
| |
| /** |
| * Test #2 for <code>setInitialPolicies(Set)</code> method<br> |
| * Assertion: <code>Set</code> may be <code>null</code> |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetInitialPolicies02() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| p.setInitialPolicies(null); |
| assertTrue(p.getInitialPolicies().isEmpty()); |
| } |
| |
| /** |
| * Test #3 for <code>setInitialPolicies(Set)</code> method<br> |
| * Assertion: <code>Set</code> may be empty |
| */ |
| public final void testSetInitialPolicies03() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| p.setInitialPolicies(new HashSet()); |
| assertTrue(p.getInitialPolicies().isEmpty()); |
| } |
| |
| /** |
| * Test #4 for <code>setInitialPolicies(Set)</code> method<br> |
| * Assertion: <code>Set</code> is copied to protect against |
| * subsequent modifications |
| */ |
| public final void testSetInitialPolicies04() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| Set s = new HashSet(); |
| s.add("1.2.3.4.5.6.7"); |
| s.add("1.2.3.4.5.6.8"); |
| PKIXParameters p = new PKIXParameters(taSet); |
| p.setInitialPolicies(s); |
| // modify original set |
| s.clear(); |
| // check that set maintained internally has |
| // not been changed by the above modification |
| assertEquals(2, p.getInitialPolicies().size()); |
| } |
| |
| /** |
| * Test #5 for <code>setInitialPolicies(Set)</code> method<br> |
| * Assertion: <code>ClassCastException</code> - |
| * if any of the elements in the set are not of type <code>String</code> |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetInitialPolicies05() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| Set s = new HashSet(); |
| s.add("1.2.3.4.5.6.7"); |
| s.add(new Object()); |
| PKIXParameters p = new PKIXParameters(taSet); |
| try { |
| p.setInitialPolicies(s); |
| fail("ClassCastException expected"); |
| } catch (ClassCastException e) { |
| } |
| } |
| |
| /** |
| * Test #1 for <code>getTrustAnchors()</code> method<br> |
| * Assertion: an immutable <code>Set</code> of <code>TrustAnchors</code> |
| * (never <code>null</code>) |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testGetTrustAnchors01() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| assertNotNull("notNull", p.getTrustAnchors()); |
| } |
| |
| /** |
| * Test #2 for <code>getTrustAnchors()</code> method<br> |
| * Assertion: an immutable <code>Set</code> of <code>TrustAnchors</code> |
| * (never <code>null</code>) |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testGetTrustAnchors02() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| Set s = p.getTrustAnchors(); |
| try { |
| // try to modify returned set |
| s.add(new Object()); |
| fail("must be immutable"); |
| } catch (Exception e) { |
| } |
| } |
| |
| /** |
| * Test #1 for <code>setTrustAnchors(Set)</code> method<br> |
| * Assertion: Sets the <code>Set</code> of most-trusted CAs |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetTrustAnchors01() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| Set taSet1 = TestUtils.getTrustAnchorSet(); |
| PKIXParameters p = new PKIXParameters(taSet); |
| p.setTrustAnchors(taSet1); |
| assertFalse(p.getTrustAnchors().isEmpty()); |
| } |
| |
| /** |
| * Test #2 for <code>setTrustAnchors(Set)</code> method<br> |
| * Assertion: <code>InvalidAlgorithmParameterException</code> - |
| * if the specified <code>Set</code> is empty |
| * (<code>trustAnchors.isEmpty() == true</code>) |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetTrustAnchors02() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| try { |
| // use empty set |
| p.setTrustAnchors(new HashSet()); |
| fail("InvalidAlgorithmParameterException expected"); |
| } catch (InvalidAlgorithmParameterException e) { |
| } |
| } |
| |
| /** |
| * Test #3 for <code>setTrustAnchors(Set)</code> method<br> |
| * Assertion: <code>NullPointerException</code> - |
| * if the specified <code>Set</code> is <code>null</code>) |
| */ |
| public final void testSetTrustAnchors03() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| try { |
| // use null |
| p.setTrustAnchors(null); |
| fail("NPE expected"); |
| } catch (NullPointerException e) { |
| } |
| } |
| |
| /** |
| * Test #4 for <code>setTrustAnchors(Set)</code> method<br> |
| * Assertion: <code>ClassCastException</code> - |
| * if any of the elements in the set are not of type |
| * <code>java.security.cert.TrustAnchor</code> |
| * |
| * @throws InvalidAlgorithmParameterException |
| * |
| */ |
| public final void testSetTrustAnchors04() throws Exception { |
| Set taSet = TestUtils.getTrustAnchorSet(); |
| if (taSet == null) { |
| fail(getName() + ": not performed (could not create test TrustAnchor set)"); |
| } |
| |
| PKIXParameters p = new PKIXParameters(taSet); |
| Set s = new HashSet(p.getTrustAnchors()); |
| s.add(new Object()); |
| try { |
| p.setTrustAnchors(s); |
| fail("ClassCastException expected"); |
| } catch (ClassCastException e) { |
| } |
| } |
| |
| } |
