rubyfox-server 2.3.0.pre2

data/lib/rubyfox/server/data/lib/Lib/test/javatests/ListTest.java

@@ -0,0 +1,638 @@
+//Copyright (c) Corporation for National Research Initiatives
+package javatests;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.NoSuchElementException;
+
+/**
+ * @author updikca1
+ */
+public abstract class ListTest {
+    
+    public static ListTest getArrayListTest(final boolean makeReadOnly) {
+        return new ListTest() {
+            public List newInstance(Collection c) {
+                List l = null;
+                if(c == null) {
+                    l = new ArrayList();
+                } else {
+                    l = new ArrayList(c);
+                }
+                return (makeReadOnly) 
+                		? Collections.unmodifiableList(l)
+                		: l;
+            }
+            public boolean isReadOnly() {
+                return makeReadOnly;
+            }            
+        };
+    }
+    
+    public static void verifyImutability(List l) {
+        
+        String message = "Expected UnsupportedOperationException.";
+        
+        try {
+            l.add(0, new Integer(0));
+            TestSupport.assertThat(false, message);
+        } catch (UnsupportedOperationException e) {}
+        
+        try {
+            l.add(new Integer(0)); 
+            TestSupport.assertThat(false, message);
+        } catch (UnsupportedOperationException e) {}
+        
+        try {
+            l.addAll(null);  
+            TestSupport.assertThat(false, message);
+        } catch (UnsupportedOperationException e) {}
+        
+        try {
+            l.addAll(0, null); 
+            TestSupport.assertThat(false, message);
+        } catch (UnsupportedOperationException e) {}
+        
+        try {
+            l.clear();      
+            TestSupport.assertThat(false, message);
+        } catch (UnsupportedOperationException e) {}
+        
+        try {
+            l.remove(0); 
+            TestSupport.assertThat(false, message);
+        } catch (UnsupportedOperationException e) {}
+        
+        try {
+            l.remove(new Object());
+            TestSupport.assertThat(false, message);
+        } catch (UnsupportedOperationException e) {}
+        
+        try {
+            l.removeAll(null); 
+            TestSupport.assertThat(false, message);
+        } catch (UnsupportedOperationException e) {}
+        
+        try {
+            l.retainAll(null);
+            TestSupport.assertThat(false, message);
+        } catch (UnsupportedOperationException e) {}
+        try {
+            l.set(0,new Integer(0));
+            TestSupport.assertThat(false, message);
+        } catch (UnsupportedOperationException e) {}   
+    }
+    
+    private final List nullList;
+    
+    protected List defaultList() {
+        List l = new ArrayList();
+        for (int i = 0; i < 4; i++) {
+            l.add(new Integer(i));
+        }
+        return newInstance(l);
+    }
+    
+    /**
+     * Implementations must supply an empty list if the collection is null.
+     * @param c Initial collection or null for empty.
+     * @return the List instance
+     */
+    public List newInstance(Collection c) {
+        throw new UnsupportedOperationException("This method must be overridden");
+    }
+    
+    /**
+     * @return true if the list is read-only (like PyTuple)
+     */
+    public boolean isReadOnly() {
+        throw new UnsupportedOperationException("This method must be overridden");
+    }
+    
+    {
+        nullList = newInstance(Arrays.asList(new Object[] {null}));
+    }
+    
+    public void testAll() {
+        
+        test_get();
+        test_equals();
+        test_size();
+        test_contains();
+        test_containsAll();
+        
+        try {
+            defaultList().hashCode();
+            test_hashCode();
+        } catch (Exception e) {
+            // skip unhashable types
+        }
+                
+        test_subList();
+        test_lastIndexOf();
+        test_listIterator();
+        test_toArray();
+        test_toArray_typed();
+      
+        if(!isReadOnly()) {     
+            test_add();
+            test_add_index();
+            test_set();
+            test_clear();
+            test_addAll();
+            test_addAll_index();  
+            test_remove();
+            test_remove_index();
+            test_removeAll();
+            test_retainAll();
+        } else {
+            verifyImutability(newInstance(null));
+        }
+    }
+    
+    /** Tests get(int index) */
+    public void test_get() {
+        TestSupport.assertThat(defaultList().get(0).equals(new Integer(0)),
+        		"get() did not return expected value of Integer(0)");
+        try {
+            defaultList().get(-1);
+            TestSupport.assertThat(false, 
+            		"get(<negative index>) did not throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {}
+        
+        try {
+            defaultList().get(-1);
+            TestSupport.assertThat(false, 
+            		"get(<index too big>) did not throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {}
+    }
+    
+    /** Tests set(int index, Object element) */
+    public void test_set() {
+        
+        try {
+            newInstance(null).set(-1, "spam");
+            TestSupport.assertThat(false, 
+            		"get(<negative index>) did not throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {}
+        
+        try {
+            newInstance(null).set(0, "spam");
+            TestSupport.assertThat(false, 
+            	"set(<index too big>) did not throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {}
+        
+        List a = defaultList();
+        a.set(a.size() - 1 , "spam");
+        TestSupport.assertThat(a.get(a.size() - 1).equals("spam"), 
+        		"set() object was not retrieved via get()");
+    }
+    
+    /** Tests add(Object o) */ 
+    public void test_add() {    
+        List a = newInstance(null);
+        for (int i = 0; i < 4; i++) {
+            a.add(new Integer(i));
+        }
+        TestSupport.assertEquals(a, defaultList(), "add(Object o) failed");
+    }
+    
+    /** Tests isEmpty() */
+    public void test_isEmpty() {
+        List a = newInstance(null);
+        TestSupport.assertThat(a.isEmpty(), 
+                "isEmpty() is false on an emtpy List");
+        a.addAll(defaultList());
+        TestSupport.assertThat(!a.isEmpty(), 
+                "isEmpty() is true on a non-empty List)" );
+        a.clear();
+        TestSupport.assertThat(a.isEmpty(), 
+                "isEmpty() is false on an emtpy List");        
+    }
+    
+    /** Tests size() */
+    public void test_size() { 
+        List b = newInstance(null);
+        TestSupport.assertThat(b.size() == 0, "empty list size was not 0");
+        TestSupport.assertThat(defaultList().size() == 4, 
+                "default list did not have a size of 4");     
+    }
+    
+    /** Tests  add(int index, Object element) */       
+    public void test_add_index() {
+        List a = newInstance(null);
+        List b = defaultList();
+        for (int i = 0; i < b.size(); i++) {
+            a.add(i, b.get(i));
+        }
+        
+        try {
+            a.add(a.size() + 1, new Integer(a.size() + 1));  
+            TestSupport.assertThat(false, "expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {}
+        
+        try {
+            a.add(-1, new Integer(-1));  
+            TestSupport.assertThat(false, "expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {}                           
+    }
+    
+    /** Tests  equals(Object o)*/       
+    public void test_equals() {
+        TestSupport.assertEquals(defaultList(), defaultList(), 
+        		"Identical lists weren't equal()");
+        TestSupport.assertNotEquals(newInstance(null), defaultList(), 
+        		"Different lists were equal()");
+        TestSupport.assertNotEquals(newInstance(null), new Object(), 
+        		"List was equal to a non-List type");
+    }
+    
+    /** Tests addAll(Collection c) */
+    public void test_addAll() {
+        List a = defaultList();
+        List b = defaultList();
+        
+        TestSupport.assertThat(a.addAll(b) == true, 
+        		"Mutating addAll(Collection) returned false");
+        TestSupport.assertThat(a.addAll(newInstance(null)) == false, 
+        		"Idempotent addAll(Collection) returned true");
+        TestSupport.assertThat(b.addAll(b) == true,
+                "Mutating addAll(Collection) returned false");
+        TestSupport.assertEquals(a, b, 
+                "Expected equal objects from addAll(collection)");
+        TestSupport.assertThat(a.size() == 8, 
+        		"Expected List to have size 8 after addAll(Collection)");      
+    }
+    
+    /** Tests indexOf(Object o) */       
+    public void indexOf() {
+        TestSupport.assertThat(defaultList().indexOf(new Integer(3)) == 3, 
+                "indexOf(3) did not return 3"); 
+        TestSupport.assertThat(defaultList().indexOf(new Integer(42)) == -1, 
+        		"indexOf() non-existing entry did not return -1");
+        TestSupport.assertThat(defaultList().indexOf(null) == -1, 
+        		"indexOf() non-existing null did not return -1"); 
+        
+    }
+    
+    /** Tests contains(Object o) */       
+    public void test_contains() { 
+        TestSupport.assertThat(defaultList().contains(new Integer(42)) == false, 
+        		"contains() returned true for non-existing entry");
+        TestSupport.assertThat(defaultList().contains(new Integer(0)) == true, 
+        		"contains() returned false for existing entry");
+        TestSupport.assertThat(nullList.contains(null) == true, 
+        		"contains() returned false for existing null entry");
+        TestSupport.assertThat(defaultList().contains(null) == false, 
+        		"contains() returned true for non-existing null entry");
+    }
+    
+    /** Tests remove(Object o) */
+    public void test_remove() {
+        List a = defaultList();
+        a.add(null);
+        TestSupport.assertThat(a.remove(null) == true, 
+        		"remove() existing null entry returned false");
+        TestSupport.assertThat(a.remove(null) == false, 
+        		"remove() non-existing null entry returned false");
+        a.add("spam");
+        TestSupport.assertThat(a.remove("spam") == true, 
+        		"remove() existing entry returned false");
+        TestSupport.assertThat(a.remove("spam") == false, 
+        		"remove() non-existing entry returned true");
+    }
+    
+    
+    /** Tests remove(int index) */
+    public void test_remove_index() {    
+        
+        List a = defaultList();
+        for (int i = 0, n = a.size(); i < n; i++) {
+            a.remove(0);
+        }
+        TestSupport.assertThat(a.size() == 0, 
+                "remove()-d all entries but size() not 0");
+        
+        try {
+            a.remove(0);
+            TestSupport.assertThat(false, 
+            		"removing a non-existing index did not throw exception");
+        } catch(IndexOutOfBoundsException e) {}       
+    }
+    
+    /** Tests lastIndexOf(Object o) */
+    public void test_lastIndexOf() {
+        // avoid calling any mutable methods 
+        List l = new ArrayList(defaultList());
+        l.add(new Integer(0));
+        
+        // now get the immutable version
+        List a = newInstance(l);
+        
+        TestSupport.assertThat(a.lastIndexOf(new Integer(0)) == 4, 
+                "lastIndexOf() did not return 4");
+        TestSupport.assertThat(a.lastIndexOf(new Integer(42)) == -1, 
+        		"lastIndexOf() non-existing value did not return -1");    
+    }
+    
+    /** Tests removeAll(Collection c) */       
+    public void test_removeAll() {
+        List a = defaultList();
+        TestSupport.assertThat(a.removeAll(a) == true, 
+        		"mutating removeAll() did not return true");
+        TestSupport.assertThat(a.removeAll(a) == false, 
+        		"idempotent removeAll did not return false");
+        TestSupport.assertThat(a.removeAll(nullList) == false, 
+        		"idempotent removeAll did not return false");
+        
+        List yanl = newInstance(null); 
+        yanl.addAll(nullList);
+        TestSupport.assertThat(yanl.removeAll(nullList) == true, 
+        		"mutating removeAll() did not return true");
+        TestSupport.assertThat(yanl.size() == 0, 
+                "empty list had non-zero size");
+        TestSupport.assertThat(yanl.removeAll(newInstance(null)) == false,
+        		"idempotent removeAll did not return false");
+        
+    }
+    
+    /** Tests addAll(int index, Collection c) */       
+    public void test_addAll_index() {
+        List a = defaultList();
+        List b = newInstance(null);
+        TestSupport.assertThat(b.addAll(0,a) == true, 
+        		"mutating addAll(index, Collection) did not return true");
+        TestSupport.assertEquals(a, b, 
+                "addAll(index, Collection) instances failed equals test");
+        TestSupport.assertThat(a.addAll(0, newInstance(null)) == false, 
+        		"idempotent addAll(index, Collection) did not return false");  
+        TestSupport.assertThat(b.addAll(0,b) == true, 
+                "mutating addAll(index, Collection) did not return true");
+        
+        // Since PyObjectList has some specific handling when it detects
+        // addAll on a PySequenceList, make sure the general case works.
+        b = newInstance(null);
+        b.addAll(new ArrayList(defaultList()));
+        TestSupport.assertEquals(defaultList(), b,
+                "addAll(index, <ArrayList>) failed equals test");
+    }
+
+    
+    /** Tests  hashCode() */       
+    public void test_hashCode() {
+        List a = defaultList();
+        TestSupport.assertThat(a.hashCode() == defaultList().hashCode(), 
+        		"Instances with same internal state have different hashcode");
+        TestSupport.assertThat(a.hashCode() != newInstance(null).hashCode(), 
+        		"Instances with different internal state have the same hashcode");
+        
+        if (isReadOnly() == false) {
+            List b = newInstance(null);
+            b.addAll(a);
+            b.remove(0);
+            TestSupport.assertThat(a.hashCode()!= b.hashCode(), 
+            		"Instances with different internal state have the same hashcode");
+        }
+        
+    }
+    
+    /** Tests clear() */       
+    public void test_clear() {
+        List a = defaultList();
+        a.clear();
+        TestSupport.assertThat(a.size() == 0, 
+                "clear()-ed list did not have size of 0");
+    }
+    
+    /** Tests subList(int fromIndex, int toIndex) */       
+    public void test_subList() {
+        List a = defaultList();
+        TestSupport.assertThat((a.subList(0, a.size()) != a), 
+                "subList() returned the same instance");
+        TestSupport.assertEquals(a.subList(0, a.size()), a, 
+                "Complete subList() did not equal original List");
+        TestSupport.assertThat(a.subList(0,0).size() == 0, 
+                "empty subList had non-zero size");
+        
+        try {
+            a.subList(-1,1);
+            TestSupport.assertThat(false, "Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {}
+        
+        try {
+            a.subList(1,0);
+            TestSupport.assertThat(false, "Expected IllegalArgumentException");
+        } catch (IllegalArgumentException e) {}
+        
+        try {
+            a.subList(0,a.size() + 1);
+            TestSupport.assertThat(false, "Expected IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {}
+        
+        if (!isReadOnly()) {
+            
+            a.subList(0, a.size()).clear();
+            TestSupport.assertThat(a.size() == 0, 
+                    "clear()-ed sublist did not have zero size");           
+            List c = newInstance(null); 
+            c.addAll(defaultList());
+            List d = c.subList(1,3);
+            TestSupport.assertThat(d.size() == 2, 
+            		"Expected subList to have size of 2");
+            TestSupport.assertThat(c.set(1,"canned").equals(new Integer(1)), 
+                    "subList.set() did not return Integer(1) from index 1" +
+            		" of defaultList");
+            TestSupport.assertThat(d.get(0).equals("canned"),
+            		"subList does not update with changes to parent");
+            d.set(0,"spam");
+            TestSupport.assertThat(c.get(1).equals("spam"), 
+            		"parent does not update with changes to subList child");
+        } else {
+            List b = a.subList(0, a.size());
+            verifyImutability(b);
+        }
+        
+    }
+    
+    /** Tests retainAll(Collection c) */
+    public void test_retainAll() { 
+        List a = defaultList();
+        a.retainAll(defaultList());
+        TestSupport.assertEquals(a, defaultList(), 
+        		"retainAll(<equal List>) does not equal original list");
+        a = defaultList();
+        a.retainAll(newInstance(null));
+        TestSupport.assertThat(a.size() == 0,
+        		"retainAll(<empty List>))does not have size of zero");
+        
+        a = defaultList();
+        a.remove(0);
+        a.remove(0);
+        a.add(new Integer(4));
+        a.add(new Integer(5));
+        List b = newInstance(null);
+        b.add(new Integer(2));
+        b.add(new Integer(3));
+        a.retainAll(b);
+        TestSupport.assertEquals(a, b,
+        		"retainAll() on overlap of indices [2,3] did not return that List");
+    }
+    
+    /** Tests containsAll(Collection c) */
+    public void test_containsAll() {
+        TestSupport.assertThat(defaultList().containsAll(defaultList()),
+        		"containsAll(<identical List> was false");
+        TestSupport.assertThat(defaultList().containsAll(newInstance(null)), 
+        		"containsAll(<empty List>) was false");
+        TestSupport.assertThat(newInstance(null).containsAll(defaultList()) == false,
+        		"containsAll(<disjoint List>) returned true");
+        TestSupport.assertThat(defaultList().containsAll(defaultList().subList(1,3)), 
+        		"containsAll(<subList>) was false");
+    }
+    
+    /** Tests iterator() */
+    public void test_iterator() {
+        
+        TestSupport.assertThat(newInstance(null).iterator().hasNext() == false, 
+        		"Iterator for empty list thinks it hasNext()");
+        try {
+            newInstance(null).iterator().next();
+            TestSupport.assertThat(false, "expected NoSuchElementException");
+        } catch (NoSuchElementException e) {}
+        
+        List a = defaultList();
+        int i = 0;
+        for (Iterator iter = a.iterator(); iter.hasNext(); ) {
+            TestSupport.assertThat(iter.next() == a.get(i++), 
+            		"Iterator next() failed identity test");
+        }
+        TestSupport.assertThat(i == a.size(), 
+                "Iterator did not iterator over entire list");
+    }
+    
+    public void test_listIterator() {
+        
+        ListIterator li = newInstance(null).listIterator();
+        TestSupport.assertThat(li.hasNext() == false, 
+        		"ListIterator.hasNext() is true for empty List");
+        
+        TestSupport.assertThat(li.hasPrevious() == false, 
+        		"ListIterator.hasPrevious() is true for empty List");
+        
+        try {
+            li.next();
+            TestSupport.assertThat(false, "expected NoSuchElementException");
+        } catch (NoSuchElementException e) {}
+        
+        try {
+            li.previous();
+            TestSupport.assertThat(false, "expected NoSuchElementException");
+        } catch (NoSuchElementException e) {}
+        
+        // Appears bug was fixed from 1.3 to 1.4.  Code it to pass either way.
+        int nextIndex = li.nextIndex();
+        TestSupport.assertThat(nextIndex == -1 || nextIndex == 0, 
+        		"ListIterator.nextIndex() on empty List did not return 0 " +
+        		"(java 1.4) or did not return -1 (java 1.3)");
+        
+        // Likewise...
+        int prevIndex = li.previousIndex();
+        TestSupport.assertThat(prevIndex == -1 || prevIndex == -2,
+        		"ListIterator.previousIndex() on empty List did not return -1 " +
+        		"(java 1.4) or -2 (java 1.3)");
+        
+        List l = new ArrayList();
+        l.add(new Integer(1)); 
+        li = newInstance(l).listIterator();
+        TestSupport.assertThat(li.hasPrevious() == false, 
+        		"ListIterator.hasPrevious() is true with nothing previous");
+        
+        TestSupport.assertThat(li.hasNext() == true, 
+        		"ListIterator.hasNext() is false with next present");
+        TestSupport.assertThat(li.next().equals(new Integer(1)), 
+                "ListIterator.next() did not return expected Integer(1)");
+       
+        if (!isReadOnly()) {
+	        li.remove();
+	        TestSupport.assertThat(li.hasNext() == false, 
+	        		"ListIterator.hasNext() is true for empty List");
+	        
+	        TestSupport.assertThat(li.hasPrevious() == false, 
+	        		"ListIterator.hasPrevious() is true for empty List");
+	        try {
+	            li.set(new Integer(42));
+	            TestSupport.assertThat(false, "expected IllegalStateException");
+	        } catch (IllegalStateException e) {}
+	        
+	        try {
+	            li.remove();
+	            TestSupport.assertThat(false, "expected IllegalStateException");
+	        } catch (IllegalStateException e) {}    
+        }
+        
+        l = new ArrayList();
+        l.add(new Integer(0));
+        l.add(new Integer(1));
+        l.add(new Integer(2));
+        
+        li = newInstance(l).listIterator();
+        
+        for (int i = 0, n = l.size(); i < n; i++) {
+            TestSupport.assertThat(li.next().equals(new Integer(i)),
+            		"ListIterator.previous did not return expected value");
+        }
+        
+        while (!isReadOnly() && li.hasNext()) {
+            li.next();
+            li.set(new Integer(42));
+            TestSupport.assertThat(li.previous().equals(new Integer(42)),
+            		"ListIterator.previous() did not return the value that was set()");
+            li.remove();
+        }
+        
+        if(isReadOnly()) {
+            li = newInstance(null).listIterator();
+        }
+        
+        li = defaultList().listIterator(2);
+        TestSupport.assertThat(li.next().equals(new Integer(2)), 
+        		"List.listIteraor(index) did not return expected value");
+        TestSupport.assertThat(li.next().equals(new Integer(3)), 
+        		"List.listIteraor(index) did not return expected value");
+        TestSupport.assertThat(li.hasNext() == false, 
+        		"listIterator.hasNext() at end of list returned true");    
+        
+    }
+    
+    /** Tests toArray() */
+    public void test_toArray() {
+        Object[] intObjArray = new Integer[] {
+                new Integer(0), new Integer(1), new Integer(2), new Integer(3)}; 
+        TestSupport.assertThat(Arrays.equals(defaultList().toArray(), intObjArray), 
+        		"toArray() did not return the expected Integer[] array");
+    }
+    
+    /** Tests toArray(Object[] a)  */
+    public void test_toArray_typed() {
+        Object[] intObjArray = new Integer[] {
+                new Integer(0), new Integer(1), new Integer(2), new Integer(3)}; 
+        TestSupport.assertThat(Arrays.equals(
+                defaultList().toArray(new Integer[] {}), intObjArray), 
+        		"toArray(Integer[]) did not return the expected Integer[] array");
+    }
+    
+    // Can't test clone since it's not visible, but it is from jython.    
+    //    /** Tests clone() */
+    //    public void test_clone() {
+    //        List a = defaultList();
+    //        TestSupport.assertEquals(((Object)a).clone(), a, 
+    //        	     "clone() was not equal to original");
+    //        TestSupport.assertThat(a.clone() != a, 
+    //               "clone() returned same instance");
+    //    }
+}

data/lib/rubyfox/server/data/lib/Lib/test/javatests/SubFoo.java

@@ -0,0 +1,3 @@
+package javatests;
+
+public class SubFoo extends Foo {}

data/lib/rubyfox/server/data/lib/Lib/test/javatests/TestSupport.java

@@ -0,0 +1,49 @@
+//Copyright (c) Corporation for National Research Initiatives
+package javatests;
+
+/**
+ * @author updikca1
+ */
+public class TestSupport {
+
+    public static class AssertionError extends RuntimeException {
+        
+        public AssertionError() {
+            super();
+        }
+        
+        public AssertionError(String message) {
+            super(message);
+        }
+        
+        /* not until java 1.4
+        public AssertionError(String message, Throwable cause) {
+            super(message, cause);
+        }
+        
+        public AssertionError(Throwable cause) {
+            super(cause);
+        }
+        */
+    }
+    
+    public static void assertThat(boolean test, String message) {
+        
+        if (test == false) {
+            throw new AssertionError(message);
+        }
+    }
+    
+    public static void assertEquals(Object a, Object b, String message) {
+        
+        assertThat(a.equals(b), message + "[a.equals(b) failed]");
+        assertThat(b.equals(a), message + "[b.equals(a) failed]");
+    }
+    
+    public static void assertNotEquals(Object a, Object b, String message) {
+        
+        assertThat( !a.equals(b), message + "[not a.equals(b) failed]");
+        assertThat( !b.equals(a), message + "[not b.equals(a) failed]");
+    }
+}
+