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
23package tests.security.cert;
24
25import junit.framework.TestCase;
26
27import static org.mockito.Mockito.mock;
28import static org.mockito.Mockito.doReturn;
29
30import java.security.cert.CertPath;
31import java.security.cert.CertPathValidatorException;
32import java.security.cert.CertPathValidatorException.BasicReason;
33import java.security.cert.Certificate;
34import java.util.ArrayList;
35import java.util.Iterator;
36import java.util.List;
37import java.util.StringTokenizer;
38import java.util.Vector;
39
40
41/**
42 * Tests for <code>CertPathValidatorException</code> class constructors and
43 * methods.
44 *
45 */
46public class CertPathValidatorExceptionTest extends TestCase {
47
48    private static String[] msgs = {
49            "",
50            "Check new message",
51            "Check new message Check new message Check new message Check new message Check new message" };
52
53    private static Throwable tCause = new Throwable("Throwable for exception");
54
55    /**
56     * Test for <code>CertPathValidatorException()</code> constructor
57     * Assertion: constructs CertPathValidatorException with no detail message
58     */
59    public void testCertPathValidatorException01() {
60        CertPathValidatorException tE = new CertPathValidatorException();
61        assertNull("getMessage() must return null.", tE.getMessage());
62        assertNull("getCause() must return null", tE.getCause());
63    }
64
65    /**
66     * Test for <code>CertPathValidatorException(String)</code> constructor
67     * Assertion: constructs CertPathValidatorException with detail message msg.
68     * Parameter <code>msg</code> is not null.
69     */
70    public void testCertPathValidatorException02() {
71        CertPathValidatorException tE;
72        for (int i = 0; i < msgs.length; i++) {
73            tE = new CertPathValidatorException(msgs[i]);
74            assertEquals("getMessage() must return: ".concat(msgs[i]), tE
75                    .getMessage(), msgs[i]);
76            assertNull("getCause() must return null", tE.getCause());
77        }
78    }
79
80    /**
81     * Test for <code>CertPathValidatorException(String)</code> constructor
82     * Assertion: constructs CertPathValidatorException when <code>msg</code>
83     * is null
84     */
85    public void testCertPathValidatorException03() {
86        String msg = null;
87        CertPathValidatorException tE = new CertPathValidatorException(msg);
88        assertNull("getMessage() must return null.", tE.getMessage());
89        assertNull("getCause() must return null", tE.getCause());
90    }
91
92    /**
93     * Test for <code>CertPathValidatorException(Throwable)</code> constructor
94     * Assertion: constructs CertPathValidatorException when <code>cause</code>
95     * is null
96     */
97    public void testCertPathValidatorException04() {
98        Throwable cause = null;
99        CertPathValidatorException tE = new CertPathValidatorException(cause);
100        assertNull("getMessage() must return null.", tE.getMessage());
101        assertNull("getCause() must return null", tE.getCause());
102    }
103
104    /**
105     * Test for <code>CertPathValidatorException(Throwable)</code> constructor
106     * Assertion: constructs CertPathValidatorException when <code>cause</code>
107     * is not null
108     */
109    public void testCertPathValidatorException05() {
110        CertPathValidatorException tE = new CertPathValidatorException(tCause);
111        if (tE.getMessage() != null) {
112            String toS = tCause.toString();
113            String getM = tE.getMessage();
114            assertTrue("getMessage() should contain ".concat(toS), (getM
115                    .indexOf(toS) != -1));
116        }
117        assertNotNull("getCause() must not return null", tE.getCause());
118        assertEquals("getCause() must return ".concat(tCause.toString()), tE
119                .getCause(), tCause);
120    }
121
122    /**
123     * Test for <code>CertPathValidatorException(String, Throwable)</code>
124     * constructor Assertion: constructs CertPathValidatorException when
125     * <code>cause</code> is null <code>msg</code> is null
126     */
127    public void testCertPathValidatorException06() {
128        CertPathValidatorException tE = new CertPathValidatorException(null,
129                null);
130        assertNull("getMessage() must return null", tE.getMessage());
131        assertNull("getCause() must return null", tE.getCause());
132    }
133
134    /**
135     * Test for <code>CertPathValidatorException(String, Throwable)</code>
136     * constructor Assertion: constructs CertPathValidatorException when
137     * <code>cause</code> is null <code>msg</code> is not null
138     */
139    public void testCertPathValidatorException07() {
140        CertPathValidatorException tE;
141        for (int i = 0; i < msgs.length; i++) {
142            tE = new CertPathValidatorException(msgs[i], null);
143            assertEquals("getMessage() must return: ".concat(msgs[i]), tE
144                    .getMessage(), msgs[i]);
145            assertNull("getCause() must return null", tE.getCause());
146        }
147    }
148
149    /**
150     * Test for <code>CertPathValidatorException(String, Throwable)</code>
151     * constructor Assertion: constructs CertPathValidatorException when
152     * <code>cause</code> is not null <code>msg</code> is null
153     */
154    public void testCertPathValidatorException08() {
155        CertPathValidatorException tE = new CertPathValidatorException(null,
156                tCause);
157        if (tE.getMessage() != null) {
158            String toS = tCause.toString();
159            String getM = tE.getMessage();
160            assertTrue("getMessage() must should ".concat(toS), (getM
161                    .indexOf(toS) != -1));
162        }
163        assertNotNull("getCause() must not return null", tE.getCause());
164        assertEquals("getCause() must return ".concat(tCause.toString()), tE
165                .getCause(), tCause);
166    }
167
168    /**
169     * Test for <code>CertPathValidatorException(String, Throwable)</code>
170     * constructor Assertion: constructs CertPathValidatorException when
171     * <code>cause</code> is not null <code>msg</code> is not null
172     */
173    public void testCertPathValidatorException09() {
174        CertPathValidatorException tE;
175        for (int i = 0; i < msgs.length; i++) {
176            tE = new CertPathValidatorException(msgs[i], tCause);
177            String getM = tE.getMessage();
178            String toS = tCause.toString();
179            if (msgs[i].length() > 0) {
180                assertTrue("getMessage() must contain ".concat(msgs[i]), getM
181                        .indexOf(msgs[i]) != -1);
182                if (!getM.equals(msgs[i])) {
183                    assertTrue("getMessage() should contain ".concat(toS), getM
184                            .indexOf(toS) != -1);
185                }
186            }
187            assertNotNull("getCause() must not return null", tE.getCause());
188            assertEquals("getCause() must return ".concat(tCause.toString()),
189                    tE.getCause(), tCause);
190        }
191    }
192
193    /**
194     * Test for
195     * <code>CertPathValidatorException(String, Throwable, CertPath, int)</code>
196     * constructor Assertion: constructs CertPathValidatorException when
197     * <code>cause</code> is null <code>msg</code> is null
198     * <code>certPath</code> is null <code>index</code> is -1
199     */
200    public void testCertPathValidatorException10() {
201        CertPathValidatorException tE = new CertPathValidatorException(null,
202                null, null, -1);
203        assertNull("getMessage() must return null", tE.getMessage());
204        assertNull("getCause() must return null", tE.getCause());
205        assertNull("getCertPath() must return null", tE.getCertPath());
206        assertEquals("getIndex() must be -1", tE.getIndex(), -1);
207    }
208
209    /**
210     * Test for
211     * <code>CertPathValidatorException(String, Throwable, CertPath, int)</code>
212     * constructor Assertion: constructs CertPathValidatorException when
213     * <code>cause</code> is null <code>msg</code> is null
214     * <code>certPath</code> is null <code>index</code> not -1 throws:
215     * IllegalArgumentException
216     */
217    public void testCertPathValidatorException11() {
218        int[] indx = { 0, 1, 100, Integer.MAX_VALUE, Integer.MIN_VALUE };
219        for (int j = 0; j < indx.length; j++) {
220            for (int i = 0; i < msgs.length; i++) {
221                try {
222                    new CertPathValidatorException(msgs[i], tCause, null, indx[j]);
223                    fail("Error. IllegalArgumentException was not thrown as expected. "
224                            + " msg: "
225                            + msgs[i]
226                            + ", certPath is null and index is " + indx[j]);
227                } catch (IllegalArgumentException e) {
228                }
229            }
230        }
231    }
232
233    /**
234     * Test for
235     * <code>CertPathValidatorException(String, Throwable, CertPath, int)</code>
236     * constructor Assertion: constructs CertPathValidatorException when
237     * <code>cause</code> not null <code>msg</code> not null
238     * <code>certPath</code> is null <code>index</code> is -1
239     */
240    public void testCertPathValidatorException12() {
241        CertPathValidatorException tE;
242
243        for (int i = 0; i < msgs.length; i++) {
244            try {
245                tE = new CertPathValidatorException(msgs[i], tCause, null, -1);
246                String getM = tE.getMessage();
247                String toS = tCause.toString();
248                if (msgs[i].length() > 0) {
249                    assertTrue("getMessage() must contain ".concat(msgs[i]),
250                            getM.indexOf(msgs[i]) != -1);
251                    if (!getM.equals(msgs[i])) {
252                        assertTrue("getMessage() should contain ".concat(toS),
253                                getM.indexOf(toS) != -1);
254                    }
255                }
256                assertNotNull("getCause() must not return null", tE.getCause());
257                assertEquals("getCause() must return "
258                        .concat(tCause.toString()), tE.getCause(), tCause);
259                assertNull("getCertPath() must return null", tE.getCertPath());
260                assertEquals("getIndex() must return -1", tE.getIndex(), -1);
261            } catch (IndexOutOfBoundsException e) {
262                fail("Unexpected exception: " + e.toString()
263                        + " Parameters: msg: " + msgs[i]
264                        + ", certPath is null and index is -1");
265            }
266        }
267    }
268
269    /**
270     * Test for
271     * <code>CertPathValidatorException(String, Throwable, CertPath, int)</code>
272     * constructor Assertion: constructs CertPathValidatorException when
273     * <code>cause</code> not null <code>msg</code> not null
274     * <code>certPath</code> not null <code>index</code>< -1 || >=
275     * certPath.getCertificates().size() throws: IndexOutOfBoundsException
276     */
277    public void testCertPathValidatorException13() {
278        myCertPath mcp = new myCertPath("X.509", "");
279        CertPath cp = mcp.get("X.509");
280        int[] indx = { -2, -100, 0, 1, 100, Integer.MAX_VALUE,
281                Integer.MIN_VALUE };
282        for (int j = 0; j < indx.length; j++) {
283            for (int i = 0; i < msgs.length; i++) {
284                try {
285                    new CertPathValidatorException(msgs[i], tCause, cp, indx[j]);
286                    fail("IndexOutOfBoundsException was not thrown as expected. "
287                            + " msg: "
288                            + msgs[i]
289                            + ", certPath is null and index is " + indx[j]);
290                } catch (IndexOutOfBoundsException e) {
291                }
292            }
293        }
294    }
295
296    /**
297     * Test for
298     * <code>CertPathValidatorException(String, Throwable, CertPath, int)</code>
299     * constructor Assertion: constructs CertPathValidatorException when
300     * <code>cause</code> not null <code>msg</code> not null
301     * <code>certPath</code> not null <code>index</code><
302     * certPath.getCertificates().size()
303     */
304    public void testCertPathValidatorException14() {
305        CertPathValidatorException tE;
306        myCertPath mcp = new myCertPath("X.509", "");
307        CertPath cp = mcp.get("X.509");
308        for (int i = 0; i < msgs.length; i++) {
309            try {
310                tE = new CertPathValidatorException(msgs[i], tCause, cp, -1);
311                String getM = tE.getMessage();
312                String toS = tCause.toString();
313                if (msgs[i].length() > 0) {
314                    assertTrue("getMessage() must contain ".concat(msgs[i]),
315                            getM.indexOf(msgs[i]) != -1);
316                    if (!getM.equals(msgs[i])) {
317                        assertTrue("getMessage() should contain ".concat(toS),
318                                getM.indexOf(toS) != -1);
319                    }
320                }
321                assertNotNull("getCause() must not return null", tE.getCause());
322                assertEquals("getCause() must return "
323                        .concat(tCause.toString()), tE.getCause(), tCause);
324                assertNotNull("getCertPath() must not return null", tE
325                        .getCertPath());
326                assertEquals(
327                        "getCertPath() must return ".concat(cp.toString()), tE
328                                .getCertPath(), cp);
329                assertEquals("getIndex() must return -1", tE.getIndex(), -1);
330
331            } catch (IndexOutOfBoundsException e) {
332                fail("Unexpected IndexOutOfBoundsException was thrown. "
333                        + e.toString());
334            }
335        }
336    }
337
338    /**
339     * Test for <code>getCertPath()</code>. Returns the certification path
340     * that was being validated when the exception was thrown.
341     */
342    public void testCertPathValidatorException15() {
343        CertPathValidatorException tE = new CertPathValidatorException();
344        assertNull("getCertPath() must return null.", tE.getCertPath());
345
346        for (int i = 0; i < msgs.length; i++) {
347            tE = new CertPathValidatorException(msgs[i]);
348            assertNull("getCertPath() must return null ", tE.getCertPath());
349        }
350
351        Throwable cause = null;
352        tE = new CertPathValidatorException(cause);
353        assertNull("getCertPath() must return null.", tE.getCertPath());
354
355        tE = new CertPathValidatorException(tCause);
356        assertNull("getCertPath() must return null.", tE.getCertPath());
357
358        for (int i = 0; i < msgs.length; i++) {
359            tE = new CertPathValidatorException(msgs[i], tCause);
360            assertNull("getCertPath() must return null", tE.getCertPath());
361        }
362
363        tE = new CertPathValidatorException(null, null, null, -1);
364        assertNull("getCertPath() must return null", tE.getCertPath());
365
366        for (int i = 0; i < msgs.length; i++) {
367            try {
368                tE = new CertPathValidatorException(msgs[i], tCause, null, -1);
369                assertNull("getCertPath() must return null", tE.getCertPath());
370            } catch (IndexOutOfBoundsException e) {
371                fail("Unexpected exception: " + e.getMessage());
372            }
373        }
374
375        myCertPath mcp = new myCertPath("X.509", "");
376        CertPath cp = mcp.get("X.509");
377        for (int i = 0; i < msgs.length; i++) {
378            try {
379                tE = new CertPathValidatorException(msgs[i], tCause, cp, -1);
380                assertNotNull("getCertPath() must not return null", tE
381                        .getCertPath());
382                assertEquals(
383                        "getCertPath() must return ".concat(cp.toString()), tE
384                                .getCertPath(), cp);
385            } catch (IndexOutOfBoundsException e) {
386                fail("Unexpected IndexOutOfBoundsException was thrown. "
387                        + e.toString());
388            }
389        }
390    }
391
392    /**
393     * Test for <code>getIndex()</code>. Returns the index of the certificate
394     * in the certification path that caused the exception to be thrown. Note
395     * that the list of certificates in a CertPath is zero based. If no index
396     * has been set, -1 is returned.
397     */
398    public void testCertPathValidatorException16() {
399        CertPathValidatorException tE = new CertPathValidatorException();
400        assertEquals("getIndex() must be equals -1", -1, tE.getIndex());
401
402        for (int i = 0; i < msgs.length; i++) {
403            tE = new CertPathValidatorException(msgs[i]);
404            assertEquals("getIndex() must be equals -1", -1, tE.getIndex());
405        }
406
407        Throwable cause = null;
408        tE = new CertPathValidatorException(cause);
409        assertEquals("getIndex() must be equals -1", -1, tE.getIndex());
410
411        tE = new CertPathValidatorException(tCause);
412        assertEquals("getIndex() must be equals -1", -1, tE.getIndex());
413
414        for (int i = 0; i < msgs.length; i++) {
415            tE = new CertPathValidatorException(msgs[i], tCause);
416            assertEquals("getIndex() must be equals -1", -1, tE.getIndex());
417        }
418
419        tE = new CertPathValidatorException(null, null, null, -1);
420        assertEquals("getIndex() must be equals -1", -1, tE.getIndex());
421
422        myCertPath mcp = new myCertPath("X.509", "");
423        CertPath cp = mcp.get("X.509");
424        for (int i = 0; i < msgs.length; i++) {
425            try {
426                tE = new CertPathValidatorException(msgs[i], tCause, cp, -1);
427                assertNotNull("getIndex() must not return null", tE
428                        .getCertPath());
429                assertEquals(
430                        "getIndex() must return ".concat(cp.toString()), tE
431                                .getCertPath(), cp);
432            } catch (IndexOutOfBoundsException e) {
433                fail("Unexpected IndexOutOfBoundsException was thrown. "
434                        + e.getMessage());
435            }
436        }
437    }
438
439    public void testCertPathValidatorException_constructsCorrectlyWithReason() throws Exception {
440        Throwable cause = mock(Throwable.class);
441        CertPath certPath = mock(CertPath.class);
442
443        Certificate cert1 = mock(Certificate.class);
444        Certificate cert2 = mock(Certificate.class);
445        List<Certificate> certList = new ArrayList<Certificate>();
446        certList.add(cert1);
447        certList.add(cert2);
448        doReturn(certList).when(certPath).getCertificates();
449
450        CertPathValidatorException exception = new CertPathValidatorException("Test exception",
451                cause, certPath, 1, BasicReason.REVOKED);
452
453        assertEquals("Test exception", exception.getMessage());
454        assertEquals(cause, exception.getCause());
455        assertEquals(certPath, exception.getCertPath());
456        assertEquals(1, exception.getIndex());
457        assertEquals(BasicReason.REVOKED, exception.getReason());
458    }
459
460    class myCertPath extends CertPath {
461
462        private static final long serialVersionUID = 5871603047244722511L;
463
464        public List<Certificate> getCertificates() {
465            return new Vector<Certificate>();
466        }
467
468        public byte[] getEncoded() {
469            return new byte[0];
470        }
471
472        public byte[] getEncoded(String s) {
473            return new byte[0];
474        }
475
476        public Iterator<String> getEncodings() {
477            return (Iterator<String>) (new StringTokenizer("ss ss ss ss"));
478        }
479
480        protected myCertPath(String s) {
481            super(s);
482        }
483
484        public CertPath get(String s) {
485            return new myCertPath(s);
486        }
487
488        public myCertPath(String s, String s1) {
489            super(s);
490        }
491
492    }
493}
494
495
496