Home | History | Annotate | Download | only in ssl
      1 package tests.api.javax.net.ssl;
      2 
      3 import dalvik.annotation.TestTargetClass;
      4 import dalvik.annotation.TestTargets;
      5 import dalvik.annotation.TestLevel;
      6 import dalvik.annotation.TestTargetNew;
      7 
      8 import java.io.ByteArrayInputStream;
      9 import java.security.cert.CertificateFactory;
     10 import java.security.cert.CertificateException;
     11 import java.security.cert.X509Certificate;
     12 import javax.net.ssl.X509TrustManager;
     13 
     14 import junit.framework.TestCase;
     15 
     16 import org.apache.harmony.security.tests.support.cert.TestUtils;
     17 import org.apache.harmony.xnet.tests.support.X509TrustManagerImpl;
     18 
     19 /**
     20  * Tests for <code>X509TrustManager</code> class constructors and methods.
     21  */
     22 @TestTargetClass(X509TrustManager.class)
     23 public class X509TrustManagerTest extends TestCase {
     24 
     25     private X509Certificate[] setX509Certificate() {
     26         try {
     27             CertificateFactory certFact = CertificateFactory.getInstance("X.509");
     28             X509Certificate pemCert = (X509Certificate) certFact
     29                 .generateCertificate(new ByteArrayInputStream(TestUtils
     30                         .getX509Certificate_v3()));
     31             X509Certificate[] xcert = {pemCert};
     32             return xcert;
     33         } catch (Exception ex) {
     34             fail("Unexpected exception " + ex);
     35         }
     36         return null;
     37     }
     38 
     39     private X509Certificate[] setInvalid() {
     40         try {
     41             CertificateFactory certFact = CertificateFactory.getInstance("X.509");
     42             X509Certificate pemCert = (X509Certificate) certFact
     43                 .generateCertificate(new ByteArrayInputStream(TestUtils
     44                         .getX509Certificate_v1()));
     45             X509Certificate[] xcert = {pemCert};
     46             return xcert;
     47         } catch (Exception ex) {
     48             fail("Unexpected exception " + ex);
     49         }
     50         return null;
     51     }
     52 
     53     /**
     54      * @tests javax.net.ssl.X509TrustManager#checkClientTrusted(X509Certificate[] chain, String authType)
     55      */
     56     @TestTargetNew(
     57         level = TestLevel.PARTIAL_COMPLETE,
     58         notes = "",
     59         method = "checkClientTrusted",
     60         args = {java.security.cert.X509Certificate[].class, java.lang.String.class}
     61     )
     62     public void test_checkClientTrusted_01() {
     63         X509TrustManagerImpl xtm = new X509TrustManagerImpl();
     64         X509Certificate[] xcert = null;
     65 
     66         try {
     67             xtm.checkClientTrusted(xcert, "SSL");
     68             fail("IllegalArgumentException wasn't thrown");
     69         } catch (IllegalArgumentException iae) {
     70             //expected
     71         } catch (Exception e) {
     72             fail(e + " was thrown instead of IllegalArgumentException");
     73         }
     74 
     75         xcert = new X509Certificate[0];
     76         try {
     77             xtm.checkClientTrusted(xcert, "SSL");
     78             fail("IllegalArgumentException wasn't thrown");
     79         } catch (IllegalArgumentException iae) {
     80             //expected
     81         } catch (Exception e) {
     82             fail(e + " was thrown instead of IllegalArgumentException");
     83         }
     84 
     85         xcert = setX509Certificate();
     86         try {
     87             xtm.checkClientTrusted(xcert, null);
     88             fail("IllegalArgumentException wasn't thrown");
     89         } catch (IllegalArgumentException iae) {
     90             //expected
     91         } catch (Exception e) {
     92             fail(e + " was thrown instead of IllegalArgumentException");
     93         }
     94 
     95         try {
     96             xtm.checkClientTrusted(xcert, "");
     97             fail("IllegalArgumentException wasn't thrown");
     98         } catch (IllegalArgumentException iae) {
     99             //expected
    100         } catch (Exception e) {
    101             fail(e + " was thrown instead of IllegalArgumentException");
    102         }
    103     }
    104 
    105     /**
    106      * @tests javax.net.ssl.X509TrustManager#checkClientTrusted(X509Certificate[] chain, String authType)
    107      */
    108     @TestTargetNew(
    109         level = TestLevel.PARTIAL_COMPLETE,
    110         notes = "",
    111         method = "checkClientTrusted",
    112         args = {java.security.cert.X509Certificate[].class, java.lang.String.class}
    113     )
    114     public void test_checkClientTrusted_02() {
    115         X509TrustManagerImpl xtm = new X509TrustManagerImpl();
    116         X509Certificate[] xcert = setInvalid();
    117 
    118         try {
    119             xtm.checkClientTrusted(xcert, "SSL");
    120             fail("CertificateException wasn't thrown");
    121         } catch (CertificateException ce) {
    122             //expected
    123         }
    124     }
    125 
    126     /**
    127      * @tests javax.net.ssl.X509TrustManager#checkClientTrusted(X509Certificate[] chain, String authType)
    128      */
    129     @TestTargetNew(
    130         level = TestLevel.PARTIAL_COMPLETE,
    131         notes = "",
    132         method = "checkClientTrusted",
    133         args = {java.security.cert.X509Certificate[].class, java.lang.String.class}
    134     )
    135     public void test_checkClientTrusted_03() {
    136         X509TrustManagerImpl xtm = new X509TrustManagerImpl();
    137         X509Certificate[] xcert = setX509Certificate();
    138 
    139         try {
    140             xtm.checkClientTrusted(xcert, "SSL");
    141         } catch (Exception ex) {
    142             fail("Unexpected exception " + ex);
    143         }
    144     }
    145 
    146     /**
    147      * @tests javax.net.ssl.X509TrustManager#checkServerTrusted(X509Certificate[] chain, String authType)
    148      */
    149     @TestTargetNew(
    150         level = TestLevel.PARTIAL_COMPLETE,
    151         notes = "",
    152         method = "checkServerTrusted",
    153         args = {java.security.cert.X509Certificate[].class, java.lang.String.class}
    154     )
    155     public void test_checkServerTrusted_01() {
    156         X509TrustManagerImpl xtm = new X509TrustManagerImpl();
    157         X509Certificate[] xcert = null;
    158 
    159         try {
    160             xtm.checkServerTrusted(xcert, "SSL");
    161             fail("IllegalArgumentException wasn't thrown");
    162         } catch (IllegalArgumentException iae) {
    163             //expected
    164         } catch (Exception e) {
    165             fail(e + " was thrown instead of IllegalArgumentException");
    166         }
    167 
    168         xcert = new X509Certificate[0];
    169         try {
    170             xtm.checkServerTrusted(xcert, "SSL");
    171             fail("IllegalArgumentException wasn't thrown");
    172         } catch (IllegalArgumentException iae) {
    173             //expected
    174         } catch (Exception e) {
    175             fail(e + " was thrown instead of IllegalArgumentException");
    176         }
    177 
    178         xcert = setX509Certificate();
    179         try {
    180             xtm.checkServerTrusted(xcert, null);
    181             fail("IllegalArgumentException wasn't thrown");
    182         } catch (IllegalArgumentException iae) {
    183             //expected
    184         } catch (Exception e) {
    185             fail(e + " was thrown instead of IllegalArgumentException");
    186         }
    187 
    188         try {
    189             xtm.checkServerTrusted(xcert, "");
    190             fail("IllegalArgumentException wasn't thrown");
    191         } catch (IllegalArgumentException iae) {
    192             //expected
    193         } catch (Exception e) {
    194             fail(e + " was thrown instead of IllegalArgumentException");
    195         }
    196     }
    197 
    198     /**
    199      * @tests javax.net.ssl.X509TrustManager#checkServerTrusted(X509Certificate[] chain, String authType)
    200      */
    201     @TestTargetNew(
    202         level = TestLevel.PARTIAL_COMPLETE,
    203         notes = "",
    204         method = "checkServerTrusted",
    205         args = {java.security.cert.X509Certificate[].class, java.lang.String.class}
    206     )
    207     public void test_checkServerTrusted_02() {
    208         X509TrustManagerImpl xtm = new X509TrustManagerImpl();
    209         X509Certificate[] xcert = setInvalid();
    210 
    211         try {
    212             xtm.checkServerTrusted(xcert, "SSL");
    213             fail("CertificateException wasn't thrown");
    214         } catch (CertificateException ce) {
    215             //expected
    216         }
    217     }
    218 
    219     /**
    220      * @tests javax.net.ssl.X509TrustManager#checkServerTrusted(X509Certificate[] chain, String authType)
    221      */
    222     @TestTargetNew(
    223         level = TestLevel.PARTIAL_COMPLETE,
    224         notes = "",
    225         method = "checkServerTrusted",
    226         args = {java.security.cert.X509Certificate[].class, java.lang.String.class}
    227     )
    228     public void test_checkServerTrusted_03() {
    229         X509TrustManagerImpl xtm = new X509TrustManagerImpl();
    230         X509Certificate[] xcert = setX509Certificate();
    231 
    232         try {
    233             xtm.checkServerTrusted(xcert, "SSL");
    234         } catch (Exception ex) {
    235             fail("Unexpected exception " + ex);
    236         }
    237     }
    238 
    239     /**
    240      * @tests javax.net.ssl.X509TrustManager#getAcceptedIssuers()
    241      */
    242     @TestTargetNew(
    243         level = TestLevel.COMPLETE,
    244         notes = "",
    245         method = "getAcceptedIssuers",
    246         args = {}
    247     )
    248     public void test_getAcceptedIssuers() {
    249         X509TrustManagerImpl xtm = new X509TrustManagerImpl();
    250 
    251         try {
    252             assertNotNull(xtm.getAcceptedIssuers());
    253         } catch (Exception ex) {
    254             fail("Unexpected exception " + ex);
    255         }
    256     }
    257 
    258 }
    259