/**
  * verify Identity.identityEquals(Identity) return true, only if names and public keys are equal
  */
 public void testIdentityEquals() throws Exception {
   String name = "nnn";
   PublicKey pk = new PublicKeyStub("aaa", "fff", new byte[] {1, 2, 3, 4, 5});
   Identity i = new IdentityStub(name);
   i.setPublicKey(pk);
   Object[] value = {
     // null, Boolean.FALSE,
     // new Object(), Boolean.FALSE,
     new IdentityStub("111"),
     Boolean.FALSE,
     new IdentityStub(name),
     Boolean.FALSE,
     new IdentityStub(name, IdentityScope.getSystemScope()),
     Boolean.FALSE,
     i,
     Boolean.TRUE,
     new IdentityStub(name, pk),
     Boolean.TRUE
   };
   for (int k = 0; k < value.length; k += 2) {
     assertEquals(value[k + 1], new Boolean(i.identityEquals((Identity) value[k])));
     if (Boolean.TRUE.equals(value[k + 1])) assertEquals(i.hashCode(), value[k].hashCode());
   }
   Identity i2 = IdentityScope.getSystemScope().getIdentity(name);
   i2.setPublicKey(pk);
   assertTrue(i.identityEquals(i2));
 }
 /** verify Identity(String, IdentityScope) creates instance with given name and in give scope */
 public void testIdentityStringIdentityScope() throws Exception {
   IdentityScope s = IdentityScope.getSystemScope();
   Identity i = new IdentityStub("iii2", s);
   assertNotNull(i);
   assertEquals("iii2", i.getName());
   assertSame(s, i.getScope());
   assertSame(i, s.getIdentity(i.getName()));
 }
 /**
  * Creates a new instance of {@code Identity} with the specified name and the scope of this {@code
  * Identity}.
  *
  * @param name the name of this {@code Identity}.
  * @param scope the {@code IdentityScope} of this {@code Identity}.
  * @throws KeyManagementException if an {@code Identity} with the same name is already present in
  *     the specified scope.
  */
 public Identity(String name, IdentityScope scope) throws KeyManagementException {
   this(name);
   if (scope != null) {
     scope.addIdentity(this);
     this.scope = scope;
   }
 }
 /**
  * Returns a string containing a concise, human-readable description of the this {@code Identity}
  * including its name and its scope.
  *
  * @return a printable representation for this {@code Identity}.
  */
 @Override
 public String toString() {
   String s = (this.name == null ? "" : this.name);
   if (scope != null) {
     s += " [" + scope.getName() + "]";
   }
   return s;
 }
  /** verify Identity.getScope() returns identity's scope */
  public void testGetScope() throws Exception {
    Identity i = new IdentityStub("testGetScope");
    assertNull(i.getScope());
    IdentityScope s = IdentityScope.getSystemScope();

    Identity i2 = new IdentityStub("testGetScope2", s);
    assertSame(s, i2.getScope());
  }
 /** verify Identity.setPublicKey() throws KeyManagementException if key is invalid */
 public void testSetPublicKey2() throws Exception {
   Identity i2 = new IdentityStub("testSetPublicKey2_2", IdentityScope.getSystemScope());
   new PublicKeyStub("kkk", "testSetPublicKey2", new byte[] {1, 2, 3, 4, 5});
   try {
     i2.setPublicKey(null);
     // fail("KeyManagementException should be thrown - key is null");
   } catch (KeyManagementException ok) {
   }
 }
 /**
  * Returns the hash code value for this {@code Identity}. Returns the same hash code for {@code
  * Identity}s that are equal to each other as required by the general contract of {@link
  * Object#hashCode}.
  *
  * @return the hash code value for this {@code Identity}.
  * @see Object#equals(Object)
  * @see Identity#equals(Object)
  */
 @Override
 public int hashCode() {
   int hash = 0;
   if (name != null) {
     hash += name.hashCode();
   }
   if (scope != null) {
     hash += scope.hashCode();
   }
   return hash;
 }
 /**
  * Sets the specified {@code PublicKey} to this {@code Identity}.
  *
  * @param key the {@code PublicKey} to be set.
  * @throws KeyManagementException if another {@code Identity} in the same scope as this {@code
  *     Identity} already has the same {@code PublicKey}.
  */
 public void setPublicKey(PublicKey key) throws KeyManagementException {
   // this check does not always work
   if ((scope != null) && (key != null)) {
     Identity i = scope.getIdentity(key);
     // System.out.println("###DEBUG## Identity: "+i);
     if ((i != null) && (i != this)) {
       throw new KeyManagementException("key already used in scope");
     }
   }
   this.publicKey = key;
   certificates = null;
 }
  public void testEquals() throws Exception {
    Identity i1 = new IdentityStub("testEquals");
    Object value[] = {
      null,
      Boolean.FALSE,
      new Object(),
      Boolean.FALSE,
      i1,
      Boolean.TRUE,
      new IdentityStub(i1.getName()),
      Boolean.TRUE
    };

    for (int k = 0; k < value.length; k += 2) {
      assertEquals(value[k + 1], new Boolean(i1.equals(value[k])));
      if (Boolean.TRUE.equals(value[k + 1])) assertEquals(i1.hashCode(), value[k].hashCode());
    }
    // check other cases
    Identity i2 = new IdentityStub("testEquals", IdentityScope.getSystemScope());
    assertEquals(i1.identityEquals(i2), i1.equals(i2));
    Identity i3 = new IdentityStub("testEquals3");
    assertEquals(i1.identityEquals(i3), i1.equals(i3));
  }
 /** verify Identity.toString(boolean) return string representation of identity */
 public void testToStringboolean() throws Exception {
   new IdentityStub("aaa").toString(false);
   new IdentityStub("aaa2", IdentityScope.getSystemScope()).toString(false);
   new IdentityStub("bbb").toString(true);
   new IdentityStub("bbb2", IdentityScope.getSystemScope()).toString(true);
 }