001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017:
018: /**
019: * @author Boris V. Kuznetsov
020: * @version $Revision$
021: */package org.apache.harmony.security.tests.java.security;
022:
023: import java.security.InvalidParameterException;
024: import java.security.KeyFactory;
025: import java.security.MessageDigest;
026: import java.security.NoSuchAlgorithmException;
027: import java.security.Provider;
028: import java.security.Security;
029: import java.security.Signature;
030: import java.util.Arrays;
031: import java.util.HashMap;
032: import java.util.Map;
033:
034: import junit.framework.TestCase;
035:
036: import org.apache.harmony.security.tests.support.TestKeyPair;
037:
038: /**
039: * Tests for <code>Security</code> constructor and methods
040: */
041: public class SecurityTest extends TestCase {
042:
043: public final void testMixed() {
044:
045: TestKeyPair tkp = null;
046: try {
047: tkp = new TestKeyPair("DSA");
048: } catch (NoSuchAlgorithmException e1) {
049: e1.printStackTrace();
050: return;
051: }
052:
053: try {
054: MessageDigest.getInstance("SHA-1");
055: KeyFactory.getInstance("DSA");
056: Signature ss = Signature.getInstance("DSA");
057: ss.initSign(tkp.getPrivate());
058: Signature.getInstance("aaaaaaaaaaaa");
059: } catch (Exception e) {
060: // ignore
061: }
062:
063: }
064:
065: /**
066: * @tests java.security.Security#insertProviderAt(Provider, int)
067: */
068: public final void test_insertProviderAtLjava_security_ProviderLI() {
069:
070: try {
071: Security.insertProviderAt(null, 1);
072: fail("No expected NullPointerException");
073: } catch (NullPointerException e) {
074: }
075:
076: Provider p = new MyProvider();
077: int initNum = Security.getProviders().length; // initial number of providers
078: Provider initialSecondProviderName = Security.getProviders()[1];
079:
080: try {
081:
082: // Insert at position -1, the provider is inserted at the end
083: assertEquals(initNum + 1, Security.insertProviderAt(p, -1));
084: assertSame(p, Security.getProviders()[initNum]);
085:
086: // A provider cannot be added if it is already installed
087: assertEquals(-1, Security.insertProviderAt(p, 1));
088:
089: Security.removeProvider(p.getName());
090:
091: // insert at the end
092: assertEquals(initNum + 1, Security.insertProviderAt(p,
093: initNum + 100));
094: assertSame(p, Security.getProviders()[initNum]);
095:
096: Security.removeProvider(p.getName());
097:
098: // insert at the first position
099: assertEquals(1, Security.insertProviderAt(p, 1));
100: assertSame(p, Security.getProviders()[0]);
101: assertSame(initialSecondProviderName, // provider shifted down
102: Security.getProviders()[2]);
103: } finally { //clean up
104: Security.removeProvider(p.getName());
105: }
106: }
107:
108: /**
109: * @tests java.security.Security#addProvider(Provider)
110: */
111: public final void test_addProviderLjava_security_Provider() {
112:
113: try {
114: Security.addProvider(null);
115: fail("No expected NullPointerException");
116: } catch (NullPointerException e) {
117: }
118:
119: Provider p = new MyProvider();
120: int initNum = Security.getProviders().length; // initial number of providers
121:
122: try {
123: // add
124: assertEquals(initNum + 1, Security.addProvider(p));
125: assertSame(p, Security.getProviders()[initNum]);
126:
127: // A provider cannot be added if it is already installed
128: assertEquals(-1, Security.addProvider(p));
129: } finally { //clean up
130: Security.removeProvider(p.getName());
131: }
132: }
133:
134: public final void testRemoveProvider() {
135: Provider[] providers;
136: Provider[] providers1;
137:
138: providers = Security.getProviders();
139:
140: try {
141: for (int i = 0; i < providers.length; i++) {
142: Security.removeProvider(providers[i].getName());
143: }
144: assertEquals("Providers not removed", 0, Security
145: .getProviders().length);
146: } finally { // restore providers
147: for (int i = 0; i < providers.length; i++) {
148: Security.addProvider(providers[i]);
149: }
150: providers1 = Security.getProviders();
151: for (int i = 0; i < providers1.length; i++) {
152: assertEquals("Providers not restored correctly",
153: providers[i], providers1[i]);
154: }
155: }
156: }
157:
158: /**
159: * @tests java.security.Security#getProvider(String)
160: */
161: public final void test_getProviderLjava_lang_String() {
162:
163: // Returns null if no provider with the specified name is installed
164: assertNull(Security.getProvider("SOMEINCORRECTPROVIDERNAME"));
165:
166: // Returns null if name is null
167: assertNull(Security.getProvider(null));
168:
169: // test for existing providers
170: Provider[] providers = Security.getProviders();
171: assertTrue("getProviders returned zero length array",
172: providers.length > 0);
173: for (Provider p : providers) {
174: String providerName = p.getName();
175: assertSame(p, Security.getProvider(providerName));
176: }
177:
178: // test for newly installed provider
179: Provider p = new MyProvider();
180: try {
181: Security.addProvider(p);
182:
183: assertSame(p, Security.getProvider(p.getName()));
184: } finally { //clean up
185: Security.removeProvider(p.getName());
186: }
187: }
188:
189: /**
190: * @tests java.security.Security#getProviders(String)
191: */
192: public void test_getProvidersLjava_lang_String() {
193:
194: try {
195: Security.getProviders("");
196: fail("No expected InvalidParameterException");
197: } catch (InvalidParameterException e) {
198: }
199:
200: try {
201: Security.getProviders((String) null);
202: fail("No expected NullPointerException");
203: } catch (NullPointerException e) {
204: }
205:
206: Provider p = new MyProvider();
207: try {
208: Security.addProvider(p);
209:
210: String filter = "MyService.MyAlgorithm";
211: assertTrue(filter, Arrays.equals(new Provider[] { p },
212: Security.getProviders(filter)));
213:
214: filter = "MyService.MyAlgorithm KeySize:512";
215: assertTrue(filter, Arrays.equals(new Provider[] { p },
216: Security.getProviders(filter)));
217:
218: filter = "MyService.MyAlgorithm KeySize:1025";
219: assertNull(filter, Security.getProviders(filter));
220:
221: // attribute name and value are case insensitive
222: filter = "MyService.MyAlgorithm imPLementedIn:softWARE";
223: assertTrue(filter, Arrays.equals(new Provider[] { p },
224: Security.getProviders(filter)));
225: filter = "MyService.MyAlgorithm ATTribute:attributeVALUE";
226: assertTrue(filter, Arrays.equals(new Provider[] { p },
227: Security.getProviders(filter)));
228:
229: // Regression for HARMONY-2761
230: filter = "MyService.NoKeySize KeySize:512";
231: assertNull(filter, Security.getProviders(filter));
232:
233: filter = "MyService.NoImplementedIn ImplementedIn:Software";
234: assertNull(filter, Security.getProviders(filter));
235:
236: filter = "ABCService.NoAttribute Attribute:ABC";
237: assertNull(filter, Security.getProviders(filter));
238: } finally { //clean up
239: Security.removeProvider(p.getName());
240: }
241: }
242:
243: /**
244: * @tests java.security.Security#getProviders(java.util.Map)
245: */
246: public void test_getProvidersLjava_util_Map() {
247:
248: Map<String, String> m = new HashMap<String, String>();
249: Security.getProviders(m);
250:
251: assertNull("Not null result on empty map", Security
252: .getProviders(m));
253:
254: try {
255: Security.getProviders((Map<String, String>) null);
256: fail("No expected NullPointerException");
257: } catch (NullPointerException e) {
258: }
259:
260: m.put("AAA.BBB.CCC", "aaaa"); // key has dot instead of space
261: try {
262: Security.getProviders(m);
263: fail("No expected InvalidParameterException");
264: } catch (InvalidParameterException e) {
265: }
266:
267: Provider p = new MyProvider();
268: try {
269: Security.addProvider(p);
270:
271: m.clear();
272: m.put("MyService.MyAlgorithm", "");
273: m.put("MessageDigest.SHA-1", "");
274: assertTrue("MyService.MyAlgorithm", Arrays.equals(
275: new Provider[] { p }, Security.getProviders(m)));
276:
277: m.clear();
278: m.put("MyService.MyAlgorithm KeySize", "512");
279: m.put("MessageDigest.SHA-1", "");
280: assertTrue("MyService.MyAlgorithm KeySize:512", Arrays
281: .equals(new Provider[] { p }, Security
282: .getProviders(m)));
283:
284: m.clear();
285: m.put("MyService.MyAlgorithm KeySize", "1025");
286: m.put("MessageDigest.SHA-1", "");
287: assertNull("MyService.MyAlgorithm KeySize:1025", Security
288: .getProviders(m));
289:
290: // attribute name and value are case insensitive
291: m.clear();
292: m.put("MyService.MyAlgorithm imPLementedIn", "softWARE");
293: assertTrue(Arrays.equals(new Provider[] { p }, Security
294: .getProviders(m)));
295: m.clear();
296: m.put("MyService.MyAlgorithm ATTribute", "attributeVALUE");
297: assertTrue(Arrays.equals(new Provider[] { p }, Security
298: .getProviders(m)));
299:
300: // Regression for HARMONY-2761
301: m.clear();
302: m.put("MyService.NoKeySize KeySize", "512");
303: assertNull("No KeySize attribute", Security.getProviders(m));
304:
305: m.clear();
306: m
307: .put("MyService.NoImplementedIn ImplementedIn",
308: "Software");
309: assertNull("No ImplementedIn attribute", Security
310: .getProviders(m));
311:
312: m.clear();
313: m.put("ABCService.NoAttribute Attribute", "ABC");
314: assertNull(Security.getProviders(m));
315: } finally { //clean up
316: Security.removeProvider(p.getName());
317: }
318: }
319:
320: /**
321: * @tests java.security.Security#getProperty(String)
322: */
323: public void test_getPropertyLjava_lang_String() {
324:
325: try {
326: Security.getProperty(null);
327: fail("No expected NullPointerException.");
328: } catch (NullPointerException e) {
329: }
330: }
331:
332: /**
333: * @tests java.security.Security#setProperty(String,String)
334: */
335: public void test_setPropertyLjava_lang_StringLjava_lang_String() {
336:
337: try {
338: Security.setProperty(null, "");
339: fail("No expected NullPointerException.");
340: } catch (NullPointerException e) {
341: }
342:
343: try {
344: Security.setProperty("", null);
345: fail("No expected NullPointerException.");
346: } catch (NullPointerException e) {
347: }
348:
349: Security.setProperty("", "");
350: assertEquals("Empty property", "", Security.getProperty(""));
351:
352: Security.setProperty("My Test Property", "My property value");
353: assertEquals("My property value", Security
354: .getProperty("My Test Property"));
355: }
356:
357: @SuppressWarnings("serial")
358: class MyProvider extends Provider {
359: MyProvider() {
360: super ("MyProvider", 1.0, "Provider for testing");
361: put("MessageDigest.SHA-1", "SomeClassName");
362: put("MyService.MyAlgorithm", "SomeClassName");
363: put("MyService.MyAlgorithm KeySize", "1024");
364: put("MyService.MyAlgorithm ImplementedIn", "Software");
365: put("MyService.MyAlgorithm Attribute", "AttributeValue");
366:
367: // service has no KeySize attribute
368: put("MyService.NoKeySize", "SomeClassName");
369:
370: // service has no ImplementedIn attribute
371: put("MyService.NoImplementedIn", "SomeClassName");
372:
373: // service has no 'Attribute' attribute
374: put("ABCService.NoAttribute", "SomeClassName");
375: }
376: }
377: }
|