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