--- src/java/org/apache/poi/ss/util/CellRangeAddressBase.java	(revision 1702702)
+++ src/java/org/apache/poi/ss/util/CellRangeAddressBase.java	(working copy)
@@ -17,6 +17,8 @@ 
 
 package org.apache.poi.ss.util;
 
+import java.util.Arrays;
+
 import org.apache.poi.ss.SpreadsheetVersion;
 
 
@@ -72,14 +74,40 @@ 
 	}
 
 
-	//TODO use the correct SpreadsheetVersion
+	/**
+	 * @deprecated since September 2015. Use {@link #isFullColumnRange(SpreadsheetVersion)}
+	 * @return
+	 */
+	@Deprecated
 	public final boolean isFullColumnRange() {
-		return (_firstRow == 0 && _lastRow == SpreadsheetVersion.EXCEL97.getLastRowIndex())
+		return isFullColumnRange(SpreadsheetVersion.EXCEL97);
+	}
+	/**
+	 * Returns true if CellRangeAddress spans one or more entire columns
+	 *
+	 * @param version
+	 * @return
+	 */
+	public final boolean isFullColumnRange(SpreadsheetVersion version) {
+		return (_firstRow == 0 && _lastRow == version.getLastRowIndex())
 		  || (_firstRow == -1 && _lastRow == -1);
 	}
-	//TODO use the correct SpreadsheetVersion
+	/**
+	 * @deprecated since September 2015. Use {@link #isFullRowRange(SpreadsheetVersion)}
+	 * @return
+	 */
+	@Deprecated
 	public final boolean isFullRowRange() {
-		return (_firstCol == 0 && _lastCol == SpreadsheetVersion.EXCEL97.getLastColumnIndex())
+		return isFullRowRange(SpreadsheetVersion.EXCEL97);
+	}
+	/**
+	 * Returns true if CellRangeAddress spans one or more entire rows
+	 *
+	 * @param version
+	 * @return
+	 */
+	public final boolean isFullRowRange(SpreadsheetVersion version) {
+		return (_firstCol == 0 && _lastCol == version.getLastColumnIndex())
 		  || (_firstCol == -1 && _lastCol == -1);
 	}
 
@@ -164,4 +192,36 @@ 
 		CellReference crB = new CellReference(_lastRow, _lastCol);
 		return getClass().getName() + " [" + crA.formatAsString() + ":" + crB.formatAsString() +"]";
 	}
+	
+	   // In case _firstRow > _lastRow or _firstCol > _lastCol
+    protected int getMinRow() {
+        return Math.min(_firstRow, _lastRow);
+    }
+    protected int getMaxRow() {
+        return Math.max(_firstRow, _lastRow);
+    }
+    protected int getMinColumn() {
+        return Math.min(_firstCol, _lastCol);
+    }
+    protected int getMaxColumn() {
+        return Math.max(_firstCol, _lastCol);
+    }
+    
+    @Override
+    public boolean equals(Object other) {
+        if (other instanceof CellRangeAddressBase) {
+            CellRangeAddressBase o = (CellRangeAddressBase) other;
+            return ((getMinRow() == o.getMinRow()) &&
+                    (getMaxRow() == o.getMaxRow()) &&
+                    (getMinColumn() == o.getMinColumn()) &&
+                    (getMaxColumn() == o.getMaxColumn()));
+        }
+        return false;
+    }
+    
+    @Override
+    public int hashCode() {
+        final int[] values = new int[]{getMinRow(), getMaxRow(), getMinColumn(), getMaxColumn()};
+        return Arrays.hashCode(values);
+    }
 }
--- src/testcases/org/apache/poi/hssf/record/cf/TestCellRange.java	(revision 1702702)
+++ src/testcases/org/apache/poi/hssf/record/cf/TestCellRange.java	(working copy)
@@ -22,6 +22,7 @@ 
 import junit.framework.AssertionFailedError;
 import junit.framework.TestCase;
 
+import org.apache.poi.ss.SpreadsheetVersion;
 import org.apache.poi.ss.util.CellRangeAddress;
 
 /**
@@ -181,8 +182,8 @@ 
 	}
 
 	private static void confirmRange(CellRangeAddress cr, boolean isFullRow, boolean isFullColumn) {
-		assertEquals("isFullRowRange", isFullRow, cr.isFullRowRange());
-		assertEquals("isFullColumnRange", isFullColumn, cr.isFullColumnRange());
+		assertEquals("isFullRowRange", isFullRow, cr.isFullRowRange(SpreadsheetVersion.EXCEL97));
+		assertEquals("isFullColumnRange", isFullColumn, cr.isFullColumnRange(SpreadsheetVersion.EXCEL97));
 	}
 	
 	public void testNumberOfCells() {
--- src/testcases/org/apache/poi/ss/util/TestCellRangeAddress.java	(revision 1702702)
+++ src/testcases/org/apache/poi/ss/util/TestCellRangeAddress.java	(working copy)
@@ -23,6 +23,7 @@ 
 import junit.framework.TestCase;
 
 import org.apache.poi.hssf.record.TestcaseRecordInputStream;
+import org.apache.poi.ss.SpreadsheetVersion;
 import org.apache.poi.util.LittleEndianOutputStream;
 
 public final class TestCellRangeAddress extends TestCase {
@@ -190,4 +191,85 @@ 
         ref = new CellRangeAddress(-1, -1, -1, -1);
         assertEquals(":", ref.formatAsString());
     }
+    
+    public static void testIsFullRowRange() {
+        CellRangeAddress ref = new CellRangeAddress(0, 0, 0, 0);
+        assertFalse("single cell range",
+                ref.isFullRowRange(SpreadsheetVersion.EXCEL97));
+        
+        // 1 before last column (for Excel 97
+        ref = new CellRangeAddress(0, 0, 0, 254);
+        assertFalse("1 before last column for EXCEL97",
+                ref.isFullRowRange(SpreadsheetVersion.EXCEL97));
+        
+        // last column (for Excel97)
+        ref = new CellRangeAddress(0, 0, 0, 255);
+        assertTrue("last column for Excel 97",
+                ref.isFullRowRange(SpreadsheetVersion.EXCEL97));
+        assertFalse("many before last column for Excel 2007",
+                ref.isFullRowRange(SpreadsheetVersion.EXCEL2007));
+        
+        // 1 before last column
+        ref = new CellRangeAddress(0, 0, 0, 16382);
+        assertFalse("many after last column for Excel 97",
+                ref.isFullRowRange(SpreadsheetVersion.EXCEL97));
+        assertFalse("1 before last column for Excel 2007",
+                ref.isFullRowRange(SpreadsheetVersion.EXCEL2007));
+        
+        //last column
+        ref = new CellRangeAddress(0, 0, 0, 16383);
+        assertTrue("last column for Excel 2007",
+                ref.isFullRowRange(SpreadsheetVersion.EXCEL2007));
+        
+        //1 after last column
+        ref = new CellRangeAddress(0, 0, 0, 16384);
+        assertFalse("1 after last column for Excel 2007",
+                ref.isFullRowRange(SpreadsheetVersion.EXCEL2007));
+        
+        // Does -1, -1 mean this is an invalid/deleted reference? Is this a useful test?
+        ref = new CellRangeAddress(0, 0, -1, -1);
+        assertTrue(ref.isFullRowRange(SpreadsheetVersion.EXCEL97));
+        assertTrue(ref.isFullRowRange(SpreadsheetVersion.EXCEL2007));
+    }
+    
+    public static void testIsFullColumnRange() {
+        CellRangeAddress ref = new CellRangeAddress(0, 0, 0, 0);
+        assertFalse(ref.isFullColumnRange(SpreadsheetVersion.EXCEL97));
+        
+        ref = new CellRangeAddress(0, 65534, 0, 0);
+        assertFalse(ref.isFullColumnRange(SpreadsheetVersion.EXCEL97));
+        
+        ref = new CellRangeAddress(0, 65535, 0, 0);
+        assertTrue(ref.isFullColumnRange(SpreadsheetVersion.EXCEL97));
+        assertFalse(ref.isFullColumnRange(SpreadsheetVersion.EXCEL2007));
+        
+        ref = new CellRangeAddress(0, 1048574, 0, 0);
+        assertFalse(ref.isFullColumnRange(SpreadsheetVersion.EXCEL97));
+        assertFalse(ref.isFullColumnRange(SpreadsheetVersion.EXCEL2007));
+        
+        ref = new CellRangeAddress(0, 1048575, 0, 0);
+        assertTrue(ref.isFullColumnRange(SpreadsheetVersion.EXCEL2007));
+        
+        ref = new CellRangeAddress(0, 1048576, 0, 0);
+        assertFalse(ref.isFullColumnRange(SpreadsheetVersion.EXCEL2007));
+        
+        // Does -1, -1 mean this is an invalid/deleted reference? Is this a relevant test?
+        ref = new CellRangeAddress(-1, -1, 0, 0);
+        assertTrue(ref.isFullColumnRange(SpreadsheetVersion.EXCEL97));
+        assertTrue(ref.isFullColumnRange(SpreadsheetVersion.EXCEL2007));
+    }
+    
+    public static void testEquals() {
+        final CellRangeAddress a = new CellRangeAddress(0, 0, 0, 0);
+        final CellRangeAddress b = new CellRangeAddress(0, 0, 0, 0);
+        assertNotSame(a, b);
+        assertEquals(a, b);
+    }
+    
+    public static void testHashCode() {
+        final CellRangeAddress a = new CellRangeAddress(0, 0, 0, 0);
+        final CellRangeAddress b = new CellRangeAddress(0, 0, 0, 0);
+        assertNotSame(a, b);
+        assertEquals(a.hashCode(), b.hashCode());
+    }
 }