/*
* 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 Vera Y. Petrashkova
* @version $Revision$
*/
package tests.security.cert;
import junit.framework.TestCase;
import org.apache.harmony.security.tests.support.SpiEngUtils;
import org.apache.harmony.security.tests.support.cert.MyCertPath;
import org.apache.harmony.security.tests.support.cert.MyCertificate;
import org.apache.harmony.security.tests.support.cert.MyCertificateFactorySpi;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectOutputStream;
import java.security.NoSuchProviderException;
import java.security.Provider;
import java.security.cert.CRL;
import java.security.cert.CRLException;
import java.security.cert.CertPath;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.CertificateFactorySpi;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
/**
* Tests for <code>CertificateFactory</code> class methods and constructor
*
*/
public class CertificateFactory1Test extends TestCase {
public static final String srvCertificateFactory = "CertificateFactory";
private static String defaultProviderName = null;
private static Provider defaultProvider = null;
private static boolean X509Support = false;
public static String defaultType = "X.509";
public static final String[] validValues = {
"X.509", "x.509" };
private final static String[] invalidValues = SpiEngUtils.invalidValues;
private static String NotSupportMsg = "";
static {
defaultProvider = SpiEngUtils.isSupport(defaultType,
srvCertificateFactory);
X509Support = (defaultProvider != null);
defaultProviderName = (X509Support ? defaultProvider.getName() : null);
NotSupportMsg = defaultType.concat(" is not supported"); }
private static CertificateFactory[] initCertFs() {
if (!X509Support) {
fail(NotSupportMsg);
return null;
}
try {
CertificateFactory[] certFs = new CertificateFactory[3];
certFs[0] = CertificateFactory.getInstance(defaultType);
certFs[1] = CertificateFactory.getInstance(defaultType,
defaultProviderName);
certFs[2] = CertificateFactory.getInstance(defaultType,
defaultProvider);
return certFs;
} catch (Exception e) {
return null;
}
}
private static MyCertificate createMC() {
byte[] enc = { (byte) 0, (byte) 2, (byte) 3, (byte) 4, (byte) 5 };
return new MyCertificate("Test_Test", enc);
}
/**
* Test for <code>getInstance(String type)</code> method
* Assertion: returns CertificateFactory if type is X.509
*/
public void testCertificateFactory01() throws CertificateException {
if (!X509Support) {
fail(NotSupportMsg);
return;
}
for (int i = 0; i < validValues.length; i++) {
CertificateFactory certF = CertificateFactory
.getInstance(validValues[i]);
assertEquals("Incorrect type: ", validValues[i], certF.getType());
}
}
/**
* Test for <code>getInstance(String type)</code> method
* Assertion:
* throws NullPointerException when type is null
* throws CertificateException when type is not available
*/
public void testCertificateFactory02() {
try {
CertificateFactory.getInstance(null);
fail("NullPointerException or CertificateException must be thrown when type is null");
} catch (CertificateException e) {
} catch (NullPointerException e) {
}
for (int i = 0; i < invalidValues.length; i++) {
try {
CertificateFactory.getInstance(invalidValues[i]);
fail("CertificateException must be thrown when type: "
.concat(invalidValues[i]));
} catch (CertificateException e) {
}
}
}
/**
* Test for <code>getInstance(String type, String provider)</code> method
* Assertion: throws IllegalArgumentException when provider is null or empty
*/
public void testCertificateFactory03() throws CertificateException,
NoSuchProviderException {
if (!X509Support) {
fail(NotSupportMsg);
return;
}
String provider = null;
for (int i = 0; i < validValues.length; i++) {
try {
CertificateFactory.getInstance(validValues[i], provider);
fail("IllegalArgumentException must be thrown when provider is null");
} catch (IllegalArgumentException e) {
}
try {
CertificateFactory.getInstance(validValues[i], "");
fail("IllegalArgumentException must be thrown when provider is empty");
} catch (IllegalArgumentException e) {
}
}
}
/**
* Test for <code>getInstance(String type, String provider)</code> method
* Assertion:
* throws NullPointerException when type is null
* throws CertificateException when type is not available
*/
public void testCertificateFactory04() throws NoSuchProviderException {
if (!X509Support) {
fail(NotSupportMsg);
return;
}
try {
CertificateFactory.getInstance(null, defaultProviderName);
fail("NullPointerException or CertificateException must be thrown when type is null");
} catch (CertificateException e) {
} catch (NullPointerException e) {
}
for (int i = 0; i < invalidValues.length; i++) {
try {
CertificateFactory.getInstance(invalidValues[i],
defaultProviderName);
fail("CertificateException must be thrown (type: ".concat(
invalidValues[i]).concat(" provider: ").concat(
defaultProviderName).concat(")"));
} catch (CertificateException e) {
}
}
}
/**
* Test for <code>getInstance(String type, String provider)</code> method
* Assertion: returns CertificateFactory when type and provider have valid
* values
*/
public void testCertificateFactory05() throws CertificateException,
NoSuchProviderException {
if (!X509Support) {
fail(NotSupportMsg);
return;
}
CertificateFactory certF;
for (int i = 0; i < validValues.length; i++) {
certF = CertificateFactory.getInstance(validValues[i],
defaultProviderName);
assertEquals("Incorrect type", certF.getType(), validValues[i]);
assertEquals("Incorrect provider name", certF.getProvider()
.getName(), defaultProviderName);
}
}
/**
* Test for <code>getInstance(String type, Provider provider)</code>
* method
* Assertion: throws IllegalArgumentException when provider is null
*/
public void testCertificateFactory06() throws CertificateException {
if (!X509Support) {
fail(NotSupportMsg);
return;
}
Provider provider = null;
for (int i = 0; i < validValues.length; i++) {
try {
CertificateFactory.getInstance(validValues[i], provider);
fail("IllegalArgumentException must be thrown when provider is null");
} catch (IllegalArgumentException e) {
}
}
}
/**
* Test for <code>getInstance(String type, Provider provider)</code>
* method
* Assertion:
* throws NullPointerException when type is null
* throws CertificateException when type is not available
*/
public void testCertificateFactory07() {
if (!X509Support) {
fail(NotSupportMsg);
return;
}
try {
CertificateFactory.getInstance(null, defaultProvider);
fail("NullPointerException or CertificateException must be thrown when type is null");
} catch (CertificateException e) {
} catch (NullPointerException e) {
}
for (int i = 0; i < invalidValues.length; i++) {
try {
CertificateFactory.getInstance(invalidValues[i],
defaultProvider);
fail("CertificateException was not thrown as expected (type:"
.concat(invalidValues[i]).concat(" provider: ").concat(
defaultProvider.getName()).concat(")"));
} catch (CertificateException e) {
}
}
}
/**
* Test for <code>getInstance(String type, Provider provider)</code>
* method
* Assertion: returns CertificateFactorythrows when type and provider
* have valid values
*/
public void testCertificateFactory08() throws CertificateException {
if (!X509Support) {
fail(NotSupportMsg);
return;
}
CertificateFactory certF;
for (int i = 0; i < validValues.length; i++) {
certF = CertificateFactory.getInstance(validValues[i],
defaultProvider);
assertEquals("Incorrect provider", certF.getProvider(),
defaultProvider);
assertEquals("Incorrect type", certF.getType(), validValues[i]);
}
}
/**
* Test for <code>getCertPathEncodings()</code> method
* Assertion: returns encodings
*/
public void testCertificateFactory09() {
if (!X509Support) {
fail(NotSupportMsg);
return;
}
CertificateFactory[] certFs = initCertFs();
assertNotNull("CertificateFactory objects were not created", certFs);
Iterator<String> it1 = certFs[0].getCertPathEncodings();
Iterator<String> it2 = certFs[1].getCertPathEncodings();
assertEquals("Incorrect encodings", it1.hasNext(), it2.hasNext());
while (it1.hasNext()) {
it2 = certFs[1].getCertPathEncodings();
String s1 = it1.next();
boolean yesNo = false;
while (it2.hasNext()) {
if (s1.equals(it2.next())) {
yesNo = true;
break;
}
}
assertTrue("Encoding: ".concat(s1).concat(
" does not define for certF2 CertificateFactory"), yesNo);
}
it1 = certFs[0].getCertPathEncodings();
it2 = certFs[2].getCertPathEncodings();
assertEquals("Incorrect encodings", it1.hasNext(), it2.hasNext());
while (it1.hasNext()) {
it2 = certFs[2].getCertPathEncodings();
String s1 = it1.next();
boolean yesNo = false;
while (it2.hasNext()) {
if (s1.equals(it2.next())) {
yesNo = true;
break;
}
}
assertTrue("Encoding: ".concat(s1).concat(
" does not define for certF3 CertificateFactory"), yesNo);
}
}
/**
* Test for <code>generateCertificate(InputStream inStream)</code>
* <code>generateCertificates(InputStream inStream)</code>
* <code>generateCRL(InputStream inStream)</code>
* <code>generateCRLs(InputStream inStream)</code>
* methods
* Assertion: throw CertificateException and CRLException when
* inStream is null or empty
*/
public void testCertificateFactory10() {
if (!X509Support) {
fail(NotSupportMsg);
return;
}
CertificateFactory[] certFs = initCertFs();
assertNotNull("CertificateFactory objects were not created", certFs);
byte [] bb = {};
InputStream is = new ByteArrayInputStream(bb);
Collection<?> colCer;
Collection<?> colCrl;
for (int i = 0; i < certFs.length; i++) {
try {
certFs[i].generateCertificate(null);
fail("generateCertificate must thrown CertificateException or NullPointerEXception when input stream is null");
} catch (CertificateException e) {
} catch (NullPointerException e) {
}
is = new ByteArrayInputStream(bb);
try {
certFs[i].generateCertificates(null);
fail("generateCertificates must throw CertificateException or NullPointerException when input stream is null");
} catch (CertificateException e) {
} catch (NullPointerException e) {
}
is = new ByteArrayInputStream(bb);
try {
certFs[i].generateCertificate(is);
} catch (CertificateException e) {
}
is = new ByteArrayInputStream(bb);
try {
colCer = certFs[i].generateCertificates(is);
if (colCer != null) {
assertTrue("Not empty certificate collection", colCer.isEmpty());
}
} catch (CertificateException e) {
}
}
for (int i = 0; i < certFs.length; i++) {
try {
certFs[i].generateCRL(null);
} catch (CRLException e) {
} catch (NullPointerException e) {
}
try {
colCrl = certFs[i].generateCRLs(null);
if (colCrl != null) {
assertTrue("Not empty CRL collection was returned from null stream", colCrl.isEmpty());
}
} catch (CRLException e) {
} catch (NullPointerException e) {
}
is = new ByteArrayInputStream(bb);
try {
certFs[i].generateCRL(is);
} catch (CRLException e) {
}
is = new ByteArrayInputStream(bb);
try {
certFs[i].generateCRLs(is);
colCrl = certFs[i].generateCRLs(null);
if (colCrl != null) {
assertTrue("Not empty CRL collection was returned from empty stream", colCrl.isEmpty());
}
} catch (CRLException e) {
}
}
}
/*
* Test for <code> generateCertificate(InputStream inStream) </code><code>
* generateCertificates(InputStream inStream) </code><code>
* generateCRL(InputStream inStream) </code><code>
* generateCRLs(InputStream inStream) </code>
* methods
* Assertion: throw CertificateException and CRLException when inStream
* contains incompatible datas
*/
public void testCertificateFactory11() throws IOException {
if (!X509Support) {
fail(NotSupportMsg);
return;
}
CertificateFactory[] certFs = initCertFs();
assertNotNull("CertificateFactory objects were not created", certFs);
MyCertificate mc = createMC();
ByteArrayOutputStream os = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeObject(mc);
oos.flush();
oos.close();
Certificate cer;
Collection<?> colCer;
CRL crl;
Collection<?> colCrl;
byte[] arr = os.toByteArray();
ByteArrayInputStream is;
for (int i = 0; i < certFs.length; i++) {
is = new ByteArrayInputStream(arr);
try {
cer = certFs[i].generateCertificate(is);
assertNull("Not null certificate was created", cer);
} catch (CertificateException e) {
}
is = new ByteArrayInputStream(arr);
try {
colCer = certFs[i].generateCertificates(is);
if (colCer != null) {
assertTrue("Not empty certificate Collection was created", colCer.isEmpty());
}
} catch (CertificateException e) {
}
is = new ByteArrayInputStream(arr);
try {
crl = certFs[i].generateCRL(is);
assertNull("Not null CRL was created", crl);
} catch (CRLException e) {
}
is = new ByteArrayInputStream(arr);
try {
colCrl = certFs[i].generateCRLs(is);
if (colCrl != null) {
assertTrue("Not empty CRL Collection was created", colCrl.isEmpty());
}
} catch (CRLException e) {
}
}
}
/**
* Test for <code>generateCertPath(InputStream inStream)</code>
* <code>generateCertPath(InputStream inStream, String encoding)</code>
* methods
* Assertion: throws CertificateException when inStream is null or
* when isStream contains invalid datas
*/
public void testCertificateFactory12() {
if (!X509Support) {
fail(NotSupportMsg);
return;
}
CertificateFactory[] certFs = initCertFs();
assertNotNull("CertificateFactory objects were not created", certFs);
InputStream is1 = null;
InputStream is2 = new ByteArrayInputStream(new byte[10]);
for (int i = 0; i < certFs.length; i++) {
try {
certFs[i].generateCertPath(is1);
fail("generateCertificate must thrown CertificateException or NullPointerException when input stream is null");
} catch (CertificateException e) {
} catch (NullPointerException e) {
}
try {
certFs[i].generateCertPath(is2);
fail("generateCertificate must thrown CertificateException when input stream contains invalid datas");
} catch (CertificateException e) {
}
Iterator<String> it = certFs[i].getCertPathEncodings();
while (it.hasNext()) {
String enc = it.next();
try {
certFs[i].generateCertPath(is1, enc);
fail("generateCertificate must thrown CertificateException or NullPointerException when input stream is null and encodings "
.concat(enc));
} catch (CertificateException e) {
} catch (NullPointerException e) {
}
try {
certFs[i].generateCertPath(is2, enc);
fail("generateCertificate must thrown CertificateException when input stream contains invalid datas and encodings "
.concat(enc));
} catch (CertificateException e) {
}
}
}
}
/**
* Test for <code>generateCertPath(InputStream inStream)</code>
* <code>generateCertPath(InputStream inStream, String encoding)</code>
* methods
* Assertion: throw CertificateException when isStream contains invalid datas
*/
// Test passed on RI
public void testCertificateFactory13() throws IOException {
if (!X509Support) {
fail(NotSupportMsg);
return;
}
CertificateFactory[] certFs = initCertFs();
assertNotNull("CertificateFactory objects were not created", certFs);
byte[] enc = { (byte) 0, (byte) 2, (byte) 3, (byte) 4, (byte) 5 };
MyCertPath mc = new MyCertPath(enc);
ByteArrayOutputStream os = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeObject(mc);
oos.flush();
oos.close();
byte[] arr = os.toByteArray();
ByteArrayInputStream is = new ByteArrayInputStream(arr);
for (int i = 0; i < certFs.length; i++) {
try {
certFs[i].generateCertPath(is);
fail("CertificateException must be thrown because input stream contains incorrect datas");
} catch (CertificateException e) {
}
Iterator<String> it = certFs[i].getCertPathEncodings();
while (it.hasNext()) {
try {
certFs[i].generateCertPath(is, it.next());
fail("CertificateException must be thrown because input stream contains incorrect datas");
} catch (CertificateException e) {
}
}
}
}
/**
* Test for <code>generateCertPath(List certificates)</code> method
* Assertion: throw NullPointerException certificates is null
*/
public void testCertificateFactory14() throws CertificateException {
if (!X509Support) {
fail(NotSupportMsg);
return;
}
CertificateFactory[] certFs = initCertFs();
assertNotNull("CertificateFactory objects were not created", certFs);
List<Certificate> list = null;
for (int i = 0; i < certFs.length; i++) {
try {
certFs[i].generateCertPath(list);
fail("generateCertificate must thrown CertificateException when list is null");
} catch (NullPointerException e) {
}
}
}
/**
* Test for <code>generateCertPath(List certificates)</code> method
* Assertion: returns empty CertPath if certificates is empty
*/
public void testCertificateFactory15() throws CertificateException {
if (!X509Support) {
fail(NotSupportMsg);
return;
}
CertificateFactory[] certFs = initCertFs();
assertNotNull("CertificateFactory objects were not created", certFs);
List<Certificate> list = new Vector<Certificate>();
for (int i = 0; i < certFs.length; i++) {
CertPath cp = certFs[i].generateCertPath(list);
List<? extends Certificate> list1 = cp.getCertificates();
assertTrue("List should be empty", list1.isEmpty());
}
}
/**
* Test for <code>generateCertPath(List certificates)</code> method
* Assertion: throws CertificateException when certificates contains
* incorrect Certificate
*/
public void testCertificateFactory16() {
if (!X509Support) {
fail(NotSupportMsg);
return;
}
CertificateFactory[] certFs = initCertFs();
assertNotNull("CertificateFactory objects were not created", certFs);
MyCertificate ms = createMC();
List<Certificate> list = new Vector<Certificate>();
list.add(ms);
for (int i = 0; i < certFs.length; i++) {
try {
certFs[i].generateCertPath(list);
fail("CertificateException must be thrown");
} catch (CertificateException e) {
}
}
}
/**
* Test for <code>CertificateFactory</code> constructor
* Assertion: returns CertificateFactory object
*/
public void testCertificateFactory17() throws CRLException {
if (!X509Support) {
fail(NotSupportMsg);
return;
}
CertificateFactorySpi spi = new MyCertificateFactorySpi();
CertificateFactory cf = new myCertificateFactory(spi, defaultProvider,
defaultType);
assertEquals("Incorrect type", cf.getType(), defaultType);
assertEquals("Incorrect provider", cf.getProvider(), defaultProvider);
try {
cf.generateCRLs(null);
fail("CRLException must be thrown");
} catch (CRLException e) {
}
cf = new myCertificateFactory(null, null, null);
assertNull("Incorrect type", cf.getType());
assertNull("Incorrect provider", cf.getProvider());
try {
cf.generateCRLs(null);
fail("NullPointerException must be thrown");
} catch (NullPointerException e) {
}
}
/**
* Test for <code>getType()</code> method
*/
public void testCertificateFactory18() throws CertificateException {
if (!X509Support) {
fail(NotSupportMsg);
return;
}
for (int i = 0; i < validValues.length; i++) {
try {
CertificateFactory certF = CertificateFactory
.getInstance(validValues[i]);
assertEquals("Incorrect type: ", validValues[i], certF
.getType());
certF = CertificateFactory.getInstance(validValues[i],
defaultProviderName);
assertEquals("Incorrect type", certF.getType(), validValues[i]);
certF = CertificateFactory.getInstance(validValues[i],
defaultProvider);
assertEquals("Incorrect provider", certF.getProvider(),
defaultProvider);
assertEquals("Incorrect type", certF.getType(), validValues[i]);
} catch (NoSuchProviderException e) {
fail("Unexpected NoSuchProviderException " + e.getMessage());
}
}
}
@SuppressWarnings("cast")
public void testCertificateFactory19() {
if (!X509Support) {
fail(NotSupportMsg);
return;
}
CertificateFactorySpi spi = new MyCertificateFactorySpi();
myCertificateFactory cf;
try {
cf = new myCertificateFactory(spi, defaultProvider,
defaultType);
assertEquals("Incorrect type", cf.getType(), defaultType);
assertEquals("Incorrect provider", cf.getProvider(), defaultProvider);
assertTrue(cf instanceof CertificateFactory);
} catch (Exception e) {
fail("Unexpected exception" + e);
}
try {
cf = new myCertificateFactory(null, null, null);
} catch (Exception e) {
fail("Unexpected exception" + e);
}
}
}
/**
* Additional class to verify CertificateFactory constructor
*/
class myCertificateFactory extends CertificateFactory {
public myCertificateFactory(CertificateFactorySpi spi, Provider prov,
String type) {
super(spi, prov, type);
}
}