1/*
2 *  Licensed to the Apache Software Foundation (ASF) under one or more
3 *  contributor license agreements.  See the NOTICE file distributed with
4 *  this work for additional information regarding copyright ownership.
5 *  The ASF licenses this file to You under the Apache License, Version 2.0
6 *  (the "License"); you may not use this file except in compliance with
7 *  the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 *  Unless required by applicable law or agreed to in writing, software
12 *  distributed under the License is distributed on an "AS IS" BASIS,
13 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 *  See the License for the specific language governing permissions and
15 *  limitations under the License.
16 */
17
18/**
19 * @author Vera Y. Petrashkova
20 */
21
22package org.apache.harmony.security.tests.java.security.cert;
23
24import java.security.InvalidAlgorithmParameterException;
25import java.security.NoSuchAlgorithmException;
26import java.security.NoSuchProviderException;
27import java.security.Provider;
28import java.security.Security;
29import java.security.cert.CertPathBuilder;
30import java.security.cert.CertPathBuilderException;
31import java.security.cert.CertPathBuilderSpi;
32import java.security.cert.CertificateException;
33
34import junit.framework.TestCase;
35
36import org.apache.harmony.security.tests.support.SpiEngUtils;
37import org.apache.harmony.security.tests.support.cert.MyCertPathBuilderSpi;
38
39import tests.support.Support_Exec;
40
41/**
42 * Tests for <code>CertPathBuilder</code> class constructors and
43 * methods.
44 */
45
46public class CertPathBuilder1Test extends TestCase {
47
48    /**
49     * Constructor for CertPathBuilderTests.
50     *
51     * @param name
52     */
53    public CertPathBuilder1Test(String name) {
54        super(name);
55    }
56
57    public static final String srvCertPathBuilder = "CertPathBuilder";
58
59    public static final String defaultType = "PKIX";
60    public static final String[] validValues = {
61            "PKIX", "pkix", "PkiX", "pKiX" };
62
63    private static String[] invalidValues = SpiEngUtils.invalidValues;
64
65    private static boolean PKIXSupport = false;
66
67    private static Provider defaultProvider;
68    private static String defaultProviderName;
69
70    private static String NotSupportMsg = "";
71
72    public static final String DEFAULT_TYPE_PROPERTY = "certpathbuilder.type";
73
74    static {
75        defaultProvider = SpiEngUtils.isSupport(defaultType,
76                srvCertPathBuilder);
77        PKIXSupport = (defaultProvider != null);
78        defaultProviderName = (PKIXSupport ? defaultProvider.getName() : null);
79        NotSupportMsg = defaultType.concat(" is not supported");
80    }
81
82    private static CertPathBuilder[] createCPBs() {
83        if (!PKIXSupport) {
84            fail(NotSupportMsg);
85            return null;
86        }
87        try {
88            CertPathBuilder[] certPBs = new CertPathBuilder[3];
89            certPBs[0] = CertPathBuilder.getInstance(defaultType);
90            certPBs[1] = CertPathBuilder.getInstance(defaultType,
91                    defaultProviderName);
92            certPBs[2] = CertPathBuilder.getInstance(defaultType,
93                    defaultProvider);
94            return certPBs;
95        } catch (Exception e) {
96            return null;
97        }
98    }
99
100    /**
101     * @tests java.security.cert.CertPathBuilder#getDefaultType()
102     */
103    public void test_getDefaultType() throws Exception {
104
105        // Regression for HARMONY-2785
106
107        // test: default value
108        assertNull(Security.getProperty(DEFAULT_TYPE_PROPERTY));
109        assertEquals("PKIX", CertPathBuilder.getDefaultType());
110
111        // test: security property. fork new VM to keep testing env. clean
112        Support_Exec.execJava(new String[] { DefaultType.class.getName() },
113                null, true);
114    }
115
116    public static class DefaultType {
117
118        public static void main(String[] args) {
119
120            Security.setProperty(DEFAULT_TYPE_PROPERTY, "MyType");
121            assertEquals("MyType", CertPathBuilder.getDefaultType());
122
123            Security.setProperty(DEFAULT_TYPE_PROPERTY, "AnotherType");
124            assertEquals("AnotherType", CertPathBuilder.getDefaultType());
125        }
126    }
127
128    /**
129     * Test for <code>getInstance(String algorithm)</code> method
130     * Assertion:
131     * throws NullPointerException when algorithm is null
132     * throws NoSuchAlgorithmException when algorithm  is not correct
133     * or it is not available
134     */
135    public void testCertPathBuilder02() throws NoSuchAlgorithmException {
136        try {
137            CertPathBuilder.getInstance(null);
138            fail("No expected NullPointerException");
139        } catch (NullPointerException e) {
140        }
141        for (int i = 0; i < invalidValues.length; i++) {
142            try {
143                CertPathBuilder.getInstance(invalidValues[i]);
144                fail("NoSuchAlgorithmException must be thrown");
145            } catch (NoSuchAlgorithmException e) {
146            }
147        }
148    }
149
150    /**
151     * Test for <code>getInstance(String algorithm)</code> method
152     * Assertion: returns CertPathBuilder object
153     */
154    public void testCertPathBuilder03() throws NoSuchAlgorithmException {
155        if (!PKIXSupport) {
156            fail(NotSupportMsg);
157            return;
158        }
159        for (int i = 0; i < validValues.length; i++) {
160            CertPathBuilder cpb = CertPathBuilder.getInstance(validValues[i]);
161            assertEquals("Incorrect algorithm", cpb.getAlgorithm(), validValues[i]);
162        }
163    }
164
165    /**
166     * Test for <code>getInstance(String algorithm, String provider)</code> method
167     * Assertion: throws IllegalArgumentException when provider is null or empty
168     * <p/>
169     * FIXME: verify what exception will be thrown if provider is empty
170     */
171    public void testCertPathBuilder04()
172            throws NoSuchAlgorithmException, NoSuchProviderException {
173        if (!PKIXSupport) {
174            fail(NotSupportMsg);
175            return;
176        }
177        String provider = null;
178        for (int i = 0; i < validValues.length; i++) {
179            try {
180                CertPathBuilder.getInstance(validValues[i], provider);
181                fail("IllegalArgumentException must be thrown thrown");
182            } catch (IllegalArgumentException e) {
183            }
184            try {
185                CertPathBuilder.getInstance(validValues[i], "");
186                fail("IllegalArgumentException must be thrown thrown");
187            } catch (IllegalArgumentException e) {
188            }
189        }
190    }
191
192    /**
193     * Test for <code>getInstance(String algorithm, String provider)</code> method
194     * Assertion:
195     * throws NoSuchProviderException when provider has invalid value
196     */
197    public void testCertPathBuilder05()
198            throws NoSuchAlgorithmException {
199        if (!PKIXSupport) {
200            fail(NotSupportMsg);
201            return;
202        }
203        for (int i = 0; i < validValues.length; i++) {
204            for (int j = 1; j < invalidValues.length; j++) {
205                try {
206                    CertPathBuilder.getInstance(validValues[i], invalidValues[j]);
207                    fail("NoSuchProviderException must be hrown");
208                } catch (NoSuchProviderException e1) {
209                }
210            }
211        }
212    }
213
214    /**
215     * Test for <code>getInstance(String algorithm, String provider)</code> method
216     * Assertion:
217     * throws NullPointerException when algorithm is null
218     * throws NoSuchAlgorithmException when algorithm  is not correct
219     */
220    public void testCertPathBuilder06()
221            throws NoSuchAlgorithmException, NoSuchProviderException {
222        if (!PKIXSupport) {
223            fail(NotSupportMsg);
224            return;
225        }
226        try {
227            CertPathBuilder.getInstance(null, defaultProviderName);
228            fail("No expected NullPointerException");
229        } catch (NullPointerException e) {
230        }
231        for (int i = 0; i < invalidValues.length; i++) {
232            try {
233                CertPathBuilder.getInstance(invalidValues[i], defaultProviderName);
234                fail("NoSuchAlgorithmException must be thrown");
235            } catch (NoSuchAlgorithmException e1) {
236            }
237        }
238    }
239
240    /**
241     * Test for <code>getInstance(String algorithm, String provider)</code> method
242     * Assertion: returns CertPathBuilder object
243     */
244    public void testCertPathBuilder07()
245            throws NoSuchAlgorithmException, NoSuchProviderException {
246        if (!PKIXSupport) {
247            fail(NotSupportMsg);
248            return;
249        }
250        CertPathBuilder certPB;
251        for (int i = 0; i < validValues.length; i++) {
252            certPB = CertPathBuilder.getInstance(validValues[i], defaultProviderName);
253            assertEquals("Incorrect algorithm", certPB.getAlgorithm(), validValues[i]);
254            assertEquals("Incorrect provider name", certPB.getProvider().getName(), defaultProviderName);
255        }
256    }
257
258    /**
259     * Test for <code>getInstance(String algorithm, Provider provider)</code> method
260     * Assertion: throws IllegalArgumentException when provider is null
261     */
262    public void testCertPathBuilder08()
263            throws NoSuchAlgorithmException {
264        if (!PKIXSupport) {
265            fail(NotSupportMsg);
266            return;
267        }
268        Provider prov = null;
269        for (int t = 0; t < validValues.length; t++) {
270            try {
271                CertPathBuilder.getInstance(validValues[t], prov);
272                fail("IllegalArgumentException must be thrown");
273            } catch (IllegalArgumentException e1) {
274            }
275        }
276    }
277
278    /**
279     * Test for <code>getInstance(String algorithm, String provider)</code> method
280     * Assertion:
281     * throws NullPointerException when algorithm is null
282     * throws NoSuchAlgorithmException when algorithm  is not correct
283     */
284    public void testCertPathBuilder09()
285            throws NoSuchAlgorithmException, NoSuchProviderException {
286        if (!PKIXSupport) {
287            fail(NotSupportMsg);
288            return;
289        }
290        try {
291            CertPathBuilder.getInstance(null, defaultProvider);
292            fail("No expected NullPointerException");
293        } catch (NullPointerException e) {
294        }
295        for (int i = 0; i < invalidValues.length; i++) {
296            try {
297                CertPathBuilder.getInstance(invalidValues[i], defaultProvider);
298                fail("NoSuchAlgorithm must be thrown");
299            } catch (NoSuchAlgorithmException e1) {
300            }
301        }
302    }
303
304    /**
305     * Test for <code>getInstance(String algorithm, String provider)</code> method
306     * Assertion: returns CertPathBuilder object
307     */
308    public void testCertPathBuilder10()
309            throws NoSuchAlgorithmException, NoSuchProviderException {
310        if (!PKIXSupport) {
311            fail(NotSupportMsg);
312            return;
313        }
314        CertPathBuilder certPB;
315        for (int i = 0; i < invalidValues.length; i++) {
316            certPB = CertPathBuilder.getInstance(validValues[i], defaultProvider);
317            assertEquals("Incorrect algorithm", certPB.getAlgorithm(), validValues[i]);
318            assertEquals("Incorrect provider name", certPB.getProvider(), defaultProvider);
319        }
320    }
321
322    /**
323     * Test for <code>build(CertPathParameters params)</code> method
324     * Assertion: throws InvalidAlgorithmParameterException params is null
325     */
326    public void testCertPathBuilder11()
327            throws NoSuchAlgorithmException, NoSuchProviderException,
328            CertPathBuilderException {
329        if (!PKIXSupport) {
330            fail(NotSupportMsg);
331            return;
332        }
333        CertPathBuilder[] certPB = createCPBs();
334        assertNotNull("CertPathBuilder objects were not created", certPB);
335        for (int i = 0; i < certPB.length; i++) {
336            try {
337                certPB[i].build(null);
338                fail("InvalidAlgorithmParameterException must be thrown");
339            } catch (InvalidAlgorithmParameterException e) {
340            }
341        }
342    }
343
344    /**
345     * Test for
346     * <code>CertPathBuilder</code> constructor
347     * Assertion: returns CertPathBuilder object
348     */
349    public void testCertPathBuilder12()
350            throws CertificateException, NoSuchProviderException,
351            NoSuchAlgorithmException, InvalidAlgorithmParameterException,
352            CertPathBuilderException {
353        if (!PKIXSupport) {
354            fail(NotSupportMsg);
355            return;
356        }
357        CertPathBuilderSpi spi = new MyCertPathBuilderSpi();
358        CertPathBuilder certPB = new myCertPathBuilder(spi,
359                defaultProvider, defaultType);
360        assertEquals("Incorrect algorithm", certPB.getAlgorithm(), defaultType);
361        assertEquals("Incorrect provider", certPB.getProvider(), defaultProvider);
362        try {
363            certPB.build(null);
364            fail("CertPathBuilderException must be thrown ");
365        } catch (CertPathBuilderException e) {
366        }
367        certPB = new myCertPathBuilder(null, null, null);
368        assertNull("Incorrect algorithm", certPB.getAlgorithm());
369        assertNull("Incorrect provider", certPB.getProvider());
370        try {
371            certPB.build(null);
372            fail("NullPointerException must be thrown ");
373        } catch (NullPointerException e) {
374        }
375    }
376}
377
378/**
379 * Additional class to verify CertPathBuilder constructor
380 */
381class myCertPathBuilder extends CertPathBuilder {
382
383    public myCertPathBuilder(CertPathBuilderSpi spi, Provider prov, String type) {
384        super(spi, prov, type);
385    }
386}
387