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}