Commit a13e4f2c authored by Dan Bornstein's avatar Dan Bornstein Committed by Jean-Baptiste Queru
Browse files

Remove pointless tests.

Change-Id: I17ffa62ca632ff1cbcdd0847c97ce539877e8667
parent 5bcbe1c8
......@@ -39,9 +39,6 @@ import java.security.AccessControlContext;
import java.security.AccessController;
import java.security.ProtectionDomain;
import org.apache.harmony.security.tests.support.acl.PrincipalImpl;
/**
* Tests for <code>Subject</code> class constructors and methods.
*
......@@ -70,82 +67,6 @@ public class SubjectTest extends TestCase {
}
}
/**
* @tests javax.security.auth.Subject#Subject(boolean readOnly,
* Set<? extends Principal> principals,
* Set<?> pubCredentials,
* Set<?> privCredentials)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "Subject",
args = {boolean.class, Set.class, Set.class, Set.class}
)
public void test_Constructor_02() {
Set <Principal> principal = new HashSet<Principal>();
Set <Object> pubCredentials = new HashSet<Object>();
Set <Object> privCredentials = new HashSet<Object>();
Principal pr1 = new PrincipalImpl("TestPrincipal1");
Principal pr2 = new PrincipalImpl("TestPrincipal2");
principal.add(pr1);
principal.add(pr2);
Object pubCredential1 = new Object();
Object pubCredential2 = new Object();
pubCredentials.add(pubCredential1);
pubCredentials.add(pubCredential2);
Object privCredential1 = new Object();
Object privCredential2 = new Object();
privCredentials.add(privCredential1);
privCredentials.add(privCredential2);
try {
Subject s = new Subject(true, principal, pubCredentials, privCredentials);
assertNotNull("Null object returned", s);
assertTrue("Not read-only object", s.isReadOnly());
assertFalse("Set of principal is empty", s.getPrincipals().isEmpty());
assertFalse("Set of private credentials is empty", s.getPrivateCredentials().isEmpty());
assertFalse("Set of public credentials is empty", s.getPublicCredentials().isEmpty());
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
try {
Subject s = new Subject(false, principal, pubCredentials, privCredentials);
assertNotNull("Null object returned", s);
assertFalse("Read-only object", s.isReadOnly());
assertFalse("Set of principal is empty", s.getPrincipals().isEmpty());
assertFalse("Set of private credentials is empty", s.getPrivateCredentials().isEmpty());
assertFalse("Set of public credentials is empty", s.getPublicCredentials().isEmpty());
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
try {
Subject s = new Subject(true, null, pubCredentials, privCredentials);
fail("NullPointerException wasn't thrown");
} catch (NullPointerException npe) {
}
try {
Subject s = new Subject(true, principal, null, privCredentials);
fail("NullPointerException wasn't thrown");
} catch (NullPointerException npe) {
}
try {
Subject s = new Subject(true, principal, pubCredentials, null);
fail("NullPointerException wasn't thrown");
} catch (NullPointerException npe) {
}
try {
Subject s = new Subject(true, null, null, null);
fail("NullPointerException wasn't thrown");
} catch (NullPointerException npe) {
}
}
/**
* @tests javax.security.auth.Subject#doAs(Subject subject, PrivilegedAction action)
*/
......@@ -308,161 +229,6 @@ public class SubjectTest extends TestCase {
}
}
/**
* @tests javax.security.auth.Subject#equals(Object o)
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "SecurityException wasn't tested",
method = "equals",
args = {Object.class}
)
public void test_equals() {
Set <Principal> principal = new HashSet<Principal>();
Set <Principal> principal1 = new HashSet<Principal>();
Set <Object> pubCredentials = new HashSet<Object>();
Set <Object> privCredentials = new HashSet<Object>();
Principal pr1 = new PrincipalImpl("TestPrincipal1");
Principal pr2 = new PrincipalImpl("TestPrincipal2");
principal.add(pr1);
principal.add(pr2);
principal1.add(pr1);
Object pubCredential1 = new Object();
Object pubCredential2 = new Object();
pubCredentials.add(pubCredential1);
pubCredentials.add(pubCredential2);
Object privCredential1 = new Object();
Object privCredential2 = new Object();
privCredentials.add(privCredential1);
privCredentials.add(privCredential2);
Subject s1 = new Subject(true, principal, pubCredentials, privCredentials);
Subject s2 = new Subject(true, principal1, pubCredentials, privCredentials);
Subject s3 = new Subject(true, principal, pubCredentials, privCredentials);
try {
assertTrue(s1.equals(s1));
assertFalse(s1.equals(s2));
assertTrue(s1.equals(s3));
assertFalse(s1.equals(new Object()));
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
}
/**
* @tests javax.security.auth.Subject#getPrincipals()
* @tests javax.security.auth.Subject#getPrivateCredentials()
* @tests javax.security.auth.Subject#getPublicCredentials()
* @tests javax.security.auth.Subject#isReadOnly()
* @tests javax.security.auth.Subject#setReadOnly()
*/
@TestTargets({
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getPrincipals",
args = {}
),
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getPrivateCredentials",
args = {}
),
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getPublicCredentials",
args = {}
)
})
public void test_getPrincipals() {
Set <Principal> principal = new HashSet<Principal>();
Set <Object> pubCredentials = new HashSet<Object>();
Set <Object> privCredentials = new HashSet<Object>();
Principal pr1 = new PrincipalImpl("TestPrincipal1");
Principal pr2 = new PrincipalImpl("TestPrincipal2");
principal.add(pr1);
principal.add(pr2);
Object pubCredential1 = new Object();
pubCredentials.add(pubCredential1);
Object privCredential1 = new Object();
Object privCredential2 = new Object();
privCredentials.add(privCredential1);
privCredentials.add(privCredential2);
Subject s = new Subject(false, principal, pubCredentials, privCredentials);
try {
Set<Principal> pr = s.getPrincipals();
assertNotNull(pr);
assertEquals(principal.size(), pr.size());
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
try {
Set<Object> privC = s.getPrivateCredentials();
assertNotNull(privC);
assertEquals(privCredentials.size(), privC.size());
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
try {
Set<Object> pubC = s.getPublicCredentials();
assertNotNull(pubC);
assertEquals(pubCredentials.size(), pubC.size());
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
}
/**
* @tests javax.security.auth.Subject#isReadOnly()
* @tests javax.security.auth.Subject#setReadOnly()
*/
@TestTargets({
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "isReadOnly",
args = {}
),
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "setReadOnly",
args = {}
)
})
public void test_ReadOnly() {
Set <Principal> principal = new HashSet<Principal>();
Set <Object> pubCredentials = new HashSet<Object>();
Set <Object> privCredentials = new HashSet<Object>();
Principal pr1 = new PrincipalImpl("TestPrincipal1");
Principal pr2 = new PrincipalImpl("TestPrincipal2");
principal.add(pr1);
principal.add(pr2);
Object pubCredential1 = new Object();
pubCredentials.add(pubCredential1);
Object privCredential1 = new Object();
Object privCredential2 = new Object();
privCredentials.add(privCredential1);
privCredentials.add(privCredential2);
Subject s = new Subject(false, principal, pubCredentials, privCredentials);
try {
assertFalse(s.isReadOnly());
s.setReadOnly();
assertTrue(s.isReadOnly());
} catch (Exception e) {
fail("Unexpected exception " + e);
}
}
/**
* @tests javax.security.auth.Subject#getSubject(AccessControlContext acc)
*/
......@@ -520,91 +286,6 @@ public class SubjectTest extends TestCase {
fail("Unexpected exception: " + e);
}
}
/**
* @tests javax.security.auth.Subject#getPrincipals(Class<T> c)
* @tests javax.security.auth.Subject#getPrivateCredentials(Class<T> c)
* @tests javax.security.auth.Subject#getPublicCredentials(Class<T> c)
*/
@TestTargets({
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getPrincipals",
args = {Class.class}
),
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "",
method = "getPrivateCredentials",
args = {Class.class}
),
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "",
method = "getPublicCredentials",
args = {Class.class}
)
})
public void test_getPrincipals_Class() {
Set <Principal> principal = new HashSet<Principal>();
Set <Object> pubCredentials = new HashSet<Object>();
Set <Object> privCredentials = new HashSet<Object>();
Principal pr1 = new PrincipalImpl("TestPrincipal1");
Principal pr2 = new PrincipalImpl("TestPrincipal2");
principal.add(pr1);
principal.add(pr2);
Object pubCredential1 = new Object();
pubCredentials.add(pubCredential1);
Object privCredential1 = new Object();
Object privCredential2 = new Object();
privCredentials.add(privCredential1);
privCredentials.add(privCredential2);
Subject s = new Subject(true, principal, pubCredentials, privCredentials);
try {
Set<Principal> pr = s.getPrincipals(null);
fail("NullPointerException wasn't thrown");
} catch (NullPointerException npe) {
}
try {
Set<Object> privC = s.getPrivateCredentials(null);
fail("NullPointerException wasn't thrown");
} catch (NullPointerException npe) {
}
try {
Set<Object> pubC = s.getPublicCredentials(null);
fail("NullPointerException wasn't thrown");
} catch (NullPointerException npe) {
}
try {
Set<Principal> pr = s.getPrincipals(Principal.class);
assertNotNull(pr);
assertEquals(principal.size(), pr.size());
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
try {
Set<Object> privC = s.getPrivateCredentials(Object.class);
assertNotNull(privC);
assertEquals(privCredentials.size(), privC.size());
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
try {
Set<Object> pubC = s.getPublicCredentials(Object.class);
assertNotNull(pubC);
assertEquals(pubCredentials.size(), pubC.size());
} catch (Exception e) {
fail("Unexpected exception: " + e);
}
}
}
......
......@@ -34,11 +34,6 @@ public class AllTests {
suite.addTestSuite(LastOwnerExceptionTest.class);
suite.addTestSuite(NotOwnerException2Test.class);
suite.addTestSuite(NotOwnerExceptionTest.class);
suite.addTestSuite(IPermissionTest.class);
suite.addTestSuite(IGroupTest.class);
suite.addTestSuite(IOwnerTest.class);
suite.addTestSuite(IAclEntryTest.class);
suite.addTestSuite(IAclTest.class);
// $JUnit-END$
return suite;
......
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package tests.security.acl;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargetClass;
import junit.framework.TestCase;
import java.security.acl.AclEntry;
import java.security.acl.Permission;
import java.security.Principal;
import java.util.Enumeration;
import java.util.Vector;
import org.apache.harmony.security.tests.support.acl.*;
@TestTargetClass(AclEntry.class)
public class IAclEntryTest extends TestCase {
class MyAclEntry extends AclEntryImpl {
public MyAclEntry() {
super();
}
public MyAclEntry(Principal pr) {
super(pr);
}
}
/**
* @tests java.security.acl.AclEntry#addPermission(Permission permission)
* @tests java.security.acl.AclEntry#checkPermission(Permission permission)
* @tests java.security.acl.AclEntry#removePermission(Permission permission)
*/
@TestTargets({
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "addPermission",
args = {java.security.acl.Permission.class}
),
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "checkPermission",
args = {java.security.acl.Permission.class}
),
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "removePermission",
args = {java.security.acl.Permission.class}
)
})
public void test_AclEntry01() {
Permission perm = new PermissionImpl("Permission_1");
MyAclEntry ae = new MyAclEntry(new PrincipalImpl("TestPrincipal"));
try {
assertTrue(ae.addPermission(perm));
assertFalse(ae.addPermission(perm));
assertTrue(ae.checkPermission(perm));
assertTrue(ae.removePermission(perm));
assertFalse(ae.removePermission(perm));
assertFalse(ae.checkPermission(perm));
} catch (Exception ex) {
fail("Unexpected exception " + ex);
}
}
/**
* @tests java.security.acl.AclEntry#getPrincipal()
* @tests java.security.acl.AclEntry#setPrincipal(Principal user)
*/
@TestTargets({
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getPrincipal",
args = {}
),
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "setPrincipal",
args = {java.security.Principal.class}
)
})
public void test_AclEntry02() {
MyAclEntry ae = new MyAclEntry();
Principal mp = new PrincipalImpl("TestPrincipal");
try {
assertTrue(ae.setPrincipal(mp));
Principal p = ae.getPrincipal();
assertEquals("Names are not equal", p.getName(), mp.getName());
assertFalse(ae.setPrincipal(mp));
} catch (Exception ex) {
fail("Unexpected exception " + ex);
}
}
/**
* @tests java.security.acl.AclEntry#setNegativePermissions()
* @tests java.security.acl.AclEntry#isNegative()
*/
@TestTargets({
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "setNegativePermissions",
args = {}
),
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "isNegative",
args = {}
)
})
public void test_AclEntry03() {
MyAclEntry ae = new MyAclEntry(new PrincipalImpl("TestPrincipal"));
try {
assertFalse("isNegative() returns TRUE",ae.isNegative());
ae.setNegativePermissions();
assertTrue("isNegative() returns FALSE", ae.isNegative());
} catch (Exception ex) {
fail("Unexpected exception " + ex);
}
}
/**
* @tests java.security.acl.AclEntry#permissions()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "permissions",
args = {}
)
public void test_AclEntry04() {
MyAclEntry ae = new MyAclEntry(new PrincipalImpl("TestPrincipal"));
Permission perm = new PermissionImpl("Permission_1");
try {
Enumeration en = ae.permissions();
assertFalse("Not empty enumeration", en.hasMoreElements());
ae.addPermission(perm);
en = ae.permissions();
assertTrue("Eempty enumeration", en.hasMoreElements());
Vector v = new Vector();
while (en.hasMoreElements()) {
v.addElement(en.nextElement());
}
assertEquals(v.size(), 1);
assertEquals(v.elementAt(0).toString(), perm.toString());
} catch (Exception ex) {
fail("Unexpected exception " + ex);
}
}
/**
* @tests java.security.acl.AclEntry#toString()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "toString",
args = {}
)
public void test_AclEntry05() {
MyAclEntry ae = new MyAclEntry(new PrincipalImpl("TestPrincipal"));
try {
String res = ae.toString();
assertTrue(res.contains("TestPrincipal"));
} catch (Exception ex) {
fail("Unexpected exception " + ex);
}
}
/**
* @tests java.security.acl.AclEntry#clone()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "clone",
args = {}
)
public void test_AclEntry06() {
MyAclEntry ae = new MyAclEntry(new PrincipalImpl("TestPrincipal"));
try {
assertEquals("Objects are not equal", ae.toString(), ae.clone().toString());
} catch (Exception ex) {
fail("Unexpected exception " + ex);
}
}
}
\ No newline at end of file
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package tests.security.acl;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargetClass;
import junit.framework.TestCase;
import java.security.acl.Acl;
import java.security.acl.AclEntry;
import java.security.acl.NotOwnerException;
import java.security.acl.Permission;
import java.security.Principal;
import java.util.Enumeration;
import java.util.Vector;
import org.apache.harmony.security.tests.support.acl.*;
@TestTargetClass(Acl.class)
public class IAclTest extends TestCase {
class MyAcl extends AclImpl {
public MyAcl(Principal principal, String str) {
super(principal, str);
}
}
/**
* @tests java.security.acl.Acl#addEntry(Principal caller, AclEntry entry)
* @tests java.security.acl.Acl#removeEntry(Principal caller, AclEntry entry)
*/
@TestTargets({
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "addEntry",
args = {java.security.Principal.class, java.security.acl.AclEntry.class}
),
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "removeEntry",
args = {java.security.Principal.class, java.security.acl.AclEntry.class}
)
})
public void test_Acl01() {
Principal pr = new PrincipalImpl("TestPrincipal");
String str = "TestName";
MyAcl acl = new MyAcl(pr, str);
AclEntry ae = new AclEntryImpl(pr);
try {
assertTrue(acl.addEntry(pr, ae));
assertFalse(acl.addEntry(pr, ae));
assertTrue(acl.removeEntry(pr, ae));
assertFalse(acl.removeEntry(pr, ae));
} catch (Exception ex) {
fail("Unexpected exception " + ex);
}
try {
acl.addEntry(new PrincipalImpl("NewPrincipal"), ae);
fail("NotOwnerException was not thrown");
} catch (NotOwnerException noe) {
//expected
}
try {
acl.removeEntry(new PrincipalImpl("NewPrincipal"), ae);
fail("NotOwnerException was not thrown");
} catch (NotOwnerException noe) {
//expected
}
}
/**
* @tests java.security.acl.Acl#setName(Principal caller, String name)
* @tests java.security.acl.Acl#getName()
*/
@TestTargets({
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "setName",
args = {java.security.Principal.class, java.lang.String.class}
),
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getName",
args = {}
)
})
public void test_Acl02() {
Principal pr = new PrincipalImpl("TestPrincipal");
String str = "TestName";
String newStr = "NewName";
MyAcl acl = new MyAcl(pr, str);
try {
assertEquals("Names are not equal", str, acl.getName());
acl.setName(pr, newStr);
assertEquals("Names are not equal", newStr, acl.getName());
} catch (Exception ex) {
fail("Unexpected exception " + ex);
}
try {
acl.setName(new PrincipalImpl("NewPrincipal"), str);
fail("NotOwnerException was not thrown");
} catch (NotOwnerException noe) {
//expected
}
}
/**
* @tests java.security.acl.Acl#toString()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "toString",
args = {}
)
public void test_Acl03() {
Principal pr = new PrincipalImpl("TestPrincipal");
String str = "TestName";
MyAcl acl = new MyAcl(pr, str);
AclEntry ae = new AclEntryImpl(pr);
Permission perm = new PermissionImpl("Permission_1");
try {
ae.addPermission(perm);
acl.addEntry(pr, ae);
String res = acl.toString();
assertTrue(res.contains(perm.toString()));
} catch (Exception ex) {
fail("Unexpected exception " + ex);
}
}
/**
* @tests java.security.acl.Acl#entries()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "entries",
args = {}
)
public void test_Acl04() {
Principal pr = new PrincipalImpl("TestPrincipal");
String str = "TestName";
MyAcl acl = new MyAcl(pr, str);
AclEntry ae1 = new AclEntryImpl(pr);
try {
ae1.addPermission(new PermissionImpl("Permission_1"));
acl.addEntry(pr, ae1);
Enumeration en = acl.entries();
Vector v = new Vector();
while (en.hasMoreElements()) {
v.addElement(en.nextElement());
}
assertEquals(v.size(), 1);
} catch (Exception ex) {
fail("Unexpected exception " + ex);
}
}
/**
* @tests java.security.acl.Acl#checkPermission(Principal principal, Permission permission)
* @tests java.security.acl.Acl#getPermissions(Principal principal)
*/
@TestTargets({
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "checkPermission",
args = {java.security.Principal.class, java.security.acl.Permission.class}
),
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getPermissions",
args = {java.security.Principal.class}
)
})
public void test_Acl05() {
Principal pr = new PrincipalImpl("TestPrincipal");
String str = "TestName";
MyAcl acl = new MyAcl(pr, str);
AclEntry ae = new AclEntryImpl(pr);
Permission perm = new PermissionImpl("Permission_1");
try {
ae.addPermission(perm);
acl.addEntry(pr, ae);
//checkPermission verification
assertTrue("Incorrect permission", acl.checkPermission(pr, perm));
assertFalse(acl.checkPermission(pr, new PermissionImpl("Permission_2")));
//getPermissions
Enumeration en = acl.getPermissions(pr);
Vector v = new Vector();
while (en.hasMoreElements()) {
v.addElement(en.nextElement());
}
assertEquals(v.size(), 1);
assertEquals(v.elementAt(0).toString(), perm.toString());
} catch (Exception ex) {
fail("Exception " + ex + " was thrown");
}
}
}
\ No newline at end of file
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package tests.security.acl;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargetClass;
import junit.framework.TestCase;
import java.security.acl.Group;
import java.security.Principal;
import java.util.Enumeration;
import org.apache.harmony.security.tests.support.acl.*;
@TestTargetClass(Group.class)
public class IGroupTest extends TestCase {
class MyGroup extends GroupImpl {
public MyGroup(String str) {
super(str);
}
}
/**
* @tests java.security.acl.Group#addMember(Principal user)
*/
@TestTargets({
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "addMember",
args = {java.security.Principal.class}
),
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "isMember",
args = {java.security.Principal.class}
),
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "removeMember",
args = {java.security.Principal.class}
)
})
public void test_addMember() {
MyGroup gr = new MyGroup("TestOwners");
Principal pr = new PrincipalImpl("TestPrincipal");
try {
assertTrue(gr.addMember(pr));
assertFalse(gr.addMember(pr));
assertTrue(gr.isMember(pr));
assertTrue(gr.removeMember(pr));
assertFalse(gr.isMember(pr));
assertFalse(gr.removeMember(pr));
} catch (Exception e) {
fail("Unexpected exception " + e);
}
}
/**
* @tests java.security.acl.Group#members()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "members",
args = {}
)
public void test_members() {
MyGroup gr = new MyGroup("TestOwners");
Principal pr = new PrincipalImpl("TestPrincipal");
try {
Enumeration en = gr.members();
assertFalse("Not empty enumeration", en.hasMoreElements());
assertTrue(gr.addMember(pr));
assertTrue("Empty enumeration", en.hasMoreElements());
} catch (Exception e) {
fail("Unexpected exception " + e);
}
}
}
\ No newline at end of file
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package tests.security.acl;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargetClass;
import junit.framework.TestCase;
import java.security.acl.Owner;
import java.security.Principal;
import java.security.acl.NotOwnerException;
import java.security.acl.LastOwnerException;
import org.apache.harmony.security.tests.support.acl.*;
@TestTargetClass(Owner.class)
public class IOwnerTest extends TestCase {
class MyOwner extends OwnerImpl {
public MyOwner(Principal pr) {
super(pr);
}
}
/**
* @tests java.security.acl.Owner#isOwner(Principal owner)
*
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "isOwner",
args = {java.security.Principal.class}
)
public void test_isOwner() {
MyOwner mo = new MyOwner(new PrincipalImpl("NewOwner"));
try {
assertFalse("Method returns TRUE", mo.isOwner(new PrincipalImpl("TestOwner")));
assertTrue("Method returns FALSE", mo.isOwner(new PrincipalImpl("NewOwner")));
} catch (Exception ex) {
fail("Unexpected exception " + ex);
}
}
/**
* @tests java.security.acl.Owner#addOwner(Principal caller, Principal owner)
*
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "addOwner",
args = {java.security.Principal.class, java.security.Principal.class}
)
public void test_addOwner() {
Principal p1 = new PrincipalImpl("Owner");
Principal p2 = new PrincipalImpl("AclOwner");
Principal pt = new PrincipalImpl("NewOwner");
MyOwner mo = new MyOwner(p1);
try {
//add new owner - TRUE expected
assertTrue("Method returns FALSE", mo.addOwner(p1, pt));
//add existent owner - FALSE expected
assertFalse("Method returns TRUE", mo.addOwner(p1, pt));
} catch (Exception ex) {
fail("Unexpected exception " + ex);
}
//exception case
try {
mo.addOwner(p2, pt);
fail("NotOwnerException was not thrown");
} catch (NotOwnerException noe) {
//expected
}
}
/**
* @tests java.security.acl.Owner#deleteOwner(Principal caller, Principal owner)
*
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "deleteOwner",
args = {java.security.Principal.class, java.security.Principal.class}
)
public void test_deleteOwner() {
Principal caller = new PrincipalImpl("Owner");
Principal owner1 = new PrincipalImpl("NewOwner1");
Principal owner2 = new PrincipalImpl("NewOwner2");
Principal notCaller = new PrincipalImpl("AclOwner");
MyOwner mo = new MyOwner(caller);
try {
if (!mo.isOwner(owner1)) mo.addOwner(caller, owner1);
if (!mo.isOwner(owner2)) mo.addOwner(caller, owner2);
} catch (Exception e) {
fail("Unexpected exception " + e + " was thrown for addOwner");
}
try {
//remove existent owner - TRUE expected
assertTrue("Method returns FALSE", mo.deleteOwner(caller, owner1));
assertFalse("Object presents in the owner list", mo.isOwner(owner1));
//remove owner which is not part of the list of owners - FALSE expected
assertFalse("Method returns TRUE", mo.deleteOwner(caller, owner1));
assertTrue("Method returns FALSE", mo.deleteOwner(caller, owner2));
} catch (Exception ex) {
fail("Unexpected exception " + ex);
}
//exception case - NotOwnerException
try {
mo.deleteOwner(notCaller, owner1);
fail("NotOwnerException was not thrown");
} catch (NotOwnerException noe) {
//expected
} catch (Exception e) {
fail(e + " was thrown instead of NotOwnerException");
}
//exception case - LastOwnerException
try {
mo.deleteOwner(caller, owner2);
fail("LastOwnerException was not thrown");
} catch (LastOwnerException loe) {
//expected
} catch (Exception e) {
fail(e + " was thrown instead of LastOwnerException");
}
}
}
\ No newline at end of file
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package tests.security.acl;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargetClass;
import junit.framework.TestCase;
import java.security.acl.Permission;
import org.apache.harmony.security.tests.support.acl.*;
@TestTargetClass(Permission.class)
public class IPermissionTest extends TestCase {
class MyPermission extends PermissionImpl {
public MyPermission(String str) {
super(str);
}
}
/**
* @tests java.security.acl.Permission#equals(Object another)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "equals",
args = {java.lang.Object.class}
)
public void test_equals() {
try {
MyPermission mp1 = new MyPermission("TestPermission");
MyPermission mp2 = new MyPermission("NewTestPermission");
Object another = new Object();
assertFalse(mp1.equals(another));
assertFalse(mp1.equals(mp2));
assertTrue(mp1.equals(new MyPermission("TestPermission")));
} catch (Exception e) {
fail("Unexpected exception - subtest1");
}
}
/**
* @tests java.security.acl.Permission#toString()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "toString",
args = {}
)
public void test_toString() {
try {
MyPermission obj = new MyPermission("TestPermission");
String res = obj.toString();
assertEquals(res, "TestPermission");
} catch (Exception e) {
fail("Unexpected exception - subtest2");
}
}
}
\ No newline at end of file
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.harmony.security.tests.support.acl;
import java.security.Principal;
import java.security.acl.*;
import java.util.Enumeration;
import java.util.Vector;
/**
* Additional class for verification AclEntry interface
*/
public class AclEntryImpl implements AclEntry {
private Principal user;
private Vector permissionSet;
private boolean negative;
public AclEntryImpl(Principal principal) {
user = null;
permissionSet = new Vector(10, 10);
negative = false;
user = principal;
}
public AclEntryImpl() {
user = null;
permissionSet = new Vector(10, 10);
negative = false;
}
public boolean setPrincipal(Principal principal) {
if(user != null) {
return false;
} else {
user = principal;
return true;
}
}
public void setNegativePermissions() {
negative = true;
}
public boolean isNegative() {
return negative;
}
public boolean addPermission(Permission permission) {
if(permissionSet.contains(permission)) {
return false;
} else {
permissionSet.addElement(permission);
return true;
}
}
public boolean removePermission(Permission permission) {
return permissionSet.removeElement(permission);
}
public boolean checkPermission(Permission permission) {
return permissionSet.contains(permission);
}
public Enumeration permissions() {
return permissionSet.elements();
}
public String toString() {
StringBuffer stringbuffer = new StringBuffer();
if(negative)
stringbuffer.append("-");
else
stringbuffer.append("+");
if(user instanceof Group)
stringbuffer.append("Group.");
else
stringbuffer.append("User.");
stringbuffer.append((new StringBuilder()).append(user).append("=").toString());
Enumeration enumeration = permissions();
do {
if(!enumeration.hasMoreElements())
break;
Permission permission = (Permission)enumeration.nextElement();
stringbuffer.append(permission);
if(enumeration.hasMoreElements())
stringbuffer.append(",");
} while(true);
return new String(stringbuffer);
}
public synchronized Object clone() {
AclEntryImpl aclentryimpl = new AclEntryImpl(user);
aclentryimpl.permissionSet = (Vector)permissionSet.clone();
aclentryimpl.negative = negative;
return aclentryimpl;
}
public Principal getPrincipal() {
return user;
}
}
\ No newline at end of file
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.harmony.security.tests.support.acl;
import java.security.acl.Acl;
import java.util.*;
final class AclEnumerator implements Enumeration {
Acl acl;
Enumeration u1;
Enumeration u2;
Enumeration g1;
Enumeration g2;
AclEnumerator(Acl acl1, Hashtable hashtable, Hashtable hashtable1, Hashtable hashtable2, Hashtable hashtable3) {
acl = acl1;
u1 = hashtable.elements();
u2 = hashtable2.elements();
g1 = hashtable1.elements();
g2 = hashtable3.elements();
}
public boolean hasMoreElements() {
return u1.hasMoreElements() || u2.hasMoreElements() || g1.hasMoreElements() || g2.hasMoreElements();
}
public Object nextElement() {
Acl acl1 = acl;
if(u2.hasMoreElements()) return u2.nextElement();
if(g1.hasMoreElements()) return g1.nextElement();
if(u1.hasMoreElements()) return u1.nextElement();
if(g2.hasMoreElements()) return g2.nextElement();
return acl1;
}
}
\ No newline at end of file
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.harmony.security.tests.support.acl;
import java.security.Principal;
import java.security.acl.*;
import java.util.*;
/**
* Additional class for verification Acl interface
*/
public class AclImpl extends OwnerImpl implements Acl {
private Hashtable allowedUsersTable;
private Hashtable allowedGroupsTable;
private Hashtable deniedUsersTable;
private Hashtable deniedGroupsTable;
private String aclName;
private Vector zeroSet;
public AclImpl(Principal principal, String s) {
super(principal);
allowedUsersTable = new Hashtable(23);
allowedGroupsTable = new Hashtable(23);
deniedUsersTable = new Hashtable(23);
deniedGroupsTable = new Hashtable(23);
aclName = null;
zeroSet = new Vector(1, 1);
try {
setName(principal, s);
} catch(Exception exception) { }
}
public void setName(Principal principal, String s)
throws NotOwnerException {
if(!isOwner(principal)) {
throw new NotOwnerException();
} else {
aclName = s;
return;
}
}
public String getName() {
return aclName;
}
public synchronized boolean addEntry(Principal principal, AclEntry aclentry)
throws NotOwnerException {
if(!isOwner(principal)) throw new NotOwnerException();
Hashtable hashtable = findTable(aclentry);
Principal principal1 = aclentry.getPrincipal();
if(hashtable.get(principal1) != null) {
return false;
} else {
hashtable.put(principal1, aclentry);
return true;
}
}
public synchronized boolean removeEntry(Principal principal, AclEntry aclentry)
throws NotOwnerException {
if(!isOwner(principal)) {
throw new NotOwnerException();
} else {
Hashtable hashtable = findTable(aclentry);
Principal principal1 = aclentry.getPrincipal();
Object obj = hashtable.remove(principal1);
return obj != null;
}
}
public synchronized Enumeration getPermissions(Principal principal) {
Enumeration enumeration2 = subtract(getGroupPositive(principal), getGroupNegative(principal));
Enumeration enumeration3 = subtract(getGroupNegative(principal), getGroupPositive(principal));
Enumeration enumeration = subtract(getIndividualPositive(principal), getIndividualNegative(principal));
Enumeration enumeration1 = subtract(getIndividualNegative(principal), getIndividualPositive(principal));
Enumeration enumeration4 = subtract(enumeration2, enumeration1);
Enumeration enumeration5 = union(enumeration, enumeration4);
enumeration = subtract(getIndividualPositive(principal), getIndividualNegative(principal));
enumeration1 = subtract(getIndividualNegative(principal), getIndividualPositive(principal));
enumeration4 = subtract(enumeration3, enumeration);
Enumeration enumeration6 = union(enumeration1, enumeration4);
return subtract(enumeration5, enumeration6);
}
public boolean checkPermission(Principal principal, Permission permission) {
for(Enumeration enumeration = getPermissions(principal); enumeration.hasMoreElements();) {
Permission permission1 = (Permission)enumeration.nextElement();
if(permission1.equals(permission))
return true;
}
return false;
}
public synchronized Enumeration entries() {
return new AclEnumerator(this, allowedUsersTable, allowedGroupsTable, deniedUsersTable, deniedGroupsTable);
}
public String toString() {
StringBuffer stringbuffer = new StringBuffer();
for(Enumeration enumeration = entries(); enumeration.hasMoreElements(); stringbuffer.append("\n")) {
AclEntry aclentry = (AclEntry)enumeration.nextElement();
stringbuffer.append(aclentry.toString().trim());
}
return stringbuffer.toString();
}
private Hashtable findTable(AclEntry aclentry) {
Hashtable hashtable = null;
Principal principal = aclentry.getPrincipal();
if(principal instanceof Group) {
if(aclentry.isNegative())
hashtable = deniedGroupsTable;
else
hashtable = allowedGroupsTable;
} else
if(aclentry.isNegative())
hashtable = deniedUsersTable;
else
hashtable = allowedUsersTable;
return hashtable;
}
private static Enumeration union(Enumeration enumeration, Enumeration enumeration1) {
Vector vector = new Vector(20, 20);
for(; enumeration.hasMoreElements(); vector.addElement(enumeration.nextElement()));
do {
if(!enumeration1.hasMoreElements())
break;
Object obj = enumeration1.nextElement();
if(!vector.contains(obj))
vector.addElement(obj);
} while(true);
return vector.elements();
}
private Enumeration subtract(Enumeration enumeration, Enumeration enumeration1) {
Vector vector = new Vector(20, 20);
for(; enumeration.hasMoreElements(); vector.addElement(enumeration.nextElement()));
do {
if(!enumeration1.hasMoreElements())
break;
Object obj = enumeration1.nextElement();
if(vector.contains(obj))
vector.removeElement(obj);
} while(true);
return vector.elements();
}
private Enumeration getGroupPositive(Principal principal) {
Enumeration enumeration = zeroSet.elements();
Enumeration enumeration1 = allowedGroupsTable.keys();
do {
if(!enumeration1.hasMoreElements())
break;
Group group = (Group)enumeration1.nextElement();
if(group.isMember(principal)) {
AclEntry aclentry = (AclEntry)allowedGroupsTable.get(group);
enumeration = union(aclentry.permissions(), enumeration);
}
} while(true);
return enumeration;
}
private Enumeration getGroupNegative(Principal principal) {
Enumeration enumeration = zeroSet.elements();
Enumeration enumeration1 = deniedGroupsTable.keys();
do {
if(!enumeration1.hasMoreElements())
break;
Group group = (Group)enumeration1.nextElement();
if(group.isMember(principal)) {
AclEntry aclentry = (AclEntry)deniedGroupsTable.get(group);
enumeration = union(aclentry.permissions(), enumeration);
}
} while(true);
return enumeration;
}
private Enumeration getIndividualPositive(Principal principal) {
Enumeration enumeration = zeroSet.elements();
AclEntry aclentry = (AclEntry)allowedUsersTable.get(principal);
if(aclentry != null)
enumeration = aclentry.permissions();
return enumeration;
}
private Enumeration getIndividualNegative(Principal principal) {
Enumeration enumeration = zeroSet.elements();
AclEntry aclentry = (AclEntry)deniedUsersTable.get(principal);
if(aclentry != null)
enumeration = aclentry.permissions();
return enumeration;
}
}
\ No newline at end of file
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.harmony.security.tests.support.acl;
import java.security.Principal;
import java.security.acl.Group;
import java.util.Enumeration;
import java.util.Vector;
/**
* Additional class for verification Group interface
*/
public class GroupImpl implements Group {
private Vector groupMembers;
private String group;
public GroupImpl(String s) {
groupMembers = new Vector(50, 100);
group = s;
}
public boolean addMember(Principal principal) {
if(groupMembers.contains(principal))
return false;
if(group.equals(principal.toString())) {
throw new IllegalArgumentException();
} else {
groupMembers.addElement(principal);
return true;
}
}
public boolean removeMember(Principal principal) {
return groupMembers.removeElement(principal);
}
public Enumeration members() {
return groupMembers.elements();
}
public boolean equals(Object obj) {
if(this == obj)
return true;
if(!(obj instanceof Group)) {
return false;
} else {
Group group1 = (Group)obj;
return group.equals(group1.toString());
}
}
public boolean equals(Group group1) {
return equals(group1);
}
public String toString() {
return group;
}
public int hashCode() {
return group.hashCode();
}
public boolean isMember(Principal principal) {
if(groupMembers.contains(principal)) {
return true;
} else {
Vector vector = new Vector(10);
return isMemberRecurse(principal, vector);
}
}
public String getName() {
return group;
}
boolean isMemberRecurse(Principal principal, Vector vector) {
for(Enumeration enumeration = members(); enumeration.hasMoreElements();) {
boolean flag = false;
Principal principal1 = (Principal)enumeration.nextElement();
if(principal1.equals(principal))
return true;
if(principal1 instanceof GroupImpl) {
GroupImpl groupimpl = (GroupImpl)principal1;
vector.addElement(this);
if(!vector.contains(groupimpl))
flag = groupimpl.isMemberRecurse(principal, vector);
} else if(principal1 instanceof Group) {
Group group1 = (Group)principal1;
if(!vector.contains(group1)) flag = group1.isMember(principal);
}
if(flag) return flag;
}
return false;
}
}
\ No newline at end of file
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.harmony.security.tests.support.acl;
import java.security.Principal;
import java.security.acl.*;
import java.util.Enumeration;
/**
* Additional class for verification Owner interface
*/
public class OwnerImpl implements Owner {
private Group ownerGroup;
public OwnerImpl(Principal principal) {
ownerGroup = new GroupImpl("AclOwners");
ownerGroup.addMember(principal);
}
public synchronized boolean addOwner(Principal principal, Principal principal1)
throws NotOwnerException {
if(!isOwner(principal))
{
throw new NotOwnerException();
} else {
if (ownerGroup.isMember(principal1)) return false;
if (!ownerGroup.isMember(principal1)) {
ownerGroup.addMember(principal1);
return true;
}
}
return false;
}
public synchronized boolean deleteOwner(Principal principal, Principal principal1)
throws NotOwnerException, LastOwnerException {
if(!isOwner(principal)) throw new NotOwnerException();
Enumeration enumeration = ownerGroup.members();
Object obj = enumeration.nextElement();
if(enumeration.hasMoreElements()) {
return ownerGroup.removeMember(principal1);
} else {
throw new LastOwnerException();
}
}
public synchronized boolean isOwner(Principal principal)
{
return ownerGroup.isMember(principal);
}
}
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.harmony.security.tests.support.acl;
import java.security.acl.Permission;
/**
* Additional class for verification Permission interface
*/
public class PermissionImpl implements Permission {
private String permission;
public PermissionImpl(String s) {
permission = s;
}
public boolean equals(Object obj) {
if(obj instanceof Permission) {
Permission permission1 = (Permission)obj;
return permission.equals(permission1.toString());
} else {
return false;
}
}
public String toString() {
return permission;
}
/* public int hashCode() {
return toString().hashCode();
}*/
}
\ No newline at end of file
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.harmony.security.tests.support.acl;
import java.security.Principal;
/**
* Additional class for verification Principal interface
*/
public class PrincipalImpl implements Principal {
private String user;
public PrincipalImpl(String s) {
user = s;
}
public boolean equals(Object obj) {
if(obj instanceof PrincipalImpl) {
PrincipalImpl principalimpl = (PrincipalImpl)obj;
return user.equals(principalimpl.toString());
} else {
return false;
}
}
public String toString() {
return user;
}
public int hashCode() {
return user.hashCode();
}
public String getName() {
return user;
}
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment