libcore/luni/src/test/java/tests/security/cert/CertificateFactory1Test.java

   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 * @author Vera Y. Petrashkova
  19 * @version $Revision$
  20 */
  21
  22 package tests.security.cert;
  23
  24 import dalvik.annotation.TestLevel;
  25 import dalvik.annotation.TestTargetClass;
  26 import dalvik.annotation.TestTargetNew;
  27 import dalvik.annotation.TestTargets;
  28
  29 import junit.framework.TestCase;
  30
  31 import org.apache.harmony.security.tests.support.SpiEngUtils;
  32 import org.apache.harmony.security.tests.support.cert.MyCertPath;
  33 import org.apache.harmony.security.tests.support.cert.MyCertificate;
  34 import org.apache.harmony.security.tests.support.cert.MyCertificateFactorySpi;
  35
  36 import java.io.ByteArrayInputStream;
  37 import java.io.ByteArrayOutputStream;
  38 import java.io.IOException;
  39 import java.io.InputStream;
  40 import java.io.ObjectOutputStream;
  41 import java.security.NoSuchProviderException;
  42 import java.security.Provider;
  43 import java.security.cert.CRL;
  44 import java.security.cert.CRLException;
  45 import java.security.cert.CertPath;
  46 import java.security.cert.Certificate;
  47 import java.security.cert.CertificateException;
  48 import java.security.cert.CertificateFactory;
  49 import java.security.cert.CertificateFactorySpi;
  50 import java.util.Collection;
  51 import java.util.Iterator;
  52 import java.util.List;
  53 import java.util.Vector;
  54
  55 /**
  56  * Tests for <code>CertificateFactory</code> class methods and constructor
  57  *
  58  */
  59 @TestTargetClass(CertificateFactory.class)
  60 public class CertificateFactory1Test extends TestCase {
  61
  62     public static final String srvCertificateFactory = "CertificateFactory";
  63
  64     private static String defaultProviderName = null;
  65
  66     private static Provider defaultProvider = null;
  67
  68     private static boolean X509Support = false;
  69
  70     public static String defaultType = "X.509";
  71
  72     public static final String[] validValues = {
  73             "X.509", "x.509" };
  74
  75     private final static String[] invalidValues = SpiEngUtils.invalidValues;
  76
  77     private static String NotSupportMsg = "";
  78
  79     static {
  80         defaultProvider = SpiEngUtils.isSupport(defaultType,
  81                 srvCertificateFactory);
  82         X509Support = (defaultProvider != null);
  83         defaultProviderName = (X509Support ? defaultProvider.getName() : null);
  84         NotSupportMsg = defaultType.concat(" is not supported");    }
  85
  86     private static CertificateFactory[] initCertFs() {
  87         if (!X509Support) {
  88             fail(NotSupportMsg);
  89             return null;
  90         }
  91         try {
  92             CertificateFactory[] certFs = new CertificateFactory[3];
  93             certFs[0] = CertificateFactory.getInstance(defaultType);
  94             certFs[1] = CertificateFactory.getInstance(defaultType,
  95                     defaultProviderName);
  96             certFs[2] = CertificateFactory.getInstance(defaultType,
  97                     defaultProvider);
  98             return certFs;
  99         } catch (Exception e) {
 100             return null;
 101         }
 102     }
 103
 104     private static MyCertificate createMC() {
 105         byte[] enc = { (byte) 0, (byte) 2, (byte) 3, (byte) 4, (byte) 5 };
 106         return new MyCertificate("Test_Test", enc);
 107     }
 108
 109     /**
 110      * Test for <code>getInstance(String type)</code> method
 111      * Assertion: returns CertificateFactory if type is X.509
 112      */
 113     @TestTargetNew(
 114         level = TestLevel.PARTIAL_COMPLETE,
 115         notes = "Doesn't verify CertificateException.",
 116         method = "getInstance",
 117         args = {java.lang.String.class}
 118     )
 119     public void testCertificateFactory01() throws CertificateException {
 120         if (!X509Support) {
 121             fail(NotSupportMsg);
 122             return;
 123         }
 124         for (int i = 0; i < validValues.length; i++) {
 125             CertificateFactory certF = CertificateFactory
 126                     .getInstance(validValues[i]);
 127             assertEquals("Incorrect type: ", validValues[i], certF.getType());
 128         }
 129     }
 130
 131     /**
 132      * Test for <code>getInstance(String type)</code> method
 133      * Assertion:
 134      * throws NullPointerException when type is null
 135      * throws CertificateException when type is not available
 136      */
 137     @TestTargetNew(
 138         level = TestLevel.PARTIAL_COMPLETE,
 139         notes = "Verifies CertificateException.",
 140         method = "getInstance",
 141         args = {java.lang.String.class}
 142     )
 143     public void testCertificateFactory02() {
 144         try {
 145             CertificateFactory.getInstance(null);
 146             fail("NullPointerException or CertificateException must be thrown when type is null");
 147         } catch (CertificateException e) {
 148         } catch (NullPointerException e) {
 149         }
 150         for (int i = 0; i < invalidValues.length; i++) {
 151             try {
 152                 CertificateFactory.getInstance(invalidValues[i]);
 153                 fail("CertificateException must be thrown when type: "
 154                         .concat(invalidValues[i]));
 155             } catch (CertificateException e) {
 156             }
 157         }
 158     }
 159
 160     /**
 161      * Test for <code>getInstance(String type, String provider)</code> method
 162      * Assertion: throws IllegalArgumentException when provider is null or empty
 163      */
 164     @TestTargetNew(
 165         level = TestLevel.PARTIAL_COMPLETE,
 166         notes = "Verifies IllegalArgumentException. IllegalArgumentException was checked instead of NoSuchProviderException",
 167         method = "getInstance",
 168         args = {java.lang.String.class, java.lang.String.class}
 169     )
 170     public void testCertificateFactory03() throws CertificateException,
 171             NoSuchProviderException {
 172         if (!X509Support) {
 173             fail(NotSupportMsg);
 174             return;
 175         }
 176         String provider = null;
 177         for (int i = 0; i < validValues.length; i++) {
 178             try {
 179                 CertificateFactory.getInstance(validValues[i], provider);
 180                 fail("IllegalArgumentException must be thrown when provider is null");
 181             } catch (IllegalArgumentException e) {
 182             }
 183             try {
 184                 CertificateFactory.getInstance(validValues[i], "");
 185                 fail("IllegalArgumentException  must be thrown when provider is empty");
 186             } catch (IllegalArgumentException e) {
 187             }
 188         }
 189     }
 190
 191     /**
 192      * Test for <code>getInstance(String type, String provider)</code> method
 193      * Assertion:
 194      * throws NullPointerException when type is null
 195      * throws CertificateException when type is not available
 196      */
 197     @TestTargetNew(
 198         level = TestLevel.PARTIAL_COMPLETE,
 199         notes = "Verifies CertificateException and NullPointerException.",
 200         method = "getInstance",
 201         args = {java.lang.String.class, java.lang.String.class}
 202     )
 203     public void testCertificateFactory04() throws NoSuchProviderException {
 204         if (!X509Support) {
 205             fail(NotSupportMsg);
 206             return;
 207         }
 208         try {
 209             CertificateFactory.getInstance(null, defaultProviderName);
 210             fail("NullPointerException or CertificateException must be thrown when type is null");
 211         } catch (CertificateException e) {
 212         } catch (NullPointerException e) {
 213         }
 214         for (int i = 0; i < invalidValues.length; i++) {
 215             try {
 216                 CertificateFactory.getInstance(invalidValues[i],
 217                         defaultProviderName);
 218                 fail("CertificateException must be thrown (type: ".concat(
 219                         invalidValues[i]).concat(" provider: ").concat(
 220                         defaultProviderName).concat(")"));
 221             } catch (CertificateException e) {
 222             }
 223         }
 224     }
 225
 226     /**
 227      * Test for <code>getInstance(String type, String provider)</code> method
 228      * Assertion: returns CertificateFactory when type and provider have valid
 229      * values
 230      */
 231     @TestTargetNew(
 232         level = TestLevel.PARTIAL_COMPLETE,
 233         notes = "Verifies positive functionality.",
 234         method = "getInstance",
 235         args = {java.lang.String.class, java.lang.String.class}
 236     )
 237     public void testCertificateFactory05() throws CertificateException,
 238             NoSuchProviderException {
 239         if (!X509Support) {
 240             fail(NotSupportMsg);
 241             return;
 242         }
 243         CertificateFactory certF;
 244         for (int i = 0; i < validValues.length; i++) {
 245             certF = CertificateFactory.getInstance(validValues[i],
 246                     defaultProviderName);
 247             assertEquals("Incorrect type", certF.getType(), validValues[i]);
 248             assertEquals("Incorrect provider name", certF.getProvider()
 249                     .getName(), defaultProviderName);
 250         }
 251     }
 252
 253     /**
 254      * Test for <code>getInstance(String type, Provider provider)</code>
 255      * method
 256      * Assertion: throws IllegalArgumentException when provider is null
 257      */
 258     @TestTargetNew(
 259         level = TestLevel.PARTIAL_COMPLETE,
 260         notes = "Verifies IllegalArgumentException.",
 261         method = "getInstance",
 262         args = {java.lang.String.class, java.security.Provider.class}
 263     )
 264     public void testCertificateFactory06() throws CertificateException {
 265         if (!X509Support) {
 266             fail(NotSupportMsg);
 267             return;
 268         }
 269         Provider provider = null;
 270         for (int i = 0; i < validValues.length; i++) {
 271             try {
 272                 CertificateFactory.getInstance(validValues[i], provider);
 273                 fail("IllegalArgumentException must be thrown  when provider is null");
 274             } catch (IllegalArgumentException e) {
 275             }
 276         }
 277     }
 278
 279     /**
 280      * Test for <code>getInstance(String type, Provider provider)</code>
 281      * method
 282      * Assertion:
 283      * throws NullPointerException when type is null
 284      * throws CertificateException when type is not available
 285      */
 286     @TestTargetNew(
 287         level = TestLevel.PARTIAL_COMPLETE,
 288         notes = "Verifies CertificateException.",
 289         method = "getInstance",
 290         args = {java.lang.String.class, java.security.Provider.class}
 291     )
 292     public void testCertificateFactory07() {
 293         if (!X509Support) {
 294             fail(NotSupportMsg);
 295             return;
 296         }
 297         try {
 298             CertificateFactory.getInstance(null, defaultProvider);
 299             fail("NullPointerException or CertificateException must be thrown when type is null");
 300         } catch (CertificateException e) {
 301         } catch (NullPointerException e) {
 302         }
 303         for (int i = 0; i < invalidValues.length; i++) {
 304             try {
 305                 CertificateFactory.getInstance(invalidValues[i],
 306                         defaultProvider);
 307                 fail("CertificateException was not thrown as expected (type:"
 308                         .concat(invalidValues[i]).concat(" provider: ").concat(
 309                                 defaultProvider.getName()).concat(")"));
 310             } catch (CertificateException e) {
 311             }
 312         }
 313     }
 314
 315     /**
 316      * Test for <code>getInstance(String type, Provider provider)</code>
 317      * method
 318      * Assertion: returns CertificateFactorythrows when type and provider
 319      * have valid values
 320      */
 321     @TestTargetNew(
 322         level = TestLevel.PARTIAL_COMPLETE,
 323         notes = "Verifies positive functionality of getInstance method.",
 324         method = "getInstance",
 325         args = {java.lang.String.class, java.security.Provider.class}
 326     )
 327     public void testCertificateFactory08() throws CertificateException {
 328         if (!X509Support) {
 329             fail(NotSupportMsg);
 330             return;
 331         }
 332         CertificateFactory certF;
 333         for (int i = 0; i < validValues.length; i++) {
 334             certF = CertificateFactory.getInstance(validValues[i],
 335                     defaultProvider);
 336             assertEquals("Incorrect provider", certF.getProvider(),
 337                     defaultProvider);
 338             assertEquals("Incorrect type", certF.getType(), validValues[i]);
 339         }
 340     }
 341
 342     /**
 343      * Test for <code>getCertPathEncodings()</code> method
 344      * Assertion: returns encodings
 345      */
 346     @TestTargetNew(
 347         level = TestLevel.COMPLETE,
 348         notes = "",
 349         method = "getCertPathEncodings",
 350         args = {}
 351     )
 352     public void testCertificateFactory09() {
 353         if (!X509Support) {
 354             fail(NotSupportMsg);
 355             return;
 356         }
 357         CertificateFactory[] certFs = initCertFs();
 358         assertNotNull("CertificateFactory objects were not created", certFs);
 359         Iterator<String> it1 = certFs[0].getCertPathEncodings();
 360         Iterator<String> it2 = certFs[1].getCertPathEncodings();
 361         assertEquals("Incorrect encodings", it1.hasNext(), it2.hasNext());
 362         while (it1.hasNext()) {
 363             it2 = certFs[1].getCertPathEncodings();
 364             String s1 = it1.next();
 365             boolean yesNo = false;
 366             while (it2.hasNext()) {
 367                 if (s1.equals(it2.next())) {
 368                     yesNo = true;
 369                     break;
 370                 }
 371             }
 372             assertTrue("Encoding: ".concat(s1).concat(
 373                     " does not define for certF2 CertificateFactory"), yesNo);
 374         }
 375         it1 = certFs[0].getCertPathEncodings();
 376         it2 = certFs[2].getCertPathEncodings();
 377         assertEquals("Incorrect encodings", it1.hasNext(), it2.hasNext());
 378         while (it1.hasNext()) {
 379             it2 = certFs[2].getCertPathEncodings();
 380             String s1 = it1.next();
 381             boolean yesNo = false;
 382             while (it2.hasNext()) {
 383                 if (s1.equals(it2.next())) {
 384                     yesNo = true;
 385                     break;
 386                 }
 387             }
 388             assertTrue("Encoding: ".concat(s1).concat(
 389                     " does not define for certF3 CertificateFactory"), yesNo);
 390         }
 391     }
 392
 393     /**
 394      * Test for <code>generateCertificate(InputStream inStream)</code>
 395      * <code>generateCertificates(InputStream inStream)</code>
 396      * <code>generateCRL(InputStream inStream)</code>
 397      * <code>generateCRLs(InputStream inStream)</code>
 398      * methods
 399      * Assertion: throw CertificateException and CRLException when
 400      * inStream is null or empty
 401      */
 402     @TestTargets({
 403         @TestTargetNew(
 404             level = TestLevel.PARTIAL_COMPLETE,
 405             notes = "Verifies methods with null and empty InputStream.",
 406             method = "generateCertificate",
 407             args = {java.io.InputStream.class}
 408         ),
 409         @TestTargetNew(
 410             level = TestLevel.PARTIAL_COMPLETE,
 411             notes = "Verifies methods with null and empty InputStream.",
 412             method = "generateCertificates",
 413             args = {java.io.InputStream.class}
 414         ),
 415         @TestTargetNew(
 416             level = TestLevel.PARTIAL_COMPLETE,
 417             notes = "Verifies methods with null and empty InputStream.",
 418             method = "generateCRL",
 419             args = {java.io.InputStream.class}
 420         ),
 421         @TestTargetNew(
 422             level = TestLevel.PARTIAL_COMPLETE,
 423             notes = "Verifies methods with null and empty InputStream.",
 424             method = "generateCRLs",
 425             args = {java.io.InputStream.class}
 426         )
 427     })
 428     public void testCertificateFactory10() {
 429         if (!X509Support) {
 430             fail(NotSupportMsg);
 431             return;
 432         }
 433         CertificateFactory[] certFs = initCertFs();
 434         assertNotNull("CertificateFactory objects were not created", certFs);
 435         byte [] bb = {};
 436         InputStream is = new ByteArrayInputStream(bb);
 437         Collection<?> colCer;
 438         Collection<?> colCrl;
 439         for (int i = 0; i < certFs.length; i++) {
 440             try {
 441                 certFs[i].generateCertificate(null);
 442                 fail("generateCertificate must thrown CertificateException or NullPointerEXception when input stream is null");
 443             } catch (CertificateException e) {
 444             } catch (NullPointerException e) {
 445             }
 446             is = new ByteArrayInputStream(bb);
 447             try {
 448                 certFs[i].generateCertificates(null);
 449                 fail("generateCertificates must throw CertificateException or NullPointerException when input stream is null");
 450             } catch (CertificateException e) {
 451             } catch (NullPointerException e) {
 452             }
 453             is = new ByteArrayInputStream(bb);
 454             try {
 455                 certFs[i].generateCertificate(is);
 456             } catch (CertificateException e) {
 457             }
 458             is = new ByteArrayInputStream(bb);
 459             try {
 460                 colCer = certFs[i].generateCertificates(is);
 461                 if (colCer != null) {
 462                     assertTrue("Not empty certificate collection", colCer.isEmpty());
 463                 }
 464             } catch (CertificateException e) {
 465             }
 466         }
 467         for (int i = 0; i < certFs.length; i++) {
 468             try {
 469                 certFs[i].generateCRL(null);
 470             } catch (CRLException e) {
 471             } catch (NullPointerException e) {
 472             }
 473             try {
 474                 colCrl = certFs[i].generateCRLs(null);
 475                 if (colCrl != null) {
 476                     assertTrue("Not empty CRL collection was returned from null stream", colCrl.isEmpty());
 477                 }
 478             } catch (CRLException e) {
 479             } catch (NullPointerException e) {
 480             }
 481             is = new ByteArrayInputStream(bb);
 482             try {
 483                  certFs[i].generateCRL(is);
 484             } catch (CRLException e) {
 485             }
 486             is = new ByteArrayInputStream(bb);
 487             try {
 488                 certFs[i].generateCRLs(is);
 489                 colCrl = certFs[i].generateCRLs(null);
 490                 if (colCrl != null) {
 491                     assertTrue("Not empty CRL collection was returned from empty stream", colCrl.isEmpty());
 492                 }
 493             } catch (CRLException e) {
 494             }
 495         }
 496     }
 497
 498     /*
 499      * Test for <code> generateCertificate(InputStream inStream) </code><code>
 500      * generateCertificates(InputStream inStream) </code><code>
 501      * generateCRL(InputStream inStream) </code><code>
 502      * generateCRLs(InputStream inStream) </code>
 503      * methods
 504      * Assertion: throw CertificateException and CRLException when inStream
 505      * contains incompatible datas
 506      */
 507     @TestTargets({
 508         @TestTargetNew(
 509             level = TestLevel.PARTIAL_COMPLETE,
 510             notes = "Verifies positive functionality of methods.",
 511             method = "generateCertificate",
 512             args = {java.io.InputStream.class}
 513         ),
 514         @TestTargetNew(
 515             level = TestLevel.PARTIAL_COMPLETE,
 516             notes = "Verifies positive functionality of methods.",
 517             method = "generateCertificates",
 518             args = {java.io.InputStream.class}
 519         ),
 520         @TestTargetNew(
 521             level = TestLevel.PARTIAL_COMPLETE,
 522             notes = "Verifies positive functionality of methods.",
 523             method = "generateCRL",
 524             args = {java.io.InputStream.class}
 525         ),
 526         @TestTargetNew(
 527             level = TestLevel.PARTIAL_COMPLETE,
 528             notes = "Verifies positive functionality of methods.",
 529             method = "generateCRLs",
 530             args = {java.io.InputStream.class}
 531         )
 532     })
 533     public void testCertificateFactory11() throws IOException {
 534         if (!X509Support) {
 535             fail(NotSupportMsg);
 536             return;
 537         }
 538         CertificateFactory[] certFs = initCertFs();
 539         assertNotNull("CertificateFactory objects were not created", certFs);
 540         MyCertificate mc = createMC();
 541         ByteArrayOutputStream os = new ByteArrayOutputStream();
 542         ObjectOutputStream oos = new ObjectOutputStream(os);
 543         oos.writeObject(mc);
 544         oos.flush();
 545         oos.close();
 546
 547         Certificate cer;
 548         Collection<?> colCer;
 549         CRL crl;
 550         Collection<?> colCrl;
 551
 552         byte[] arr = os.toByteArray();
 553         ByteArrayInputStream is;
 554         for (int i = 0; i < certFs.length; i++) {
 555             is = new ByteArrayInputStream(arr);
 556             try {
 557                 cer = certFs[i].generateCertificate(is);
 558                 assertNull("Not null certificate was created", cer);
 559             } catch (CertificateException e) {
 560             }
 561             is = new ByteArrayInputStream(arr);
 562             try {
 563                 colCer = certFs[i].generateCertificates(is);
 564                 if (colCer != null) {
 565                     assertTrue("Not empty certificate Collection was created", colCer.isEmpty());
 566                 }
 567             } catch (CertificateException e) {
 568             }
 569             is = new ByteArrayInputStream(arr);
 570             try {
 571                 crl = certFs[i].generateCRL(is);
 572                 assertNull("Not null CRL was created", crl);
 573             } catch (CRLException e) {
 574             }
 575             is = new ByteArrayInputStream(arr);
 576             try {
 577                 colCrl = certFs[i].generateCRLs(is);
 578                 if (colCrl != null) {
 579                     assertTrue("Not empty CRL Collection was created", colCrl.isEmpty());
 580                 }
 581             } catch (CRLException e) {
 582             }
 583         }
 584     }
 585
 586     /**
 587      * Test for <code>generateCertPath(InputStream inStream)</code>
 588      * <code>generateCertPath(InputStream inStream, String encoding)</code>
 589      * methods
 590      * Assertion: throws CertificateException when inStream is null or
 591      * when isStream contains invalid datas
 592      */
 593     @TestTargets({
 594         @TestTargetNew(
 595             level = TestLevel.PARTIAL_COMPLETE,
 596             notes = "Verifies CertificateException.",
 597             method = "generateCertPath",
 598             args = {java.io.InputStream.class, java.lang.String.class}
 599         ),
 600         @TestTargetNew(
 601             level = TestLevel.PARTIAL_COMPLETE,
 602             notes = "Verifies CertificateException.",
 603             method = "generateCertPath",
 604             args = {java.io.InputStream.class}
 605         )
 606     })
 607     public void testCertificateFactory12() {
 608         if (!X509Support) {
 609             fail(NotSupportMsg);
 610             return;
 611         }
 612         CertificateFactory[] certFs = initCertFs();
 613         assertNotNull("CertificateFactory objects were not created", certFs);
 614         InputStream is1 = null;
 615         InputStream is2 = new ByteArrayInputStream(new byte[10]);
 616
 617         for (int i = 0; i < certFs.length; i++) {
 618             try {
 619                 certFs[i].generateCertPath(is1);
 620                 fail("generateCertificate must thrown CertificateException or NullPointerException when input stream is null");
 621             } catch (CertificateException e) {
 622             } catch (NullPointerException e) {
 623             }
 624             try {
 625                 certFs[i].generateCertPath(is2);
 626                 fail("generateCertificate must thrown CertificateException when input stream contains invalid datas");
 627             } catch (CertificateException e) {
 628             }
 629             Iterator<String> it = certFs[i].getCertPathEncodings();
 630             while (it.hasNext()) {
 631                 String enc = it.next();
 632                 try {
 633                     certFs[i].generateCertPath(is1, enc);
 634                     fail("generateCertificate must thrown CertificateException or NullPointerException when input stream is null and encodings "
 635                             .concat(enc));
 636                 } catch (CertificateException e) {
 637                 } catch (NullPointerException e) {
 638                 }
 639                 try {
 640                     certFs[i].generateCertPath(is2, enc);
 641                     fail("generateCertificate must thrown CertificateException when input stream contains invalid datas  and encodings "
 642                             .concat(enc));
 643                 } catch (CertificateException e) {
 644                 }
 645             }
 646         }
 647     }
 648
 649     /**
 650      * Test for <code>generateCertPath(InputStream inStream)</code>
 651      * <code>generateCertPath(InputStream inStream, String encoding)</code>
 652      * methods
 653      * Assertion: throw CertificateException when isStream contains invalid datas
 654      */
 655     @TestTargets({
 656         @TestTargetNew(
 657             level = TestLevel.PARTIAL_COMPLETE,
 658             notes = "Verifies CertificateException.",
 659             method = "generateCertPath",
 660             args = {java.io.InputStream.class}
 661         ),
 662         @TestTargetNew(
 663             level = TestLevel.PARTIAL_COMPLETE,
 664             notes = "Verifies CertificateException.",
 665             method = "generateCertPath",
 666             args = {java.io.InputStream.class, java.lang.String.class}
 667         )
 668     })
 669     // Test passed on RI
 670     public void testCertificateFactory13() throws IOException {
 671         if (!X509Support) {
 672             fail(NotSupportMsg);
 673             return;
 674         }
 675         CertificateFactory[] certFs = initCertFs();
 676         assertNotNull("CertificateFactory objects were not created", certFs);
 677         byte[] enc = { (byte) 0, (byte) 2, (byte) 3, (byte) 4, (byte) 5 };
 678         MyCertPath mc = new MyCertPath(enc);
 679         ByteArrayOutputStream os = new ByteArrayOutputStream();
 680
 681         ObjectOutputStream oos = new ObjectOutputStream(os);
 682         oos.writeObject(mc);
 683         oos.flush();
 684         oos.close();
 685
 686         byte[] arr = os.toByteArray();
 687         ByteArrayInputStream is = new ByteArrayInputStream(arr);
 688
 689         for (int i = 0; i < certFs.length; i++) {
 690             try {
 691                 certFs[i].generateCertPath(is);
 692                 fail("CertificateException must be thrown because input stream contains incorrect datas");
 693             } catch (CertificateException e) {
 694             }
 695             Iterator<String> it = certFs[i].getCertPathEncodings();
 696             while (it.hasNext()) {
 697                 try {
 698                     certFs[i].generateCertPath(is, it.next());
 699                     fail("CertificateException must be thrown because input stream contains incorrect datas");
 700                 } catch (CertificateException e) {
 701                 }
 702             }
 703         }
 704     }
 705
 706     /**
 707      * Test for <code>generateCertPath(List certificates)</code> method
 708      * Assertion: throw NullPointerException certificates is null
 709      */
 710     @TestTargetNew(
 711         level = TestLevel.PARTIAL_COMPLETE,
 712         notes = "Verifies NullPointerException. Valid parameters checking missed.",
 713         method = "generateCertPath",
 714         args = {java.util.List.class}
 715     )
 716     public void testCertificateFactory14() throws CertificateException {
 717         if (!X509Support) {
 718             fail(NotSupportMsg);
 719             return;
 720         }
 721         CertificateFactory[] certFs = initCertFs();
 722         assertNotNull("CertificateFactory objects were not created", certFs);
 723         List<Certificate> list = null;
 724         for (int i = 0; i < certFs.length; i++) {
 725             try {
 726                 certFs[i].generateCertPath(list);
 727                 fail("generateCertificate must thrown CertificateException when list is null");
 728             } catch (NullPointerException e) {
 729             }
 730         }
 731     }
 732
 733     /**
 734      * Test for <code>generateCertPath(List certificates)</code> method
 735      * Assertion: returns empty CertPath if certificates is empty
 736      */
 737     @TestTargetNew(
 738         level = TestLevel.PARTIAL_COMPLETE,
 739         notes = "Verifies that generateCertPath method returns empty CertPath if certificates is empty. Valid parameters checking missed.",
 740         method = "generateCertPath",
 741         args = {java.util.List.class}
 742     )
 743     public void testCertificateFactory15() throws CertificateException {
 744         if (!X509Support) {
 745             fail(NotSupportMsg);
 746             return;
 747         }
 748         CertificateFactory[] certFs = initCertFs();
 749         assertNotNull("CertificateFactory objects were not created", certFs);
 750         List<Certificate> list = new Vector<Certificate>();
 751         for (int i = 0; i < certFs.length; i++) {
 752             CertPath cp = certFs[i].generateCertPath(list);
 753             List<? extends Certificate> list1 = cp.getCertificates();
 754             assertTrue("List should be empty", list1.isEmpty());
 755         }
 756     }
 757
 758     /**
 759      * Test for <code>generateCertPath(List certificates)</code> method
 760      * Assertion: throws CertificateException when certificates contains
 761      * incorrect Certificate
 762      */
 763     @TestTargetNew(
 764         level = TestLevel.PARTIAL_COMPLETE,
 765         notes = "Verifies CertificateException. Valid parameters checking missed.",
 766         method = "generateCertPath",
 767         args = {java.util.List.class}
 768     )
 769     public void testCertificateFactory16() {
 770         if (!X509Support) {
 771             fail(NotSupportMsg);
 772             return;
 773         }
 774         CertificateFactory[] certFs = initCertFs();
 775         assertNotNull("CertificateFactory objects were not created", certFs);
 776         MyCertificate ms = createMC();
 777         List<Certificate> list = new Vector<Certificate>();
 778         list.add(ms);
 779         for (int i = 0; i < certFs.length; i++) {
 780             try {
 781                 certFs[i].generateCertPath(list);
 782                 fail("CertificateException must be thrown");
 783             } catch (CertificateException e) {
 784             }
 785         }
 786     }
 787
 788     /**
 789      * Test for <code>CertificateFactory</code> constructor
 790      * Assertion: returns CertificateFactory object
 791      */
 792     @TestTargetNew(
 793         level = TestLevel.PARTIAL_COMPLETE,
 794         notes = "Verifies CRLException and NullPointerException.",
 795         method = "generateCRLs",
 796         args = {java.io.InputStream.class}
 797     )
 798     public void testCertificateFactory17() throws CRLException {
 799         if (!X509Support) {
 800             fail(NotSupportMsg);
 801             return;
 802         }
 803         CertificateFactorySpi spi = new MyCertificateFactorySpi();
 804         CertificateFactory cf = new myCertificateFactory(spi, defaultProvider,
 805                 defaultType);
 806         assertEquals("Incorrect type", cf.getType(), defaultType);
 807         assertEquals("Incorrect provider", cf.getProvider(), defaultProvider);
 808         try {
 809             cf.generateCRLs(null);
 810             fail("CRLException must be thrown");
 811         } catch (CRLException e) {
 812         }
 813
 814         cf = new myCertificateFactory(null, null, null);
 815         assertNull("Incorrect type", cf.getType());
 816         assertNull("Incorrect provider", cf.getProvider());
 817         try {
 818             cf.generateCRLs(null);
 819             fail("NullPointerException must be thrown");
 820         } catch (NullPointerException e) {
 821         }
 822     }
 823
 824     /**
 825      * Test for <code>getType()</code> method
 826      */
 827     @TestTargetNew(
 828         level = TestLevel.COMPLETE,
 829         notes = "",
 830         method = "getType",
 831         args = {}
 832     )
 833     public void testCertificateFactory18() throws CertificateException {
 834         if (!X509Support) {
 835             fail(NotSupportMsg);
 836             return;
 837         }
 838         for (int i = 0; i < validValues.length; i++) {
 839             try {
 840                 CertificateFactory certF = CertificateFactory
 841                         .getInstance(validValues[i]);
 842                 assertEquals("Incorrect type: ", validValues[i], certF
 843                         .getType());
 844                 certF = CertificateFactory.getInstance(validValues[i],
 845                         defaultProviderName);
 846                 assertEquals("Incorrect type", certF.getType(), validValues[i]);
 847
 848                 certF = CertificateFactory.getInstance(validValues[i],
 849                         defaultProvider);
 850                 assertEquals("Incorrect provider", certF.getProvider(),
 851                         defaultProvider);
 852                 assertEquals("Incorrect type", certF.getType(), validValues[i]);
 853
 854             } catch (NoSuchProviderException e) {
 855                 fail("Unexpected NoSuchProviderException " + e.getMessage());
 856             }
 857         }
 858     }
 859
 860     @SuppressWarnings("cast")
 861     @TestTargetNew(
 862         level = TestLevel.COMPLETE,
 863         notes = "",
 864         method = "CertificateFactory",
 865         args = {java.security.cert.CertificateFactorySpi.class, java.security.Provider.class, java.lang.String.class}
 866     )
 867     public void testCertificateFactory19() {
 868         if (!X509Support) {
 869             fail(NotSupportMsg);
 870             return;
 871         }
 872         CertificateFactorySpi spi = new MyCertificateFactorySpi();
 873         myCertificateFactory cf;
 874         try {
 875             cf = new myCertificateFactory(spi, defaultProvider,
 876                                       defaultType);
 877             assertEquals("Incorrect type", cf.getType(), defaultType);
 878             assertEquals("Incorrect provider", cf.getProvider(), defaultProvider);
 879             assertTrue(cf instanceof CertificateFactory);
 880         } catch (Exception e) {
 881             fail("Unexpected exception" + e);
 882         }
 883
 884         try {
 885             cf = new myCertificateFactory(null, null, null);
 886         } catch (Exception e) {
 887             fail("Unexpected exception" + e);
 888         }
 889     }
 890 }
 891 /**
 892  * Additional class to verify CertificateFactory constructor
 893  */
 894
 895 class myCertificateFactory extends CertificateFactory {
 896
 897     public myCertificateFactory(CertificateFactorySpi spi, Provider prov,
 898             String type) {
 899         super(spi, prov, type);
 900     }
 901 }