IdentityTest.java revision e98fbf8686c5289bf03fe5c3de7ff82d3a77104d
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 18/** 19* @author Aleksei Y. Semenov 20*/ 21 22package java.security; 23 24 25 26import org.apache.harmony.security.tests.support.CertificateStub; 27import org.apache.harmony.security.tests.support.IdentityStub; 28import org.apache.harmony.security.tests.support.PublicKeyStub; 29 30import junit.framework.TestCase; 31 32/** 33 * Tests for class Identity 34 * 35 */ 36 37public class IdentityTest extends TestCase { 38 39 public static class MySecurityManager extends SecurityManager { 40 public Permissions denied = new Permissions(); 41 public void checkPermission(Permission permission){ 42 if (denied!=null && denied.implies(permission)) throw new SecurityException(); 43 } 44 } 45 46 /** 47 * Constructor for IdentityTest. 48 * @param name 49 */ 50 public IdentityTest(String name) { 51 super(name); 52 } 53 54 public void testHashCode() { 55 new IdentityStub("testHashCode").hashCode(); 56 } 57 58 public void testEquals() throws Exception { 59 Identity i1 = new IdentityStub("testEquals"); 60 Object value[] = { 61 null, Boolean.FALSE, 62 new Object(), Boolean.FALSE, 63 i1, Boolean.TRUE, 64 new IdentityStub(i1.getName()), Boolean.TRUE 65 }; 66 67 for (int k=0; k<value.length; k+=2) { 68 assertEquals(value[k+1], new Boolean(i1.equals(value[k]))); 69 if (Boolean.TRUE.equals(value[k+1])) assertEquals(i1.hashCode(), value[k].hashCode()); 70 } 71 // check other cases 72 Identity i2 = new IdentityStub("testEquals", IdentityScope.getSystemScope()); 73 assertEquals(i1.identityEquals(i2), i1.equals(i2)); 74 Identity i3 = new IdentityStub("testEquals3"); 75 assertEquals(i1.identityEquals(i3), i1.equals(i3)); 76 77 } 78 79 /** 80 * verify Identity.toString() throws Exception is permission is denied 81 */ 82 public void testToString1() { 83 MySecurityManager sm = new MySecurityManager(); 84 sm.denied.add(new SecurityPermission("printIdentity")); 85 System.setSecurityManager(sm); 86 try { 87 new IdentityStub("testToString").toString(); 88 fail("SecurityException should be thrown"); 89 } catch (SecurityException ok) { 90 } finally { 91 System.setSecurityManager(null); 92 } 93 } 94 /** 95 * verify Identity.toString() 96 */ 97 public void testToString2() { 98 assertNotNull(new IdentityStub("testToString2").toString()); 99 } 100 101 /** 102 * verify Identity() creates instance 103 */ 104 public void testIdentity() { 105 assertNotNull(new IdentityStub()); 106 } 107 108 /* 109 * verify Identity(String) creates instance with given name 110 */ 111 public void testIdentityString() { 112 Identity i = new IdentityStub("iii"); 113 assertNotNull(i); 114 assertEquals("iii", i.getName()); 115 i=new IdentityStub(null); 116 assertNotNull(i); 117 assertNull(i.getName()); 118 } 119 120 /** 121 * verify Identity(String, IdentityScope) creates instance with given name and in give scope 122 */ 123 public void testIdentityStringIdentityScope() throws Exception { 124 IdentityScope s = IdentityScope.getSystemScope(); 125 Identity i = new IdentityStub("iii2", s); 126 assertNotNull(i); 127 assertEquals("iii2", i.getName()); 128 assertSame(s, i.getScope()); 129 assertSame(i, s.getIdentity(i.getName())); 130 } 131 132 /** 133 * verify addCertificate(Certificate certificate) adds a certificate for this identity. 134 * If the identity has a public key, the public key in the certificate must be the same 135 * 136 */ 137 public void testAddCertificate1() throws Exception { 138 Identity i = new IdentityStub("iii"); 139 PublicKeyStub pk1 = new PublicKeyStub("kkk", "fff", new byte[]{1,2,3,4,5}); 140 i.setPublicKey(pk1); 141 // try with the same key 142 CertificateStub c1 = new CertificateStub("fff", null, null, pk1); 143 i.addCertificate(c1); 144 assertSame(c1, i.certificates()[0]); 145 // try Certificate with different key 146 try { 147 i.addCertificate(new CertificateStub("ccc", null, null, new PublicKeyStub("k2", "fff", new byte[]{6,7,8,9,0}))); 148 fail("KeyManagementException should be thrown"); 149 } catch (KeyManagementException ok) {} 150 } 151 152 /** 153 * verify addCertificate(Certificate certificate) adds a certificate for this identity. 154 * if the identity does not have a public key, the identity's public key is set to be that specified in the certificate. 155 */ 156 public void testAddCertificate2() throws Exception { 157 Identity i = new IdentityStub("iii"); 158 PublicKeyStub pk1 = new PublicKeyStub("kkk", "fff", null); 159 CertificateStub c1 = new CertificateStub("fff", null, null, pk1); 160 i.addCertificate(c1); 161 assertSame(c1, i.certificates()[0]); 162 assertSame(pk1, i.getPublicKey()); 163 164 } 165 166 /** 167 * verify addCertificate(Certificate certificate) throws SecurityException is permission is denied 168 */ 169 public void testAddCertificate3() throws Exception { 170 MySecurityManager sm = new MySecurityManager(); 171 sm.denied.add(new SecurityPermission("addIdentityCertificate")); 172 System.setSecurityManager(sm); 173 try { 174 new IdentityStub("iii").addCertificate(new CertificateStub("ccc", null, null, null)); 175 fail("SecurityException should be thrown"); 176 } catch (SecurityException ok) { 177 } finally { 178 System.setSecurityManager(null); 179 } 180 } 181 182 /** 183 * verify addCertificate(Certificate certificate) throws KeyManagementException if certificate is null 184 */ 185 public void testAddCertificate4() throws Exception { 186 try { 187 new IdentityStub("aaa").addCertificate(null); 188 fail("KeyManagementException should be thrown"); 189 } catch (KeyManagementException ok) { 190 } catch (NullPointerException ok) {} 191 192 } 193// 194// Commented out since there will no be fix for the test failure 195// /** 196// * verify removeCertificate(Certificate certificate) removes certificate 197// */ 198// public void testRemoveCertificate1() throws Exception{ 199// Identity i = new IdentityStub("iii"); 200// PublicKeyStub pk1 = new PublicKeyStub("kkk", "fff", null); 201// CertificateStub c1 = new CertificateStub("fff", null, null, pk1); 202// i.addCertificate(c1); 203// assertSame(c1, i.certificates()[0]); 204// i.removeCertificate(c1); 205// assertEquals(0, i.certificates().length); 206// // throw KeyManagementException if certificate not found 207// try { 208// i.removeCertificate(c1); 209// fail("KeyManagementException should be thrown"); 210// } catch (KeyManagementException ok) { 211// } 212// try { 213// i.removeCertificate(null); 214// fail("KeyManagementException should be thrown"); 215// } catch (KeyManagementException ok) { 216// 217// } 218// } 219 /** 220 * verify removeCertificate(Certificate certificate) throws SecurityException if permission is denied 221 */ 222 public void testRemoveCertificate2() throws Exception{ 223 MySecurityManager sm = new MySecurityManager(); 224 sm.denied.add(new SecurityPermission("removeIdentityCertificate")); 225 Identity i = new IdentityStub("iii"); 226 i.addCertificate(new CertificateStub("ccc", null, null, null)); 227 System.setSecurityManager(sm); 228 try { 229 i.removeCertificate(i.certificates()[0]); 230 fail("SecurityException should be thrown"); 231 } catch (SecurityException ok) { 232 } finally { 233 System.setSecurityManager(null); 234 } 235 236 } 237 238 /** 239 * verify certificates() returns a copy of all certificates for this identity 240 */ 241 public void testCertificates() throws Exception { 242 Identity i = new IdentityStub("iii"); 243 PublicKeyStub pk1 = new PublicKeyStub("kkk", "fff", null); 244 CertificateStub c1 = new CertificateStub("fff", null, null, pk1); 245 CertificateStub c2 = new CertificateStub("zzz", null, null, pk1); 246 i.addCertificate(c1); 247 i.addCertificate(c2); 248 Certificate[] s = i.certificates(); 249 assertEquals(2, s.length); 250 assertTrue(c1.equals(s[0]) || c2.equals(s[0])); 251 assertTrue(c1.equals(s[1]) || c2.equals(s[1])); 252 s[0] = null; 253 s[1] = null; 254 // check that the copy was modified 255 s = i.certificates(); 256 assertEquals(2, s.length); 257 assertTrue(c1.equals(s[0]) || c2.equals(s[0])); 258 assertTrue(c1.equals(s[1]) || c2.equals(s[1])); 259 } 260 261 /** 262 * verify Identity.identityEquals(Identity) return true, only if names and public keys are equal 263 */ 264 265 public void testIdentityEquals() throws Exception { 266 String name = "nnn"; 267 PublicKey pk = new PublicKeyStub("aaa", "fff", new byte[]{1,2,3,4,5}); 268 Identity i = new IdentityStub(name); 269 i.setPublicKey(pk); 270 Object[] value = { 271 //null, Boolean.FALSE, 272 //new Object(), Boolean.FALSE, 273 new IdentityStub("111"), Boolean.FALSE, 274 new IdentityStub(name), Boolean.FALSE, 275 new IdentityStub(name, IdentityScope.getSystemScope()), Boolean.FALSE, 276 i, Boolean.TRUE, 277 new IdentityStub(name, pk), Boolean.TRUE 278 }; 279 for (int k=0; k<value.length; k+=2){ 280 assertEquals(value[k+1], new Boolean(i.identityEquals((Identity)value[k]))); 281 if (Boolean.TRUE.equals(value[k+1])) assertEquals(i.hashCode(), value[k].hashCode()); 282 } 283 Identity i2 = IdentityScope.getSystemScope().getIdentity(name); 284 i2.setPublicKey(pk); 285 assertTrue(i.identityEquals(i2)); 286 } 287 288 /** 289 * verify Identity.toString(boolean) return string representation of identity 290 */ 291 public void testToStringboolean() throws Exception { 292 new IdentityStub("aaa").toString(false); 293 new IdentityStub("aaa2", IdentityScope.getSystemScope()).toString(false); 294 new IdentityStub("bbb").toString(true); 295 new IdentityStub("bbb2", IdentityScope.getSystemScope()).toString(true); 296 } 297 298 /** 299 * verify Identity.getScope() returns identity's scope 300 */ 301 public void testGetScope() throws Exception { 302 Identity i = new IdentityStub("testGetScope"); 303 assertNull(i.getScope()); 304 IdentityScope s = IdentityScope.getSystemScope(); 305 306 Identity i2 = new IdentityStub("testGetScope2", s); 307 assertSame(s, i2.getScope()); 308 309 } 310 /** 311 * 312 * verify Identity.setPublicKey() throws SecurityException if permission is denied 313 * 314 */ 315 public void testSetPublicKey1() throws Exception { 316 MySecurityManager sm = new MySecurityManager(); 317 sm.denied.add(new SecurityPermission("setIdentityPublicKey")); 318 System.setSecurityManager(sm); 319 try { 320 new IdentityStub("testSetPublicKey1").setPublicKey(new PublicKeyStub("kkk", "testSetPublicKey1", null)); 321 fail("SecurityException should be thrown"); 322 } catch (SecurityException ok) { 323 } finally { 324 System.setSecurityManager(null); 325 } 326 327 } 328 /** 329 * 330 * verify Identity.setPublicKey() throws KeyManagementException if key is invalid 331 * 332 */ 333 public void testSetPublicKey2() throws Exception { 334 Identity i2 = new IdentityStub("testSetPublicKey2_2", IdentityScope.getSystemScope()); 335 new PublicKeyStub("kkk", "testSetPublicKey2", new byte[]{1,2,3,4,5}); 336 try { 337 i2.setPublicKey(null); 338 //fail("KeyManagementException should be thrown - key is null"); 339 } catch (KeyManagementException ok) {} 340 } 341 342// 343// Commented out since there will no be fix for the test failure 344// /** 345// * 346// * verify Identity.setPublicKey() throws KeyManagementException if key is already used 347// * 348// */ 349// public void testSetPublicKey3() throws Exception { 350// Identity i1 = new IdentityStub("testSetPublicKey3_1", IdentityScope.getSystemScope()); 351// Identity i2 = new IdentityStub("testSetPublicKey3_2", IdentityScope.getSystemScope()); 352// PublicKey pk = new PublicKeyStub("kkk", "fff", new byte[]{1,2,3,4,5}); 353// i1.setPublicKey(pk); 354// try { 355// i2.setPublicKey(pk); 356// fail("KeyManagementException should be thrown - key already used"); 357// } catch (KeyManagementException ok) {}; 358// } 359 /** 360 * 361 * verify Identity.setPublicKey() removes old key and all identity's certificates 362 * 363 */ 364 public void testSetPublicKey4() throws Exception { 365 Identity i = new IdentityStub("testSetPublicKey4"); 366 PublicKeyStub pk1 = new PublicKeyStub("kkk", "Identity.testSetPublicKey4", null); 367 CertificateStub c1 = new CertificateStub("fff", null, null, pk1); 368 CertificateStub c2 = new CertificateStub("zzz", null, null, pk1); 369 i.addCertificate(c1); 370 i.addCertificate(c2); 371 assertEquals(2, i.certificates().length); 372 assertSame(pk1, i.getPublicKey()); 373 374 PublicKeyStub pk2 = new PublicKeyStub("zzz", "Identity.testSetPublicKey4", null); 375 i.setPublicKey(pk2); 376 assertSame(pk2, i.getPublicKey()); 377 assertEquals(0, i.certificates().length); 378 } 379 380 /** 381 * verify Identity.getPublicKey() returns public key 382 */ 383 384 public void testGetPublicKey() throws Exception { 385 Identity i = new IdentityStub("testGetPublicKey"); 386 assertNull(i.getPublicKey()); 387 PublicKey pk = new PublicKeyStub("kkk", "Identity.testGetPublicKey", null); 388 i.setPublicKey(pk); 389 assertSame(pk, i.getPublicKey()); 390 } 391 392 /** 393 * 394 * verify Identity.setInfo() throws SecurityException if permission is denied 395 * 396 * 397 */ 398 public void testSetInfo() throws Exception { 399 MySecurityManager sm = new MySecurityManager(); 400 sm.denied.add(new SecurityPermission("setIdentityInfo")); 401 System.setSecurityManager(sm); 402 try { 403 new IdentityStub("testSetInfo").setInfo("some info"); 404 fail("SecurityException should be thrown"); 405 } catch (SecurityException ok) { 406 } finally { 407 System.setSecurityManager(null); 408 } 409 } 410 411 public void testGetInfo() { 412 413 Identity i = new IdentityStub("testGetInfo"); 414 i.setInfo("some info"); 415 assertEquals("some info", i.getInfo()); 416 } 417 418 public void testGetName() { 419 Identity i = new IdentityStub("testGetName"); 420 assertEquals ("testGetName", i.getName()); 421 } 422 423} 424