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 * @version $Revision$
21 */
22 
23 package tests.security.cert;
24 
25 import junit.framework.TestCase;
26 
27 import org.apache.harmony.security.tests.support.SpiEngUtils;
28 import org.apache.harmony.security.tests.support.cert.MyCertificateFactorySpi;
29 
30 import java.io.ByteArrayInputStream;
31 import java.io.DataInputStream;
32 import java.security.NoSuchProviderException;
33 import java.security.Provider;
34 import java.security.Security;
35 import java.security.cert.CRL;
36 import java.security.cert.CRLException;
37 import java.security.cert.CertPath;
38 import java.security.cert.Certificate;
39 import java.security.cert.CertificateException;
40 import java.security.cert.CertificateFactory;
41 import java.util.Collection;
42 import java.util.Iterator;
43 import java.util.List;
44 
45 /**
46  * Tests for CertificateFactory class constructors and methods
47  *
48  */
49 public class CertificateFactory2Test extends TestCase {
50     private static final String defaultAlg = "CertFac";
51     private static final String CertificateFactoryProviderClass = "org.apache.harmony.security.tests.support.cert.MyCertificateFactorySpi";
52 
53     private static final String[] invalidValues = SpiEngUtils.invalidValues;
54 
55     private static final String[] validValues;
56 
57     static {
58         validValues = new String[4];
59         validValues[0] = defaultAlg;
60         validValues[1] = defaultAlg.toLowerCase();
61         validValues[2] = "CeRtFaC";
62         validValues[3] = "cerTFac";
63     }
64 
65     Provider mProv;
66 
setUp()67     protected void setUp() throws Exception {
68         super.setUp();
69         mProv = (new SpiEngUtils()).new MyProvider("MyCFProvider",
70                 "Provider for testing", CertificateFactory1Test.srvCertificateFactory
71                         .concat(".").concat(defaultAlg),
72                 CertificateFactoryProviderClass);
73         Security.insertProviderAt(mProv, 1);
74     }
75 
76     /*
77      * @see TestCase#tearDown()
78      */
tearDown()79     protected void tearDown() throws Exception {
80         super.tearDown();
81         Security.removeProvider(mProv.getName());
82     }
83 
checkResult(CertificateFactory certFactory, boolean mode)84     private void checkResult(CertificateFactory certFactory, boolean mode)
85             throws CertificateException, CRLException {
86         MyCertificateFactorySpi.putMode(mode);
87 
88         ByteArrayInputStream bais = new ByteArrayInputStream(new byte[0]);
89         DataInputStream dis = new DataInputStream(bais);
90         try {
91             certFactory.generateCertPath(bais);
92             fail("CertificateException must be thrown");
93         } catch (CertificateException e) {
94         }
95         try {
96             certFactory.generateCertPath(dis);
97             if (!mode) {
98                 fail("CertificateException must be thrown because encodings list is empty");
99             }
100         } catch (CertificateException e) {
101             if (mode) {
102                 fail("Unexpected CertificateFactoryException was thrown");
103             }
104         }
105         try {
106             certFactory.generateCertPath(bais, "aa");
107             fail("CertificateException must be thrown");
108         } catch (CertificateException e) {
109         }
110         try {
111             certFactory.generateCertPath(dis, "");
112             if (mode) {
113                 fail("IllegalArgumentException must be thrown");
114             }
115         } catch (IllegalArgumentException e) {
116             if (!mode) {
117                 fail("Unexpected IllegalArgumentException was thrown");
118             }
119         }
120         certFactory.generateCertPath(dis, "ss");
121 
122         try {
123             certFactory.generateCertificate(bais);
124             fail("CertificateException must be thrown");
125         } catch (CertificateException e) {
126         }
127         try {
128             certFactory.generateCertificates(null);
129             fail("CertificateException must be thrown");
130         } catch (CertificateException e) {
131         }
132         Certificate cert = certFactory.generateCertificate(dis);
133         assertNull("Result must be null", cert);
134         Collection<? extends Certificate> col = certFactory.generateCertificates(dis);
135         assertNull("Result must be null", col);
136 
137         try {
138             certFactory.generateCRL(bais);
139             fail("CRLException must be thrown");
140         } catch (CRLException e) {
141         }
142         try {
143             certFactory.generateCRLs(null);
144             fail("CRLException must be thrown");
145         } catch (CRLException e) {
146         }
147         CRL crl = certFactory.generateCRL(dis);
148         assertNull("Result must be null", crl);
149         Collection<? extends CRL> colc = certFactory.generateCRLs(dis);
150         assertNull("Result must be null", colc);
151 
152         List<Certificate> list = null;
153         CertPath cp;
154         try {
155             cp = certFactory.generateCertPath(list);
156             if (mode) {
157                 fail("NullPointerException must be thrown");
158             } else {
159                 assertNull("Must be null", cp);
160             }
161         } catch (NullPointerException e) {
162             if (!mode) {
163                 fail("Unexpected NullPointerException was thrown");
164             }
165         }
166         Iterator<String> it = certFactory.getCertPathEncodings();
167         if (mode) {
168             assertTrue(it.hasNext());
169         } else {
170             assertFalse(it.hasNext());
171         }
172     }
173 
174     /**
175      * Test for <code>getInstance(String type)</code> method
176      * Assertions:
177      * throws NullPointerException when type is null
178      * throws CertificateException when type is not available
179      * returns CertificateFactory object
180      */
GetInstance01(boolean mode)181     public void GetInstance01(boolean mode) throws CertificateException, CRLException {
182         try {
183             CertificateFactory.getInstance(null);
184             fail("NullPointerException or CertificateException must be thrown when type is null");
185         } catch (CertificateException e) {
186         } catch (NullPointerException e) {
187         }
188         for (int i = 0; i < invalidValues.length; i++) {
189             try {
190                 CertificateFactory.getInstance(invalidValues[i]);
191                 fail("CertificateException must be thrown (type: ".concat(
192                         invalidValues[i]).concat(")"));
193             } catch (CertificateException e) {
194             }
195         }
196         CertificateFactory cerF;
197         for (int i = 0; i < validValues.length; i++) {
198             cerF = CertificateFactory.getInstance(validValues[i]);
199             assertEquals("Incorrect type", cerF.getType(), validValues[i]);
200             assertEquals("Incorrect provider", cerF.getProvider(), mProv);
201             checkResult(cerF, mode);
202         }
203     }
204 
205     /**
206      * Test for <code>getInstance(String type, String provider)</code> method
207      * Assertions:
208      * throws NullPointerException when type is null
209      * throws CertificateException when type is not available
210      * throws IllegalArgumentException when provider is null or empty;
211      * throws NoSuchProviderException when provider is available;
212      * returns CertificateFactory object
213      */
214 
GetInstance02(boolean mode)215     public void GetInstance02(boolean mode) throws CertificateException,
216             NoSuchProviderException, IllegalArgumentException, CRLException {
217         try {
218             CertificateFactory.getInstance(null, mProv.getName());
219             fail("NullPointerException or CertificateException must be thrown when type is null");
220         } catch (CertificateException e) {
221         } catch (NullPointerException e) {
222         }
223         for (int i = 0; i < invalidValues.length; i++) {
224             try {
225                 CertificateFactory.getInstance(invalidValues[i], mProv
226                         .getName());
227                 fail("CertificateException must be thrown (type: ".concat(
228                         invalidValues[i]).concat(")"));
229             } catch (CertificateException e) {
230             }
231         }
232         String prov = null;
233         for (int i = 0; i < validValues.length; i++) {
234             try {
235                 CertificateFactory.getInstance(validValues[i], prov);
236                 fail("IllegalArgumentException must be thrown when provider is null (type: "
237                         .concat(validValues[i]).concat(")"));
238             } catch (IllegalArgumentException e) {
239             }
240             try {
241                 CertificateFactory.getInstance(validValues[i], "");
242                 fail("IllegalArgumentException must be thrown when provider is empty (type: "
243                         .concat(validValues[i]).concat(")"));
244             } catch (IllegalArgumentException e) {
245             }
246         }
247         for (int i = 0; i < validValues.length; i++) {
248             for (int j = 1; j < invalidValues.length; j++) {
249                 try {
250                     CertificateFactory.getInstance(validValues[i],
251                             invalidValues[j]);
252                     fail("NoSuchProviderException must be thrown (type: "
253                             .concat(validValues[i]).concat(" provider: ")
254                             .concat(invalidValues[j]).concat(")"));
255                 } catch (NoSuchProviderException e) {
256                 }
257             }
258         }
259         CertificateFactory cerF;
260         for (int i = 0; i < validValues.length; i++) {
261             cerF = CertificateFactory.getInstance(validValues[i], mProv
262                     .getName());
263             assertEquals("Incorrect type", cerF.getType(), validValues[i]);
264             assertEquals("Incorrect provider", cerF.getProvider().getName(),
265                     mProv.getName());
266             checkResult(cerF, mode);
267         }
268     }
269 
270     /**
271      * Test for <code>getInstance(String type, Provider provider)</code>
272      * method
273      * Assertions:
274      * throws NullPointerException when type is null
275      * throws CertificateException when type is not available
276      * throws IllegalArgumentException when provider is null;
277      * returns CertificateFactory object
278      */
279 
GetInstance03(boolean mode)280     public void GetInstance03(boolean mode) throws CertificateException,
281             IllegalArgumentException, CRLException {
282         try {
283             CertificateFactory.getInstance(null, mProv);
284             fail("NullPointerException or CertificateException must be thrown when type is null");
285         } catch (CertificateException e) {
286         } catch (NullPointerException e) {
287         }
288         for (int i = 0; i < invalidValues.length; i++) {
289             try {
290                 CertificateFactory.getInstance(invalidValues[i], mProv);
291                 fail("CertificateException must be thrown (type: ".concat(
292                         invalidValues[i]).concat(")"));
293             } catch (CertificateException e) {
294             }
295         }
296         Provider prov = null;
297         for (int i = 0; i < validValues.length; i++) {
298             try {
299                 CertificateFactory.getInstance(validValues[i], prov);
300                 fail("IllegalArgumentException must be thrown when provider is null (type: "
301                         .concat(validValues[i]).concat(")"));
302             } catch (IllegalArgumentException e) {
303             }
304         }
305         CertificateFactory cerF;
306         for (int i = 0; i < validValues.length; i++) {
307             cerF = CertificateFactory.getInstance(validValues[i], mProv);
308             assertEquals("Incorrect type", cerF.getType(), validValues[i]);
309             assertEquals("Incorrect provider", cerF.getProvider(), mProv);
310             checkResult(cerF,  mode);
311         }
312     }
testGetInstance01()313     public void testGetInstance01() throws CertificateException, CRLException {
314         GetInstance01(true);
315     }
testGetInstance02()316     public void testGetInstance02() throws CertificateException,
317         NoSuchProviderException, IllegalArgumentException, CRLException {
318         GetInstance02(true);
319     }
testGetInstance03()320     public void testGetInstance03() throws CertificateException,
321         IllegalArgumentException, CRLException {
322         GetInstance03(true);
323     }
testGetInstance04()324     public void testGetInstance04() throws CertificateException, CRLException {
325         GetInstance01(false);
326     }
testGetInstance05()327     public void testGetInstance05() throws CertificateException,
328         NoSuchProviderException, IllegalArgumentException, CRLException {
329         GetInstance02(false);
330     }
testGetInstance06()331     public void testGetInstance06() throws CertificateException,
332         IllegalArgumentException, CRLException {
333         GetInstance03(false);
334     }
335 }
336