[jboss-cvs] JBossAS SVN: r81237 - projects/naming/branches/Branch_5_0/jnpserver/src/test/java/org/jnp/test.
jboss-cvs-commits at lists.jboss.org
jboss-cvs-commits at lists.jboss.org
Tue Nov 18 11:54:07 EST 2008
Author: adrian at jboss.org
Date: 2008-11-18 11:54:07 -0500 (Tue, 18 Nov 2008)
New Revision: 81237
Modified:
projects/naming/branches/Branch_5_0/jnpserver/src/test/java/org/jnp/test/JndiPermissionUnitTest.java
Log:
More thorough test
Modified: projects/naming/branches/Branch_5_0/jnpserver/src/test/java/org/jnp/test/JndiPermissionUnitTest.java
===================================================================
--- projects/naming/branches/Branch_5_0/jnpserver/src/test/java/org/jnp/test/JndiPermissionUnitTest.java 2008-11-18 16:53:59 UTC (rev 81236)
+++ projects/naming/branches/Branch_5_0/jnpserver/src/test/java/org/jnp/test/JndiPermissionUnitTest.java 2008-11-18 16:54:07 UTC (rev 81237)
@@ -21,18 +21,61 @@
*/
package org.jnp.test;
+import java.security.Permission;
+import java.security.PermissionCollection;
+import java.util.Arrays;
+import java.util.Enumeration;
+import java.util.HashSet;
+
+import javax.naming.CompositeName;
+import javax.naming.Name;
+
import org.jboss.naming.JndiPermission;
+import org.jboss.test.BaseTestCase;
-import junit.framework.TestCase;
-
/**
* Tests of the JndiPermission/JndiPermissionCollection behavior
*
* @author Scott.Stark at jboss.org
+ * @author adrian at jboss.org
* @version $Revision$
*/
-public class JndiPermissionUnitTest extends TestCase
+public class JndiPermissionUnitTest extends BaseTestCase
{
+ private static final String ALL_BINDINGS = "<<ALL BINDINGS>>";
+
+ private static final String[] ACTION_ARRAY = new String[]
+ {
+ JndiPermission.BIND_ACTION,
+ JndiPermission.REBIND_ACTION,
+ JndiPermission.UNBIND_ACTION,
+ JndiPermission.LOOKUP_ACTION,
+ JndiPermission.LIST_ACTION,
+ JndiPermission.LIST_BINDINGS_ACTION,
+ JndiPermission.CREATE_SUBCONTEXT_ACTION,
+ };
+
+ private static final String ALL_ACTIONS;
+
+ static
+ {
+ StringBuilder builder = new StringBuilder();
+ boolean comma = false;
+ for (String action : ACTION_ARRAY)
+ {
+ if (comma)
+ builder.append(',');
+ builder.append(action);
+ comma = true;
+ }
+ ALL_ACTIONS = builder.toString();
+ }
+
+ public JndiPermissionUnitTest(String name)
+ {
+ super(name);
+ }
+
public void testBind()
{
JndiPermission any = new JndiPermission("<<ALL BINDINGS>>", "*");
@@ -50,4 +93,503 @@
assertFalse(path1Recursive+" implies /path1;bind", path1Recursive.implies(p));
}
+
+ public void testConstants()
+ {
+ assertEquals(0, JndiPermission.NONE);
+ assertEquals(1, JndiPermission.BIND);
+ assertEquals(2, JndiPermission.REBIND);
+ assertEquals(4, JndiPermission.UNBIND);
+ assertEquals(8, JndiPermission.LOOKUP);
+ assertEquals(16, JndiPermission.LIST);
+ assertEquals(32, JndiPermission.LIST_BINDINGS);
+ assertEquals(64, JndiPermission.CREATE_SUBCONTEXT);
+ assertEquals(127, JndiPermission.ALL);
+
+ assertEquals("bind", JndiPermission.BIND_ACTION);
+ assertEquals("rebind", JndiPermission.REBIND_ACTION);
+ assertEquals("unbind", JndiPermission.UNBIND_ACTION);
+ assertEquals("lookup", JndiPermission.LOOKUP_ACTION);
+ assertEquals("list", JndiPermission.LIST_ACTION);
+ assertEquals("listBindings", JndiPermission.LIST_BINDINGS_ACTION);
+ assertEquals("createSubcontext", JndiPermission.CREATE_SUBCONTEXT_ACTION);
+ assertEquals("*", JndiPermission.ALL_ACTION);
+ }
+
+ public void testBasicConstructorAllBindings() throws Exception
+ {
+ JndiPermission test = new JndiPermission(ALL_BINDINGS, JndiPermission.BIND_ACTION);
+ assertEquals(ALL_BINDINGS, test.getName());
+ assertEquals(JndiPermission.BIND_ACTION, test.getActions());
+ }
+
+ public void testBasicConstructorSimplePathString() throws Exception
+ {
+ JndiPermission test = new JndiPermission("simple", JndiPermission.BIND_ACTION);
+ assertEquals("simple", test.getName());
+ assertEquals(JndiPermission.BIND_ACTION, test.getActions());
+ }
+
+ /*
+ public void testBasicConstructorSimplePathString2() throws Exception
+ {
+ JndiPermission test = new JndiPermission("/simple", JndiPermission.BIND_ACTION);
+ assertEquals("simple", test.getName());
+ assertEquals(JndiPermission.BIND_ACTION, test.getActions());
+ }
+ */
+
+ public void testBasicConstructorHierarchcicalPathString() throws Exception
+ {
+ JndiPermission test = new JndiPermission("1/2/3", JndiPermission.BIND_ACTION);
+ assertEquals("1/2/3", test.getName());
+ assertEquals(JndiPermission.BIND_ACTION, test.getActions());
+ }
+
+ public void testBasicConstructorWildcardPathString() throws Exception
+ {
+ JndiPermission test = new JndiPermission("1/2/3/*", JndiPermission.BIND_ACTION);
+ assertEquals("1/2/3/*", test.getName());
+ assertEquals(JndiPermission.BIND_ACTION, test.getActions());
+ }
+
+ public void testBasicConstructorRecursivePathString() throws Exception
+ {
+ JndiPermission test = new JndiPermission("1/2/3/-", JndiPermission.BIND_ACTION);
+ assertEquals("1/2/3/-", test.getName());
+ assertEquals(JndiPermission.BIND_ACTION, test.getActions());
+ }
+
+ public void testBasicConstructorSimplePathName() throws Exception
+ {
+ JndiPermission test = new JndiPermission(new CompositeName("simple"), JndiPermission.BIND_ACTION);
+ assertEquals("simple", test.getName());
+ assertEquals(JndiPermission.BIND_ACTION, test.getActions());
+ }
+
+ public void testBasicConstructorHierarchcicalPathName() throws Exception
+ {
+ JndiPermission test = new JndiPermission(new CompositeName("1/2/3"), JndiPermission.BIND_ACTION);
+ assertEquals("1/2/3", test.getName());
+ assertEquals(JndiPermission.BIND_ACTION, test.getActions());
+ }
+
+ public void testBasicConstructorWildcardPathName() throws Exception
+ {
+ JndiPermission test = new JndiPermission(new CompositeName("1/2/3/*"), JndiPermission.BIND_ACTION);
+ assertEquals("1/2/3/*", test.getName());
+ assertEquals(JndiPermission.BIND_ACTION, test.getActions());
+ }
+
+ public void testBasicConstructorRecursivePathName() throws Exception
+ {
+ JndiPermission test = new JndiPermission(new CompositeName("1/2/3/-"), JndiPermission.BIND_ACTION);
+ assertEquals("1/2/3/-", test.getName());
+ assertEquals(JndiPermission.BIND_ACTION, test.getActions());
+ }
+
+ public void testBasicConstructorBadString() throws Exception
+ {
+ try
+ {
+ new JndiPermission((String) null, JndiPermission.ALL_ACTION);
+ fail("Should not be here!");
+ }
+ catch (Exception expected)
+ {
+ checkThrowable(NullPointerException.class, expected);
+ }
+ }
+
+ public void testBasicConstructorBadName() throws Exception
+ {
+ try
+ {
+ new JndiPermission((Name) null, JndiPermission.ALL_ACTION);
+ fail("Should not be here!");
+ }
+ catch (Exception expected)
+ {
+ checkThrowable(NullPointerException.class, expected);
+ }
+ }
+
+ public void testBasicConstructorActions() throws Exception
+ {
+ HashSet<String> previous = new HashSet<String>();
+ testBasicConstructorActions(previous);
+ }
+
+ public void testBasicConstructorActions(HashSet<String> previous) throws Exception
+ {
+ if (previous.size() == ACTION_ARRAY.length)
+ return;
+
+ for (String current : ACTION_ARRAY)
+ {
+ if (previous.contains(current) == false)
+ {
+ HashSet<String> newTest = new HashSet<String>(previous);
+ newTest.add(current);
+
+ StringBuilder builder = new StringBuilder();
+ boolean comma = false;
+ for (String action : newTest)
+ {
+ if (comma)
+ builder.append(',');
+ builder.append(action);
+ comma = true;
+ }
+
+ JndiPermission test = new JndiPermission("simple", builder.toString());
+ assertEquals("simple", test.getName());
+
+ String foundActions = test.getActions();
+ assertNotNull(foundActions);
+ HashSet<String> actual = new HashSet<String>(Arrays.asList(foundActions.split(",")));
+ assertEquals(newTest, actual);
+
+ // Recurse
+ testBasicConstructorActions(newTest);
+ }
+ }
+ }
+
+ /* public void testBasicConstructorActionsSpaces() throws Exception
+ {
+ for (String current : ACTION_ARRAY)
+ {
+ JndiPermission test = new JndiPermission("simple", " " + current);
+ assertEquals("simple", test.getName());
+ assertEquals(current, test.getActions());
+ test = new JndiPermission("simple", current + " ");
+ assertEquals("simple", test.getName());
+ assertEquals(current, test.getActions());
+ test = new JndiPermission("simple", " " + current + " ");
+ assertEquals("simple", test.getName());
+ assertEquals(current, test.getActions());
+ }
+ } */
+
+ public void testBasicConstructorAllAction() throws Exception
+ {
+ JndiPermission all = new JndiPermission("simple", JndiPermission.ALL_ACTION);
+ JndiPermission test = new JndiPermission("simple", ALL_ACTIONS);
+ assertEquals(test, all);
+ }
+
+ public void testBasicConstructorBadActions() throws Exception
+ {
+ try
+ {
+ new JndiPermission("simple", "rubbish");
+ fail("Should not be here!");
+ }
+ catch (Exception expected)
+ {
+ checkThrowable(IllegalArgumentException.class, expected);
+ }
+
+ try
+ {
+ new JndiPermission("simple", "bind,rubbish");
+ fail("Should not be here!");
+ }
+ catch (Exception expected)
+ {
+ checkThrowable(IllegalArgumentException.class, expected);
+ }
+ }
+
+ public void testImpliesSimplePath() throws Exception
+ {
+ JndiPermission test1 = new JndiPermission("simple", JndiPermission.ALL_ACTION);
+ JndiPermission test2 = new JndiPermission("simple", JndiPermission.ALL_ACTION);
+ assertTrue(test2.implies(test1));
+
+ test2 = new JndiPermission("notsimple", JndiPermission.ALL_ACTION);
+ assertFalse(test2.implies(test1));
+
+ test2 = new JndiPermission(ALL_BINDINGS, JndiPermission.ALL_ACTION);
+ assertTrue(test2.implies(test1));
+ }
+
+ public void testImpliesHierarchy() throws Exception
+ {
+ JndiPermission test1 = new JndiPermission("1/2/3", JndiPermission.ALL_ACTION);
+ JndiPermission test2 = new JndiPermission("1/2/3", JndiPermission.ALL_ACTION);
+ assertTrue(test2.implies(test1));
+
+ test2 = new JndiPermission("1", JndiPermission.ALL_ACTION);
+ assertFalse(test2.implies(test1));
+
+ test2 = new JndiPermission("1/2", JndiPermission.ALL_ACTION);
+ assertFalse(test2.implies(test1));
+
+ test2 = new JndiPermission("1/2/4", JndiPermission.ALL_ACTION);
+ assertFalse(test2.implies(test1));
+
+ test2 = new JndiPermission("1/2/3/4", JndiPermission.ALL_ACTION);
+ assertFalse(test2.implies(test1));
+
+ test2 = new JndiPermission(ALL_BINDINGS, JndiPermission.ALL_ACTION);
+ assertTrue(test2.implies(test1));
+ }
+
+ public void testImpliesWildcard() throws Exception
+ {
+ JndiPermission test1 = new JndiPermission("1/2/3", JndiPermission.ALL_ACTION);
+ JndiPermission test2 = new JndiPermission("1/2/*", JndiPermission.ALL_ACTION);
+ assertTrue(test2.implies(test1));
+
+ test2 = new JndiPermission("1/2/3/*", JndiPermission.ALL_ACTION);
+ assertFalse(test2.implies(test1));
+
+ test2 = new JndiPermission("1/4/*", JndiPermission.ALL_ACTION);
+ assertFalse(test2.implies(test1));
+
+ test2 = new JndiPermission("1/*", JndiPermission.ALL_ACTION);
+ assertFalse(test2.implies(test1));
+
+ /*
+ test2 = new JndiPermission("*", JndiPermission.ALL_ACTION);
+ assertFalse(test2.implies(test1));
+
+ test1 = new JndiPermission("1", JndiPermission.ALL_ACTION);
+ assertTrue(test2.implies(test1));
+ */
+
+ test1 = new JndiPermission("1/2/34", JndiPermission.ALL_ACTION);
+ test2 = new JndiPermission("1/2/3*", JndiPermission.ALL_ACTION);
+ assertFalse(test2.implies(test1));
+ }
+
+ public void testImpliesRecursive() throws Exception
+ {
+ JndiPermission test1 = new JndiPermission("1/2/3", JndiPermission.ALL_ACTION);
+ JndiPermission test2 = new JndiPermission("1/2/-", JndiPermission.ALL_ACTION);
+ assertTrue(test2.implies(test1));
+
+ test2 = new JndiPermission("1/-", JndiPermission.ALL_ACTION);
+ assertTrue(test2.implies(test1));
+
+ /*
+ test2 = new JndiPermission("-", JndiPermission.ALL_ACTION);
+ assertTrue(test2.implies(test1));
+ */
+
+ test2 = new JndiPermission("1/2/3/-", JndiPermission.ALL_ACTION);
+ assertFalse(test2.implies(test1));
+
+ test2 = new JndiPermission("1/4/-", JndiPermission.ALL_ACTION);
+ assertFalse(test2.implies(test1));
+
+ test1 = new JndiPermission("1/2/34", JndiPermission.ALL_ACTION);
+ test2 = new JndiPermission("1/2/3-", JndiPermission.ALL_ACTION);
+ assertFalse(test2.implies(test1));
+ }
+
+ public void testImpliesActions() throws Exception
+ {
+ JndiPermission all = new JndiPermission("simple", JndiPermission.ALL_ACTION);
+
+ for (String current : ACTION_ARRAY)
+ {
+ HashSet<String> actions = new HashSet<String>();
+ actions.add(current);
+
+ JndiPermission test = new JndiPermission("simple", current);
+ assertTrue("All implies " + current, all.implies(test));
+ testImpliesActions(actions, test);
+ }
+ }
+
+ public void testImpliesActions(HashSet<String> previous, JndiPermission current) throws Exception
+ {
+ if (previous.size() == ACTION_ARRAY.length)
+ return;
+
+ for (String action : ACTION_ARRAY)
+ {
+ if (previous.contains(action) == false)
+ {
+ HashSet<String> newTest = new HashSet<String>(previous);
+ newTest.add(action);
+
+ StringBuilder builder = new StringBuilder();
+ boolean comma = false;
+ for (String element : newTest)
+ {
+ if (comma)
+ builder.append(',');
+ builder.append(element);
+ comma = true;
+ }
+ String actions = builder.toString();
+
+ JndiPermission test = new JndiPermission("simple", actions);
+ assertTrue(actions + " implies " + current.getActions(), test.implies(current));
+
+ // Recurse
+ testImpliesActions(newTest, current);
+ }
+ }
+ }
+
+ public void testEqualsPath() throws Exception
+ {
+ JndiPermission one = new JndiPermission("1/2/3", JndiPermission.ALL_ACTION);
+ JndiPermission two = new JndiPermission("1/2/3", JndiPermission.ALL_ACTION);
+ assertEquals(one, two);
+ assertEquals(two, one);
+
+ two = new JndiPermission(new CompositeName("1/2/3"), JndiPermission.ALL_ACTION);
+ assertEquals(one, two);
+ assertEquals(two, one);
+
+ two = new JndiPermission("1/2/4", JndiPermission.ALL_ACTION);
+ assertNotSame(one, two);
+ assertNotSame(two, one);
+
+ two = new JndiPermission("1/2/*", JndiPermission.ALL_ACTION);
+ assertNotSame(one, two);
+ assertNotSame(two, one);
+
+ two = new JndiPermission("1/2/-", JndiPermission.ALL_ACTION);
+ assertNotSame(one, two);
+ assertNotSame(two, one);
+
+ two = new JndiPermission(ALL_BINDINGS, JndiPermission.ALL_ACTION);
+ assertNotSame(one, two);
+ assertNotSame(two, one);
+
+ one = new JndiPermission("1/2/*", JndiPermission.ALL_ACTION);
+ two = new JndiPermission("1/2/*", JndiPermission.ALL_ACTION);
+ assertEquals(one, two);
+ assertEquals(two, one);
+
+ one = new JndiPermission("1/2/-", JndiPermission.ALL_ACTION);
+ two = new JndiPermission("1/2/-", JndiPermission.ALL_ACTION);
+ assertEquals(one, two);
+ assertEquals(two, one);
+
+ one = new JndiPermission(ALL_BINDINGS, JndiPermission.ALL_ACTION);
+ two = new JndiPermission(ALL_BINDINGS, JndiPermission.ALL_ACTION);
+ assertEquals(one, two);
+ assertEquals(two, one);
+ }
+
+ public void testEqualsActions() throws Exception
+ {
+ for (String action1 : ACTION_ARRAY)
+ {
+ for (String action2 : ACTION_ARRAY)
+ {
+ JndiPermission one = new JndiPermission("1/2/3", action1);
+ JndiPermission two = new JndiPermission("1/2/3", action1);
+ if (action1.equals(action2))
+ {
+ assertEquals(one, two);
+ assertEquals(two, one);
+ }
+ else
+ {
+ assertNotSame(one, two);
+ assertNotSame(two, one);
+ }
+ }
+ }
+
+ JndiPermission one = new JndiPermission("1/2/3", ALL_ACTIONS);
+ JndiPermission two = new JndiPermission("1/2/3", JndiPermission.ALL_ACTION);
+ assertEquals(one, two);
+ assertEquals(two, one);
+
+ one = new JndiPermission("1/2/3", "bind,unbind");
+ two = new JndiPermission("1/2/3", "unbind,bind");
+ assertEquals(one, two);
+ assertEquals(two, one);
+
+ one = new JndiPermission("1/2/3", "bind,unbind");
+ two = new JndiPermission("1/2/3", "unbind");
+ assertNotSame(one, two);
+ assertNotSame(two, one);
+ }
+
+ public void testSerialization() throws Exception
+ {
+ testSerialization(new JndiPermission("simple", JndiPermission.ALL_ACTION));
+ testSerialization(new JndiPermission(new CompositeName("simple"), JndiPermission.ALL_ACTION));
+ testSerialization(new JndiPermission("1/2/3", JndiPermission.ALL_ACTION));
+ testSerialization(new JndiPermission("1/2/*", JndiPermission.ALL_ACTION));
+ testSerialization(new JndiPermission("1/2/-", JndiPermission.ALL_ACTION));
+ testSerialization(new JndiPermission(ALL_BINDINGS, JndiPermission.ALL_ACTION));
+ for (String action : ACTION_ARRAY)
+ testSerialization(new JndiPermission("simple", action));
+ }
+
+ public void testSerialization(JndiPermission expected) throws Exception
+ {
+ JndiPermission actual = serializeDeserialize(expected, JndiPermission.class);
+ assertEquals(expected, actual);
+ }
+
+ public void testPermissionsCollection() throws Exception
+ {
+ JndiPermission one = new JndiPermission("1/2/3/*", "bind");
+ JndiPermission two = new JndiPermission("1/2/3/4", "unbind");
+
+ PermissionCollection permissions = one.newPermissionCollection();
+ assertFalse(permissions.implies(new JndiPermission("1/2/3/4", "bind")));
+ assertFalse(permissions.implies(new JndiPermission("1/2/3/4", "unbind")));
+ assertFalse(permissions.elements().hasMoreElements());
+
+ permissions.add(one);
+ permissions.add(two);
+
+ JndiPermission test = new JndiPermission("1/2/3/4", "bind");
+ assertTrue(permissions.implies(test));
+
+ test = new JndiPermission("1/2/3/5", "bind");
+ assertTrue(permissions.implies(test));
+
+ test = new JndiPermission("1/2/3/4", "unbind");
+ assertTrue(permissions.implies(test));
+
+ test = new JndiPermission("1/2/3/5", "unbind");
+ assertFalse(permissions.implies(test));
+
+ test = new JndiPermission("1/2/3", "bind");
+ assertFalse(permissions.implies(test));
+
+ try
+ {
+ permissions.add(null);
+ fail("Should not be here");
+ }
+ catch (Exception exception)
+ {
+ checkThrowable(IllegalArgumentException.class, exception);
+ }
+
+ try
+ {
+ permissions.add(new RuntimePermission("createClassLoader"));
+ fail("Should not be here");
+ }
+ catch (Exception exception)
+ {
+ checkThrowable(IllegalArgumentException.class, exception);
+ }
+
+ HashSet<Permission> expected = new HashSet<Permission>();
+ expected.add(one);
+ expected.add(two);
+
+ HashSet<Permission> actual = new HashSet<Permission>();
+ for (Enumeration<Permission> enumeration = permissions.elements(); enumeration.hasMoreElements();)
+ actual.add(enumeration.nextElement());
+ assertEquals(expected, actual);
+ }
}
More information about the jboss-cvs-commits
mailing list