Index: /Users/edwin/workspace/groovy/src/test/AllGroovyJavaTestsSuite.java
===================================================================
--- /Users/edwin/workspace/groovy/src/test/AllGroovyJavaTestsSuite.java	(revision 4080)
+++ /Users/edwin/workspace/groovy/src/test/AllGroovyJavaTestsSuite.java	(working copy)
@@ -1,5 +1,6 @@
 import groovy.inspect.InspectorTest;
 import groovy.lang.*;
+import groovy.lang.RangeTest;
 import groovy.security.SecurityTest;
 import groovy.security.SignedJarTest;
 import groovy.servlet.GroovyServletTest;
@@ -23,9 +24,8 @@
         suite.addTestSuite(InspectorTest.class);
         suite.addTestSuite(GroovyShellTest.class);
         suite.addTestSuite(GStringTest.class);
-        suite.addTestSuite(IntRangeTest.class);
         suite.addTestSuite(MetaClassTest.class);
-        suite.addTestSuite(RangeTest.class);
+        // suite.addTestSuite(RangeTest.class);
         suite.addTestSuite(ScriptIntegerDivideTest.class);
         suite.addTestSuite(ScriptPrintTest.class);
         suite.addTestSuite(ScriptTest.class);
@@ -41,6 +41,8 @@
         suite.addTestSuite(MBeanTest.class);
         suite.addTestSuite(XmlTest.class);
 
+        suite.addTest(new RangeTestSuite());
+        
         return suite;
     }
 }
Index: /Users/edwin/workspace/groovy/src/main/groovy/lang/EmptyRange.java
===================================================================
--- /Users/edwin/workspace/groovy/src/main/groovy/lang/EmptyRange.java	(revision 4080)
+++ /Users/edwin/workspace/groovy/src/main/groovy/lang/EmptyRange.java	(working copy)
@@ -8,88 +8,86 @@
  * Constructing Ranges like 0..<0
  * @author Dierk Koenig
  */
-public class EmptyRange implements Range {
+public class EmptyRange extends AbstractList implements Range {
+    
+    /**
+     * The value at which the range originates (may be <code>null</code>).
+     */
     protected Comparable at = null;
-    protected final List EMPTY_LIST = new ArrayList();
 
+    /**
+     * Creates a new {@link EmptyRange}.
+     * 
+     * @param at the value at which the range starts (may be <code>null</code>).
+     */
     public EmptyRange(Comparable at) {
        this.at = at;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public Comparable getFrom() {
         return at;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public Comparable getTo() {
         return at;
     }
 
+    /**
+     * Returns <code>false</code>
+     * 
+     * @return <code>false</code>
+     */
     public boolean isReverse() {
         return false;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public String inspect() {
-        return InvokerHelper.inspect(at)+"..<"+InvokerHelper.inspect(at);
+        return InvokerHelper.inspect(at) + "..<" + InvokerHelper.inspect(at);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public String toString() {
-        if (null == at) return "null..<null";
-        return at.toString()+"..<"+at.toString();
+        return (null == at) 
+            ? "null..<null"
+            : at.toString() + "..<" + at.toString();
     }
 
+    /**
+     * Returns 0
+     * 
+     * @return 0
+     */
     public int size() {
         return 0;
     }
 
-    public void clear() {
-    }
-
-    public boolean isEmpty() {
-        return true;
-    }
-
-    public Object[] toArray() {
-        return new Object[0];
-    }
-
-    public Object get(int index) {
-        return null;
-    }
-
-    public Object remove(int index) {
-        return null;
-    }
-
     /**
-     * @throws UnsupportedOperationException
+     * Throws <code>IndexOutOfBoundsException</code>.
+     * 
+     * @throws IndexOutOfBoundsException always
      */
-    public void add(int index, Object element) {
-        throw new UnsupportedOperationException("cannot add to Empty Ranges");
+    public Object get(int index) {
+        throw new IndexOutOfBoundsException("can't get values from Empty Ranges");
     }
 
-    public int indexOf(Object o) {
-        return -1;
-    }
-
-    public int lastIndexOf(Object o) {
-        return -1;
-    }
-
     /**
-     * @throws UnsupportedOperationException
+     * @throws UnsupportedOperationException always
      */
     public boolean add(Object o) {
         throw new UnsupportedOperationException("cannot add to Empty Ranges");
     }
 
-    public boolean contains(Object o) {
-        return false;
-    }
-
-    public boolean remove(Object o) {
-        return false;
-    }
-
     /**
      * @throws UnsupportedOperationException
      */
@@ -103,35 +101,35 @@
     public boolean addAll(Collection c) {
         throw new UnsupportedOperationException("cannot add to Empty Ranges");
     }
+    
+    /** 
+     * @throws UnsupportedOperationException
+     */
+    public boolean remove(Object o) {
+        throw new UnsupportedOperationException("cannot remove from Empty Ranges");
+    }
 
-    public boolean containsAll(Collection c) {
-        return false;
+    /** 
+     * @throws UnsupportedOperationException
+     */
+    public Object remove(int index) {
+        throw new UnsupportedOperationException("cannot remove from Empty Ranges");
     }
 
+    /**
+     * @throws UnsupportedOperationException
+     */
     public boolean removeAll(Collection c) {
-        return false;
+        throw new UnsupportedOperationException("cannot remove from Empty Ranges");
     }
 
+    /**
+     * @throws UnsupportedOperationException
+     */
     public boolean retainAll(Collection c) {
-        return false;
+        throw new UnsupportedOperationException("cannot retainAll in Empty Ranges");
     }
 
-    public Iterator iterator() {
-        return EMPTY_LIST.iterator();
-    }
-
-    public List subList(int fromIndex, int toIndex) {
-        return EMPTY_LIST.subList(fromIndex, toIndex);
-    }
-
-    public ListIterator listIterator() {
-        return EMPTY_LIST.listIterator();
-    }
-
-    public ListIterator listIterator(int index) {
-        return EMPTY_LIST.listIterator(index);
-    }
-
      /**
      * @throws UnsupportedOperationException
      */
@@ -139,14 +137,16 @@
         throw new UnsupportedOperationException("cannot set in Empty Ranges");
     }
 
-    public Object[] toArray(Object a[]) {
-        return new Object[0];
-    }
-
+    /**
+     * {@inheritDoc}
+     */
     public void step(int step, Closure closure) {
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public List step(int step) {
-        return EMPTY_LIST;
+        return new ArrayList();
     }
 }
Index: /Users/edwin/workspace/groovy/src/test/groovy/lang/EmptyRangeTest.java
===================================================================
--- /Users/edwin/workspace/groovy/src/test/groovy/lang/EmptyRangeTest.java	(revision 0)
+++ /Users/edwin/workspace/groovy/src/test/groovy/lang/EmptyRangeTest.java	(revision 0)
@@ -0,0 +1,395 @@
+/**
+ * 
+ */
+package groovy.lang;
+
+import groovy.util.GroovyTestCase;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.NoSuchElementException;
+
+/**
+ * Provides unit tests for the {@link EmptyRange} class.
+ * 
+ * @author $Author$
+ * @version $Revision$
+ */
+public class EmptyRangeTest extends GroovyTestCase {
+
+    /**
+     * The 'from' value for the {@link Range}.
+     */
+    private static final Integer AT = new Integer(17);
+    
+    /**
+     * The {@link Range} to test.
+     */
+    private Range range = null;
+    
+    /** 
+     * {@inheritDoc}
+     */
+    protected void setUp() throws Exception {
+        super.setUp();
+        
+        range = new EmptyRange(AT);
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#getFrom()}.
+     */
+    public void testGetFrom() {
+        assertEquals("wrong 'from' value", AT, range.getFrom());
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#getTo()}.
+     */
+    public void testGetTo() {
+        assertEquals("wrong 'from' value", AT, range.getTo());
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#isReverse()}.
+     */
+    public void testIsReverse() {
+        assertFalse("empty range reversed", range.isReverse());
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#inspect()}.
+     */
+    public void testInspect() {
+        assertEquals("wrong 'inspect' value", AT + "..<" + AT, range.inspect());
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#inspect()()} with a range with a <code>null</code> 'at' value.
+     */
+    public void testInspectNullAt() {
+        final Range nullAtRange = new EmptyRange(null);
+        assertEquals("wrong inspect value", "null..<null", nullAtRange.inspect());
+    }
+    
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#toString()}.
+     */
+    public void testToString() {
+        assertEquals("wrong string value", AT + "..<" + AT, range.toString());
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#toString()} with a range with a <code>null</code> 'at' value.
+     */
+    public void testToStringNullAt() {
+        final Range nullAtRange = new EmptyRange(null);
+        assertEquals("wrong string value", "null..<null", nullAtRange.toString());
+    }
+    
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#size()}.
+     */
+    public void testSize() {
+        assertEquals("wrong size", 0, range.size());
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#clear()}.
+     */
+    public void testClear() {
+        range.clear();
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#isEmpty()}.
+     */
+    public void testIsEmpty() {
+        assertTrue("range not empty", range.isEmpty());
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#toArray()}.
+     */
+    public void testToArray() {
+        assertArrayEquals(new Object[0], range.toArray());
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#get(int)}.
+     */
+    public void testGet() {
+        try {
+            range.get(0);
+            fail("got value from empty range");
+        }
+        catch (IndexOutOfBoundsException e) {
+            assertTrue("expected exception thrown", true);
+        }
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#remove(int)}.
+     */
+    public void testRemoveInt() {
+        try {
+            range.remove(0);
+            fail("removed value from empty range");
+        }
+        catch (UnsupportedOperationException e) {
+            assertTrue("expected exception thrown", true);
+        }
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#add(int, java.lang.Object)}.
+     */
+    public void testAddIntObject() {
+        try {
+            range.add(0, new Integer(12));
+            fail("added value to empty range");
+        }
+        catch (UnsupportedOperationException e) {
+            assertTrue("expected exception thrown", true);
+        }
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#indexOf(java.lang.Object)}.
+     */
+    public void testIndexOf() {
+        assertEquals("found value in empty range", -1, range.indexOf(AT));
+        assertEquals("found null in empty range", -1, range.indexOf(null));
+        assertEquals("found string in empty range", -1, range.indexOf("hello"));
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#lastIndexOf(java.lang.Object)}.
+     */
+    public void testLastIndexOf() {
+        assertEquals("found value in empty range", -1, range.lastIndexOf(AT));
+        assertEquals("found null in empty range", -1, range.lastIndexOf(null));
+        assertEquals("found string in empty range", -1, range.lastIndexOf("hello"));
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#add(java.lang.Object)}.
+     */
+    public void testAddObject() {
+        try {
+            range.add(new Integer(12));
+            fail("added value to empty range");
+        }
+        catch (UnsupportedOperationException e) {
+            assertTrue("expected exception thrown", true);
+        }
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#contains(java.lang.Object)}.
+     */
+    public void testContains() {
+        assertFalse("empty range contains a value", range.contains(AT));
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#remove(java.lang.Object)}.
+     */
+    public void testRemoveObject() {
+        try {
+            range.remove(AT);
+            fail("removed value from empty range");
+        }
+        catch (UnsupportedOperationException e) {
+            assertTrue("expected exception thrown", true);
+        }
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#addAll(int, java.util.Collection)}.
+     */
+    public void testAddAllIntCollection() {
+        try {
+            range.addAll(0, new ArrayList());
+            fail("added values to empty range");
+        }
+        catch (UnsupportedOperationException e) {
+            assertTrue("expected exception thrown", true);
+        }
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#addAll(java.util.Collection)}.
+     */
+    public void testAddAllCollection() {
+        try {
+            range.addAll(new ArrayList());
+            fail("added values to empty range");
+        }
+        catch (UnsupportedOperationException e) {
+            assertTrue("expected exception thrown", true);
+        }
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#containsAll(java.util.Collection)}.
+     */
+    public void testContainsAll() {
+        final List list = new ArrayList();
+        assertTrue("range contains all elements of an empty list", range.containsAll(list));
+        
+        list.add(AT);
+        assertFalse("range contains all elements of single element list", range.containsAll(list));
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#removeAll(java.util.Collection)}.
+     */
+    public void testRemoveAll() {
+        try {
+            range.removeAll(new ArrayList());
+            fail("removed values from an empty range");
+        }
+        catch (UnsupportedOperationException e) {
+            assertTrue("expected exception thrown", true);
+        }
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#retainAll(java.util.Collection)}.
+     */
+    public void testRetainAll() {
+        try {
+            range.retainAll(new ArrayList());
+            fail("retained values in an empty range");
+        }
+        catch (UnsupportedOperationException e) {
+            assertTrue("expected exception thrown", true);
+        }
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#iterator()}.
+     */
+    public void testIterator() {
+        final Iterator iterator = range.iterator();
+        assertFalse("iterator has next value", iterator.hasNext());
+        
+        try {
+            iterator.next();
+            fail("got next value in an empty range");
+        }
+        catch (NoSuchElementException e) {
+            assertTrue("expected exception thrown", true);
+        }
+    }
+
+    /**
+     * Tests removing via an iterator.
+     */
+    public void testIteratorRemove() {
+        try {
+            final Iterator iterator = range.iterator();
+            iterator.remove();
+            fail("removed via iterator");
+        }
+        catch (IllegalStateException e) {
+            assertTrue("expected exception thrown", true);
+        }
+    }
+    
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#subList(int, int)}.
+     */
+    public void testSubList() {
+        final List list = range.subList(0, 0);
+        assertTrue("list not empty", list.isEmpty());
+        try {
+            range.subList(0, 1);
+            fail("got sub list in an empty range");
+        }
+        catch (IndexOutOfBoundsException e) {
+            assertTrue("expected exception thrown", true);
+        }
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#listIterator()}.
+     */
+    public void testListIterator() {
+        final ListIterator iterator = range.listIterator();
+        assertFalse("iterator has next value", iterator.hasNext());
+        assertFalse("iterator has previous value", iterator.hasPrevious());
+        
+        try {
+            iterator.next();
+            fail("got next value in an empty range");
+        }
+        catch (NoSuchElementException e) {
+            assertTrue("expected exception thrown", true);
+        }
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#listIterator(int)}.
+     */
+    public void testListIteratorInt() {
+        final ListIterator iterator = range.listIterator(0);
+        assertFalse("iterator has next value", iterator.hasNext());
+        assertFalse("iterator has previous value", iterator.hasPrevious());
+
+        try {
+            range.listIterator(1);
+            fail("got list iterator at index 1");
+        }
+        catch (IndexOutOfBoundsException e) {
+            assertTrue("expected exception thrown", true);
+        }
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#set(int, java.lang.Object)}.
+     */
+    public void testSet() {
+        try {
+            range.set(0, AT);
+            fail("got set value 0");
+        }
+        catch (UnsupportedOperationException e) {
+            assertTrue("expected exception thrown", true);
+        }
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#toArray(java.lang.Object[])}.
+     */
+    public void testToArrayObjectArray() {
+        final Integer[] actual = (Integer[]) range.toArray(new Integer[0]);
+        assertArrayEquals(new Integer[0], actual);
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#step(int, groovy.lang.Closure)}.
+     */
+    public void testStepIntClosure() {
+        final List callLog = new ArrayList();
+        final Closure closure = new NumberRangeTest.RecordingClosure(callLog);        
+        range.step(1, closure);    
+        assertEquals("wrong number of calls to closure", 0, callLog.size());
+    }
+
+    /**
+     * Test method for {@link groovy.lang.EmptyRange#step(int)}.
+     */
+    public void testStepInt() {
+        List result = range.step(1);
+        assertTrue("too many elements", result.isEmpty());
+        
+        // make sure a new list is returned each time
+        result.add(new Integer(1));
+        result = range.step(1);
+        assertTrue("too many elements", result.isEmpty());
+    }
+}
Index: /Users/edwin/workspace/groovy/src/test/groovy/lang/RangeTestSuite.java
===================================================================
--- /Users/edwin/workspace/groovy/src/test/groovy/lang/RangeTestSuite.java	(revision 0)
+++ /Users/edwin/workspace/groovy/src/test/groovy/lang/RangeTestSuite.java	(revision 0)
@@ -0,0 +1,41 @@
+/**
+ * 
+ */
+package groovy.lang;
+
+import junit.framework.TestSuite;
+import junit.textui.TestRunner;
+
+/**
+ * Calls all the range-related tests.
+ * 
+ * @author $Author$
+ * @version $Revision$
+ */
+public final class RangeTestSuite extends TestSuite {
+
+    /**
+     * Creates a new {@link RangeTestSuite}
+     */
+    public RangeTestSuite() {
+        addTestSuite(IntRangeTest.class);
+        addTestSuite(ShortRangeTest.class);
+        addTestSuite(IntegerRangeTest.class);
+        addTestSuite(LongRangeTest.class);
+        addTestSuite(FloatRangeTest.class);
+        addTestSuite(BigDecimalRangeTest.class);
+        addTestSuite(CharacterRangeTest.class);
+        addTestSuite(RangeTest.class);
+        addTestSuite(EmptyRangeTest.class);
+    }
+    
+    /**
+     * Runs the tests in the {@link TestRunner}.
+     * 
+     * @param argv
+     *            not used
+     */
+    public static void main(String[] argv) {
+        junit.textui.TestRunner.run(new RangeTestSuite());
+    }
+}