You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@river.apache.org by pe...@apache.org on 2010/07/22 13:14:16 UTC
svn commit: r966578 - in /incubator/river/jtsk/trunk:
src/org/apache/river/imp/security/policy/se/ src/org/apache/river/imp/util/
test/src/org/apache/river/imp/security/policy/se/
Author: peter_firmstone
Date: Thu Jul 22 11:14:16 2010
New Revision: 966578
URL: http://svn.apache.org/viewvc?rev=966578&view=rev
Log:
Clean up and minor refactoring of unused classes and methods in org.apache.river.* namespace.
Removed:
incubator/river/jtsk/trunk/src/org/apache/river/imp/util/DependantTask.java
incubator/river/jtsk/trunk/src/org/apache/river/imp/util/PriorityHandler.java
Modified:
incubator/river/jtsk/trunk/src/org/apache/river/imp/security/policy/se/ConcurrentPermissions.java
incubator/river/jtsk/trunk/src/org/apache/river/imp/security/policy/se/MultiReadPermissionCollection.java
incubator/river/jtsk/trunk/src/org/apache/river/imp/security/policy/se/PermissionPendingResolutionCollection.java
incubator/river/jtsk/trunk/test/src/org/apache/river/imp/security/policy/se/ConcurrentPermissionsTest.java
incubator/river/jtsk/trunk/test/src/org/apache/river/imp/security/policy/se/MultiReadPermissionCollectionTest.java
Modified: incubator/river/jtsk/trunk/src/org/apache/river/imp/security/policy/se/ConcurrentPermissions.java
URL: http://svn.apache.org/viewvc/incubator/river/jtsk/trunk/src/org/apache/river/imp/security/policy/se/ConcurrentPermissions.java?rev=966578&r1=966577&r2=966578&view=diff
==============================================================================
--- incubator/river/jtsk/trunk/src/org/apache/river/imp/security/policy/se/ConcurrentPermissions.java (original)
+++ incubator/river/jtsk/trunk/src/org/apache/river/imp/security/policy/se/ConcurrentPermissions.java Thu Jul 22 11:14:16 2010
@@ -70,7 +70,7 @@ import java.util.concurrent.ConcurrentHa
* @serial permsMap
*/
public final class ConcurrentPermissions extends PermissionCollection
-implements Serializable, RevokeablePermissionCollection {
+implements Serializable {
private static final long serialVersionUID=1L;
/* unresolved is never returned or allowed to escape, it's elements() method
@@ -118,22 +118,19 @@ implements Serializable, RevokeablePermi
if (pc != null){
pc.add(permission);
return;
- }
- // A null instance occurs when a PermissionCollection was absent.
- pc = permsMap.putIfAbsent(permission.getClass(), new MultiReadPermissionCollection(permission));
- // If This is the first time the PermissionCollection was added
- // we must still add the permission, see Add the permission below.
- // The putIfAbsent will succeed, and as a result pc is null, provided another
- // thread doesn't add the permission between this put and the last get.
- // Just in case, we check the return value of the putIfAbsent, if
- // pc != null then another thread has alreaddy added a PermissionCollection
- if (pc != null){
- pc.add(permission);
- return;
- }
- // Add the permission if it missed out due to unlucky timing.
- pc = permsMap.get(permission.getClass());
- pc.add(permission);
+ } else {
+ PermissionCollection fresh = permission.newPermissionCollection();
+ if (fresh == null) {
+ fresh = new MultiReadPermissionCollection(permission);
+ } else {
+ fresh.add(permission);
+ }
+ PermissionCollection existed =
+ permsMap.putIfAbsent(permission.getClass(), fresh);
+ if (existed != null) {
+ existed.add(permission);
+ }
+ }
}
/**
@@ -160,7 +157,7 @@ implements Serializable, RevokeablePermi
pc = existed;
}
}
- unresolved.resolveCollection(permission, pc); // drop the returned collection its the same as the one passed in.
+ unresolved.resolveCollection(permission, pc);
return pc.implies(permission);
}
@@ -172,13 +169,21 @@ implements Serializable, RevokeablePermi
* Any number of these Enumerations may be utilised , each accessed by
* a separate thread.
*
- * This Enumeration may contain duplicates
+ * This Enumeration may contain duplicates and it may contain UnresolvedPermission's
+ * that have been resolved and are present in the returned Enumeration.
*
* @return Enumeration<Permission>
*/
@Override
public Enumeration<Permission> elements() {
- Enumeration<PermissionCollection> perms = permsMap.elements();
+ ArrayList<PermissionCollection> elem =
+ new ArrayList<PermissionCollection>(permsMap.size()
+ + unresolved.awaitingResolution() + 2);
+ if (unresolved.awaitingResolution() > 0) {
+ elem.add(unresolved);
+ }
+ elem.addAll(permsMap.values());
+ Iterator<PermissionCollection> perms = elem.iterator();
return new PermissionEnumerator(perms);
}
@@ -200,26 +205,24 @@ implements Serializable, RevokeablePermi
* PermissionCollection's underlying state is protected by defensive copying,
* it wont affect the thread safety of ConcurrentPermission.
*
- * This enumeration doesn't include unresolved permissions is that a problem?
- *
* Any number of these Enumerations may be utilised , each accessed by
* a separate thread.
*
* @author Peter Firmstone
*/
private final static class PermissionEnumerator implements Enumeration<Permission> {
- private final Enumeration<PermissionCollection> epc;
+ private final Iterator<PermissionCollection> epc;
private volatile Enumeration<Permission> currentPermSet;
- PermissionEnumerator(Enumeration<PermissionCollection> epc){
+ PermissionEnumerator(Iterator<PermissionCollection> epc){
this.epc = epc;
currentPermSet = getNextPermSet();
}
private Enumeration<Permission> getNextPermSet(){
Set<Permission> permissionSet = new HashSet<Permission>();
- if (epc.hasMoreElements()){
- PermissionCollection pc = epc.nextElement();
+ if (epc.hasNext()){
+ PermissionCollection pc = epc.next();
/* Local copy of the set containing a snapshot of
* references to Permission objects present at an instant in time,
* we can Enumerate over, without contention or exception.
@@ -233,6 +236,14 @@ implements Serializable, RevokeablePermi
permissionSet.add(e.nextElement());
}
}
+ } else if ( pc instanceof PermissionPendingResolutionCollection ){
+ Enumeration<Permission> e = pc.elements();
+ while (e.hasMoreElements()) {
+ PermissionPendingResolution p =
+ (PermissionPendingResolution) e.nextElement();
+ UnresolvedPermission up = p.asUnresolvedPermission();
+ permissionSet.add(up);
+ }
} else {
Enumeration<Permission> e = pc.elements();
while (e.hasMoreElements()) {
@@ -258,74 +269,4 @@ implements Serializable, RevokeablePermi
}
}
- public int revoke(Permission ... permissions) {
-
- // build a hashmap to put all permissions into, grouped by class.
- HashMap<Class<?>, Integer> results = new HashMap<Class<?>, Integer>();
- HashMap<Class<?>, ArrayList<Permission>> groups = new HashMap<Class<?>, ArrayList<Permission>>();
- int size = permissions.length;
- for (int i = 0; i < size; i++ ){
- Permission permission = permissions[i];
- //Make sure that any unresolved permissions have been resolved first
- //Don't bother revoking if it doesn't imply
- if ( !implies(permission)){
- continue;
- }
- ArrayList<Permission> permissionClassGroup = groups.get(permission.getClass());
- if (permissionClassGroup == null){
- permissionClassGroup = new ArrayList<Permission>();
- groups.put(permissions[i].getClass(), permissionClassGroup);
- }
- permissionClassGroup.add(permission); // still holds a reference
- }
- // process each group by class, if all succeed return 1, if one or more has
- // an issue with an intervening write return 0.
- // If any fail, return -1
- Set<Class<?>> classes = groups.keySet();
- Iterator<Class<?>> itr = classes.iterator();
- while (itr.hasNext()){
- Class<?> permissionClass = itr.next();
- RevokeablePermissionCollection current =
- (RevokeablePermissionCollection) permsMap.get(permissionClass);
- int result = 1; // If it doesn't exist then it must succeed.
- if (current != null){
- ArrayList<Permission> permissionGroupToRevoke = groups.get(permissionClass);
- Permission permissionList[] = new Permission[permissionGroupToRevoke.size()];
- permissionGroupToRevoke.toArray(permissionList);
- result = current.revoke( permissionList );
- }
- results.put(permissionClass, result);
- }
- // Now determine the results and return
- int result = 1;
- Iterator<Integer> itresult = results.values().iterator();
- while (itresult.hasNext()){
- int thisResult = itresult.next();
- if (thisResult < result) { result = thisResult; }
- }
- return result;
- }
-
-
- public void revokeAll(Permission permission) {
- PermissionCollection pc = permsMap.get(permission.getClass());
- if ( pc == null ){
- pc = new MultiReadPermissionCollection(permission);
- PermissionCollection exists = permsMap.putIfAbsent(permission.getClass(),pc);
- if ( exists != null ){
- pc = exists;
- }
- unresolved.resolveCollection(permission, pc);
- }
- // Any permissions added by other threads in the interim will be
- // revoked when this method completes.
- // We won't avoid permission loss by only emptying the collection either,
- // however since
- // the intent will be probably to temporarily revoke a permission
- // when a proxy is required to be refreshed, it should be more efficient.
- //permsMap.remove(permission.getClass(), pc);
- RevokeablePermissionCollection rpc = (RevokeablePermissionCollection) pc;
- rpc.revokeAll(permission);
- }
-
}
Modified: incubator/river/jtsk/trunk/src/org/apache/river/imp/security/policy/se/MultiReadPermissionCollection.java
URL: http://svn.apache.org/viewvc/incubator/river/jtsk/trunk/src/org/apache/river/imp/security/policy/se/MultiReadPermissionCollection.java?rev=966578&r1=966577&r2=966578&view=diff
==============================================================================
--- incubator/river/jtsk/trunk/src/org/apache/river/imp/security/policy/se/MultiReadPermissionCollection.java (original)
+++ incubator/river/jtsk/trunk/src/org/apache/river/imp/security/policy/se/MultiReadPermissionCollection.java Thu Jul 22 11:14:16 2010
@@ -46,13 +46,12 @@ import java.util.logging.Logger;
* @author Peter Firmstone
*/
public final class MultiReadPermissionCollection extends PermissionCollection
- implements RevokeablePermissionCollection, Serializable {
+ implements Serializable {
private final static long serialVersionUID = 1L;
private transient PermissionCollection permCl; // all access protected by rwl
private final transient ReadWriteLock rwl;
private final transient Lock rl;
private final transient Lock wl;
- private transient int writeCounter; // all access protected by rwl
private boolean readOnly; // all access protected by rwl
private Permission[] permissions; //never instantiate for ide code completion
@@ -61,7 +60,6 @@ public final class MultiReadPermissionCo
rwl = new ReentrantReadWriteLock();
rl = rwl.readLock();
wl = rwl.writeLock();
- writeCounter = 0;
readOnly = false;
}
@@ -118,7 +116,6 @@ public final class MultiReadPermissionCo
wl.lock();
try {
permCl.add(permission);
- writeCounter++;
}
finally {wl.unlock();}
}
@@ -146,109 +143,7 @@ public final class MultiReadPermissionCo
pc = new PermissionHash();
}
return pc;
- }
- /**
- * Permissions may have some overlap, this method will remove any Permission
- * objects that imply any of the Permission's supplied.
- *
- * If this fails it will be due to the implies method returning true
- * due to a combination of Permission objects.
- *
- * Permission objects must have the same class and type for this implementation.
- *
- * @param permissions
- * @return success
- */
- public int revoke(Permission ... permissions) {
- int count = 0; // false
- HashSet<Permission> permissionSet = new HashSet<Permission>();
- rl.lock();
- try {
- if (readOnly) {
- throw new SecurityException("attempt to remove a Permission from a readonly Permissions object");
- }
- count = writeCounter;
- Enumeration<Permission> current = elements();
- while (current.hasMoreElements()) {
- permissionSet.add(current.nextElement());
- }
- } finally {
- rl.unlock();
- }
- if (permissionSet.size() == 0) {
- return 1; // true
- }
- Iterator<Permission> itr = permissionSet.iterator();
- PermissionCollection newCollection = null;
- int size = permissions.length;
- PER:
- while (itr.hasNext() ){
- Permission p = itr.next();
- if (newCollection == null) {
- newCollection = p.newPermissionCollection();
- if (newCollection == null ){
- newCollection = new PermissionHash();
- }
- }
- for (int i = 0; i < size; i++) {
- if (p.implies(permissions[i])) {
- continue PER;
- }
- }
- newCollection.add(p); // if the wrong type is passed in it doesn't matter
- }
- /* Check that our modifications have been effective.
- */
- for (int i = 0; i < size ; i++){
- if ( newCollection.implies(permissions[i])) { return -1;} // fail
- }
- return updatePermissionCollection(newCollection, count);
- }
-
- /**
- * Idempotent method to remove all Permissions Contained within a
- * PermissionCollection. Method fails if PermissionCollection is
- * modified during method execution. This method
- * creates an empty replacement PermissionCollection.
- *
- * This method also resets setReadOnly() to false;
- *
- * @param permission
- */
- public void revokeAll(Permission permission) {
- boolean sameClassType = false;
- int count = 0;
- rl.lock();
- try {
- Enumeration<Permission> current = elements();
- Permission currentPerm = null;
- if (current.hasMoreElements()) {
- currentPerm = current.nextElement();
- }
- if (currentPerm == null) { return; } // idempotent, already empty.
- if (currentPerm.getClass().equals(permission.getClass())){ sameClassType = true;}
- } finally { rl.unlock(); }
- PermissionCollection newCollection = permission.newPermissionCollection();
- if (newCollection == null) { newCollection = new PermissionHash(); }
- if (sameClassType == true){
- updatePermissionCollection(newCollection, count);
- }
- }
-
- private int updatePermissionCollection( PermissionCollection pc, int writeCount ){
- wl.lock();
- try {
- if ( writeCount == writeCounter || writeCount == 0 ) {
- permCl = pc;
- writeCounter = 0; //Reset the counter
- if (writeCount == 0) {readOnly = false;}
- return 1;
- }
- } finally {
- wl.unlock();
- }
- return 0;
- }
+ }
private static class SerializationProxy implements Serializable {
private static final long serialVersionUID = 1L;
Modified: incubator/river/jtsk/trunk/src/org/apache/river/imp/security/policy/se/PermissionPendingResolutionCollection.java
URL: http://svn.apache.org/viewvc/incubator/river/jtsk/trunk/src/org/apache/river/imp/security/policy/se/PermissionPendingResolutionCollection.java?rev=966578&r1=966577&r2=966578&view=diff
==============================================================================
--- incubator/river/jtsk/trunk/src/org/apache/river/imp/security/policy/se/PermissionPendingResolutionCollection.java (original)
+++ incubator/river/jtsk/trunk/src/org/apache/river/imp/security/policy/se/PermissionPendingResolutionCollection.java Thu Jul 22 11:14:16 2010
@@ -40,6 +40,9 @@ import java.util.concurrent.atomic.Atomi
public class PermissionPendingResolutionCollection extends PermissionCollection {
private static final long serialVersionUID = 1L;
private ConcurrentHashMap<String,Collection<PermissionPendingResolution>> klasses;
+ // This is a best effort counter, it doesn't try to identify duplicates.
+ // If it equals 0, it definitely has no pendings, however it may be greater
+ // than 0 and have no pending Permission's for resolution.
private AtomicInteger pending;
PermissionPendingResolutionCollection(){
klasses = new ConcurrentHashMap<String,Collection<PermissionPendingResolution>>(2);
@@ -83,8 +86,8 @@ public class PermissionPendingResolution
PermissionCollection holder ){
if (pending.get() == 0) { return holder; }
String klass = target.getClass().getName();
- if (klasses.containsKey(klass)) {
- Collection<PermissionPendingResolution> klassMates = klasses.get(klass);
+ Collection<PermissionPendingResolution> klassMates = klasses.remove(klass);
+ if (klassMates != null) {
for (Iterator<PermissionPendingResolution> iter = klassMates.iterator(); iter.hasNext();) {
PermissionPendingResolution element = iter.next();
Permission resolved = element.resolve(target.getClass());
@@ -97,7 +100,15 @@ public class PermissionPendingResolution
pending.decrementAndGet();
}
}
- // there is no possible way of atomic removal of an empty Collection.
+ // If for some reason something wasn't resolved we better put it back
+ // We should never get here, should I throw an exception instead?
+ if (klassMates.size() > 0 ) {
+ Collection<PermissionPendingResolution> existed
+ = klasses.putIfAbsent(klass, klassMates);
+ if ( existed != null ) {
+ existed.addAll(klassMates);
+ }
+ }
}
return holder;
}
Modified: incubator/river/jtsk/trunk/test/src/org/apache/river/imp/security/policy/se/ConcurrentPermissionsTest.java
URL: http://svn.apache.org/viewvc/incubator/river/jtsk/trunk/test/src/org/apache/river/imp/security/policy/se/ConcurrentPermissionsTest.java?rev=966578&r1=966577&r2=966578&view=diff
==============================================================================
--- incubator/river/jtsk/trunk/test/src/org/apache/river/imp/security/policy/se/ConcurrentPermissionsTest.java (original)
+++ incubator/river/jtsk/trunk/test/src/org/apache/river/imp/security/policy/se/ConcurrentPermissionsTest.java Thu Jul 22 11:14:16 2010
@@ -8,10 +8,12 @@ package org.apache.river.imp.security.po
import java.lang.reflect.ReflectPermission;
import java.net.NetPermission;
import java.security.Permission;
+import java.security.PermissionCollection;
import java.security.Permissions;
import java.security.UnresolvedPermission;
import java.util.ArrayList;
import java.util.Enumeration;
+import java.util.List;
import java.util.PropertyPermission;
import java.util.logging.LoggingPermission;
import net.jini.security.AuthenticationPermission;
@@ -140,68 +142,61 @@ public class ConcurrentPermissionsTest {
}
/**
- * Test of revoke method, of class MultiReadPermissionCollection.
+ * This tests the ability of the ConcurrentPermission to return
+ * UnresolvedPermission's via an Enumerator.
*/
@org.junit.Test
- public void revoke() {
- System.out.println("revoke");
+ public void resolvesAndReturnsEnumerator() {
+ System.out.println("resolves and returns Enumerators correctly");
Permission permission0 = new ReflectPermission ("suppressAccessChecks");
Permission permission1 = new PropertyPermission ("sun.security.key.serial.interop", "read");
Permission permission2 = new NetPermission ("specifyStreamHandler");
- RevokeablePermissionCollection instance = new ConcurrentPermissions();
+ Permission permission3 = new UnresolvedPermission("java.net.NetPermission",
+ "specifyStreamHandler", null, null);
+ PermissionCollection instance = new ConcurrentPermissions();
instance.add(permission0);
instance.add(permission1);
- instance.add(permission2);
+ instance.add(permission3);
+ List<Permission> expectedResult = new ArrayList<Permission>(3);
+ expectedResult.add(permission0);
+ expectedResult.add(permission1);
+ expectedResult.add(permission3);
+ Enumeration<Permission> en = instance.elements();
+ List<Permission> result = new ArrayList<Permission>(3);
+ while (en.hasMoreElements()){
+ result.add(en.nextElement());
+ }
+ assertTrue(expectedResult.equals(result));
assertTrue(instance.implies(permission0));
assertTrue(instance.implies(permission1));
assertTrue(instance.implies(permission2));
- int result = instance.revoke(permission1, permission0 , permission2);
- int expectedResult = 1;
- assertEquals(expectedResult, result);
- assertFalse(instance.implies(permission0));
- assertFalse(instance.implies(permission1));
- assertFalse(instance.implies(permission2));
+ en = instance.elements();
+ result = new ArrayList<Permission>(3);
+ while (en.hasMoreElements()){
+ result.add(en.nextElement());
+ }
+ expectedResult = new ArrayList<Permission>(3);
+ expectedResult.add(permission0);
+ expectedResult.add(permission1);
+ expectedResult.add(permission2);
+ assertTrue(result.containsAll(expectedResult));
}
/**
- * Test of revoke method, of class MultiReadPermissionCollection.
- * This test adds an UnresolvedPermission, the revoke() method
- * must first attempt to resolve any UnresolvedPermission's before
- * revoking
- *
+ * This test adds an UnresolvedPermission, the implies() method
+ * must resolve any UnresolvedPermission's.
*/
@org.junit.Test
- public void revokeUnresolvedPermission() {
- System.out.println("revokeUnresolvedPermission");
+ public void resolvesUnresolvedPermission() {
+ System.out.println("resolveUnresolvedPermission");
Permission permission2 = new NetPermission ("specifyStreamHandler");
Permission permission3 = new UnresolvedPermission("java.net.NetPermission",
"specifyStreamHandler", null, null);
- RevokeablePermissionCollection instance = new ConcurrentPermissions();
+ PermissionCollection instance = new ConcurrentPermissions();
instance.add(permission3);
- //We don't check implies for permission2, that would cause resolution.
+ //check implies for permission2, that will cause resolution.
assertFalse(instance.implies(permission3));
- int result = instance.revoke( permission2);
- int expectedResult = 1;
- assertEquals(expectedResult, result);
- assertFalse(instance.implies(permission2));
- }
-
- /**
- * Test of revokeAll method, of class MultiReadPermissionCollection.
- */
- @org.junit.Test
- public void revokeAll() {
- System.out.println("revokeAll");
- Permission permission0 = new ReflectPermission ("suppressAccessChecks");
- Permission permission1 = new PropertyPermission ("sun.security.key.serial.interop", "read");
- Permission permission2 = new NetPermission ("specifyStreamHandler");
- RevokeablePermissionCollection instance = new ConcurrentPermissions();
- instance.add(permission0);
- instance.add(permission1);
- instance.add(permission2);
- instance.revokeAll(permission1);
- boolean result = instance.implies(permission1);
- assertEquals(false, result);
+ assertTrue(instance.implies( permission2));
}
Modified: incubator/river/jtsk/trunk/test/src/org/apache/river/imp/security/policy/se/MultiReadPermissionCollectionTest.java
URL: http://svn.apache.org/viewvc/incubator/river/jtsk/trunk/test/src/org/apache/river/imp/security/policy/se/MultiReadPermissionCollectionTest.java?rev=966578&r1=966577&r2=966578&view=diff
==============================================================================
--- incubator/river/jtsk/trunk/test/src/org/apache/river/imp/security/policy/se/MultiReadPermissionCollectionTest.java (original)
+++ incubator/river/jtsk/trunk/test/src/org/apache/river/imp/security/policy/se/MultiReadPermissionCollectionTest.java Thu Jul 22 11:14:16 2010
@@ -73,7 +73,7 @@ public class MultiReadPermissionCollecti
public void implies() {
System.out.println("add");
Permission permission = new RuntimePermission("getClassLoader");
- RevokeablePermissionCollection instance = new MultiReadPermissionCollection(permission);
+ PermissionCollection instance = new MultiReadPermissionCollection(permission);
instance.add(permission);
boolean result = instance.implies(permission);
assertEquals(true, result);
@@ -88,7 +88,7 @@ public class MultiReadPermissionCollecti
Permission permission0 = new AccessPermission("org.some.class");
Permission permission1 = new AccessPermission("org.some.other.class");
Permission permission2 = new AccessPermission("org.another.class");
- RevokeablePermissionCollection instance = new MultiReadPermissionCollection(permission0);
+ PermissionCollection instance = new MultiReadPermissionCollection(permission0);
instance.add(permission0);
instance.add(permission1);
instance.add(permission2);
@@ -106,47 +106,6 @@ public class MultiReadPermissionCollecti
assertEquals(expRes, res);
}
- /**
- * Test of revoke method, of class MultiReadPermissionCollection.
- */
- @org.junit.Test
- public void revoke() {
- System.out.println("revoke");
- Permission permission0 = new AccessPermission("org.some.class");
- Permission permission1 = new AccessPermission("org.some.other.class");
- Permission permission2 = new AccessPermission("org.another.class");
- RevokeablePermissionCollection instance = new MultiReadPermissionCollection(permission0);
- instance.add(permission0);
- instance.add(permission1);
- instance.add(permission2);
- instance.revoke(permission1);
- boolean result = instance.implies(permission1);
- assertEquals(false, result);
- }
- /**
- * Test of revokeAll method, of class MultiReadPermissionCollection.
- */
- @org.junit.Test
- public void revokeAll() {
- System.out.println("revokeAll");
- Permission permission0 = new AccessPermission("org.some.class");
- Permission permission1 = new AccessPermission("org.some.other.class");
- Permission permission2 = new AccessPermission("org.another.class");
- RevokeablePermissionCollection instance = new MultiReadPermissionCollection(permission0);
- instance.add(permission0);
- instance.add(permission1);
- instance.add(permission2);
- instance.revokeAll(permission1);
- ArrayList<Permission> expResult = new ArrayList<Permission>();
- Enumeration<Permission> elem = instance.elements();
- ArrayList<Permission> result = new ArrayList<Permission>();
- while (elem.hasMoreElements()){
- result.add(elem.nextElement());
- }
- int expRes = expResult.size();
- int res = result.size();
- assertEquals(expRes, res);
- }
}
\ No newline at end of file