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
18package org.apache.harmony.xnet.tests.javax.net.ssl;
19
20import java.security.InvalidAlgorithmParameterException;
21import java.security.KeyStore;
22import java.security.KeyStoreException;
23import java.security.NoSuchAlgorithmException;
24import java.security.NoSuchProviderException;
25import java.security.Provider;
26import java.security.Security;
27
28import javax.net.ssl.ManagerFactoryParameters;
29import javax.net.ssl.TrustManagerFactory;
30
31import org.apache.harmony.xnet.tests.support.SpiEngUtils;
32import org.apache.harmony.xnet.tests.support.MyTrustManagerFactorySpi;
33import junit.framework.TestCase;
34
35/**
36 * Tests for TrustManagerFactory class constructors and methods
37 *
38 */
39
40public class TrustManagerFactory2Test extends TestCase {
41    private static final String srvTrustManagerFactory = "TrustManagerFactory";
42    private static final String defaultAlg = "TMF";
43    private static final String TrustManagerFactoryProviderClass = "org.apache.harmony.xnet.tests.support.MyTrustManagerFactorySpi";
44
45    private static final String[] invalidValues = SpiEngUtils.invalidValues;
46
47    private static final String[] validValues;
48
49    static {
50        validValues = new String[4];
51        validValues[0] = defaultAlg;
52        validValues[1] = defaultAlg.toLowerCase();
53        validValues[2] = "Tmf";
54        validValues[3] = "tMF";
55    }
56
57    Provider mProv;
58
59    @Override
60    protected void setUp() throws Exception {
61        super.setUp();
62        mProv = (new SpiEngUtils()).new MyProvider("MyTMFProvider",
63                "Provider for testing", srvTrustManagerFactory.concat(".")
64                        .concat(defaultAlg), TrustManagerFactoryProviderClass);
65        Security.insertProviderAt(mProv, 1);
66    }
67
68    /*
69     * @see TestCase#tearDown()
70     */
71    @Override
72    protected void tearDown() throws Exception {
73        super.tearDown();
74        Security.removeProvider(mProv.getName());
75    }
76
77    private void checkResult(TrustManagerFactory tmf) throws Exception {
78        KeyStore kStore = null;
79        ManagerFactoryParameters mfp = null;
80
81        try {
82            tmf.init(kStore);
83            fail("KeyStoreException must be thrown");
84        } catch (KeyStoreException e) {
85        }
86        try {
87            tmf.init(mfp);
88            fail("InvalidAlgorithmParameterException must be thrown");
89        } catch (InvalidAlgorithmParameterException e) {
90        }
91        assertNull("getTrustManagers() should return null object", tmf
92                .getTrustManagers());
93
94        try {
95            kStore = KeyStore.getInstance(KeyStore.getDefaultType());
96            kStore.load(null, null);
97        } catch (KeyStoreException e) {
98            fail("default keystore is not supported");
99            return;
100        }
101        tmf.init(kStore);
102        mfp = (ManagerFactoryParameters) new MyTrustManagerFactorySpi.Parameters(null);
103        try {
104            tmf.init(mfp);
105            fail("RuntimeException must be thrown");
106        } catch (RuntimeException e) {
107            assertTrue("Incorrect exception", e.getCause() instanceof KeyStoreException);
108        }
109        mfp = (ManagerFactoryParameters) new MyTrustManagerFactorySpi.Parameters(kStore);
110        tmf.init(mfp);
111    }
112
113    /**
114     * Test for <code>getInstance(String algorithm)</code> method
115     * Assertions:
116     * throws NullPointerException when algorithm is null;
117     * throws NoSuchAlgorithmException when algorithm is not correct;
118     * returns TrustManagerFactory object
119     */
120    public void testGetInstance01() throws Exception {
121        try {
122            TrustManagerFactory.getInstance(null);
123            fail("NoSuchAlgorithmException or NullPointerException should be thrown (algorithm is null");
124        } catch (NoSuchAlgorithmException e) {
125        } catch (NullPointerException e) {
126        }
127        for (int i = 0; i < invalidValues.length; i++) {
128            try {
129                TrustManagerFactory.getInstance(invalidValues[i]);
130                fail("NoSuchAlgorithmException must be thrown (algorithm: "
131                        .concat(invalidValues[i]).concat(")"));
132            } catch (NoSuchAlgorithmException e) {
133            }
134        }
135        TrustManagerFactory tmf;
136        for (int i = 0; i < validValues.length; i++) {
137            tmf = TrustManagerFactory.getInstance(validValues[i]);
138            assertTrue("Not instanceof TrustManagerFactory object",
139                    tmf instanceof TrustManagerFactory);
140            assertEquals("Incorrect algorithm", tmf.getAlgorithm(),
141                    validValues[i]);
142            assertEquals("Incorrect provider", tmf.getProvider(), mProv);
143            checkResult(tmf);
144        }
145    }
146
147    /**
148     * Test for <code>getInstance(String algorithm, String provider)</code>
149     * method
150     * Assertions:
151     * throws NullPointerException when algorithm is null;
152     * throws NoSuchAlgorithmException when algorithm is not correct;
153     * throws IllegalArgumentException when provider is null or empty;
154     * throws NoSuchProviderException when provider is available;
155     * returns TrustManagerFactory object
156     */
157    public void testGetInstance02() throws Exception {
158        try {
159            TrustManagerFactory.getInstance(null, mProv.getName());
160            fail("NoSuchAlgorithmException or NullPointerException should be thrown (algorithm is null");
161        } catch (NoSuchAlgorithmException e) {
162        } catch (NullPointerException e) {
163        }
164        for (int i = 0; i < invalidValues.length; i++) {
165            try {
166                TrustManagerFactory.getInstance(invalidValues[i], mProv
167                        .getName());
168                fail("NoSuchAlgorithmException must be thrown (algorithm: "
169                        .concat(invalidValues[i]).concat(")"));
170            } catch (NoSuchAlgorithmException e) {
171            }
172        }
173        String prov = null;
174        for (int i = 0; i < validValues.length; i++) {
175            try {
176                TrustManagerFactory.getInstance(validValues[i], prov);
177                fail("IllegalArgumentException must be thrown when provider is null (algorithm: "
178                        .concat(invalidValues[i]).concat(")"));
179            } catch (IllegalArgumentException e) {
180            }
181            try {
182                TrustManagerFactory.getInstance(validValues[i], "");
183                fail("IllegalArgumentException must be thrown when provider is empty (algorithm: "
184                        .concat(invalidValues[i]).concat(")"));
185            } catch (IllegalArgumentException e) {
186            }
187        }
188        for (int i = 0; i < validValues.length; i++) {
189            for (int j = 1; j < invalidValues.length; j++) {
190                try {
191                    TrustManagerFactory.getInstance(validValues[i],
192                            invalidValues[j]);
193                    fail("NoSuchProviderException must be thrown (algorithm: "
194                            .concat(invalidValues[i]).concat(" provider: ")
195                            .concat(invalidValues[j]).concat(")"));
196                } catch (NoSuchProviderException e) {
197                }
198            }
199        }
200        TrustManagerFactory tmf;
201        for (int i = 0; i < validValues.length; i++) {
202            tmf = TrustManagerFactory.getInstance(validValues[i], mProv
203                    .getName());
204            assertTrue("Not instanceof TrustManagerFactory object",
205                    tmf instanceof TrustManagerFactory);
206            assertEquals("Incorrect algorithm", tmf.getAlgorithm(),
207                    validValues[i]);
208            assertEquals("Incorrect provider", tmf.getProvider().getName(),
209                    mProv.getName());
210            checkResult(tmf);
211        }
212    }
213
214    /**
215     * Test for <code>getInstance(String algorithm, Provider provider)</code>
216     * method
217     * Assertions:
218     * throws NullPointerException when algorithm is null;
219     * throws NoSuchAlgorithmException when algorithm is not correct;
220     * throws IllegalArgumentException when provider is null;
221     * returns TrustManagerFactory object
222     */
223    public void testGetInstance03() throws Exception {
224        try {
225            TrustManagerFactory.getInstance(null, mProv);
226            fail("NoSuchAlgorithmException or NullPointerException should be thrown (algorithm is null");
227        } catch (NoSuchAlgorithmException e) {
228        } catch (NullPointerException e) {
229        }
230        for (int i = 0; i < invalidValues.length; i++) {
231            try {
232                TrustManagerFactory.getInstance(invalidValues[i], mProv);
233                fail("NoSuchAlgorithmException must be thrown (algorithm: "
234                        .concat(invalidValues[i]).concat(")"));
235            } catch (NoSuchAlgorithmException e) {
236            }
237        }
238        Provider prov = null;
239        for (int i = 0; i < validValues.length; i++) {
240            try {
241                TrustManagerFactory.getInstance(validValues[i], prov);
242                fail("IllegalArgumentException must be thrown when provider is null (algorithm: "
243                        .concat(invalidValues[i]).concat(")"));
244            } catch (IllegalArgumentException e) {
245            }
246        }
247        TrustManagerFactory tmf;
248        for (int i = 0; i < validValues.length; i++) {
249            tmf = TrustManagerFactory.getInstance(validValues[i], mProv);
250            assertTrue("Not instanceof TrustManagerFactory object",
251                    tmf instanceof TrustManagerFactory);
252            assertEquals("Incorrect algorithm", tmf.getAlgorithm(),
253                    validValues[i]);
254            assertEquals("Incorrect provider", tmf.getProvider(), mProv);
255            checkResult(tmf);
256        }
257    }
258}