/**
* 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);
}
