Adjust Bin2Dec similar to what we did for Hex2Dec in Bug 57196 and fix some smaller problems in the implementation found while adding full unit tests

git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@1650654 13f79535-47bb-0310-9956-ffa450edef68

4 files changed, 501 insertions, 5 deletions

diff --git a/src/testcases/org/apache/poi/ss/formula/functions/TestBin2Dec.java b/src/testcases/org/apache/poi/ss/formula/functions/TestBin2Dec.java
new file mode 100644
index 0000000000..0f3fff9a98
--- /dev/null
+++ b/src/testcases/org/apache/poi/ss/formula/functions/TestBin2Dec.java
@@ -0,0 +1,113 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.ss.formula.functions;
+
+import junit.framework.TestCase;
+
+import org.apache.poi.hssf.usermodel.HSSFEvaluationWorkbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
+import org.apache.poi.ss.formula.IStabilityClassifier;
+import org.apache.poi.ss.formula.OperationEvaluationContext;
+import org.apache.poi.ss.formula.WorkbookEvaluator;
+import org.apache.poi.ss.formula.eval.ErrorEval;
+import org.apache.poi.ss.formula.eval.NumberEval;
+import org.apache.poi.ss.formula.eval.StringEval;
+import org.apache.poi.ss.formula.eval.ValueEval;
+
+/**
+ * Tests for {@link Bin2Dec}
+ *
+ * @author cedric dot walter @ gmail dot com
+ */
+public final class TestBin2Dec extends TestCase {
+
+    private static ValueEval invokeValue(String number1) {
+		ValueEval[] args = new ValueEval[] { new StringEval(number1) };
+		return new Bin2Dec().evaluate(args, -1, -1);
+	}
+
+    private static void confirmValue(String msg, String number1, String expected) {
+		ValueEval result = invokeValue(number1);
+		assertEquals("Had: " + result.toString(), NumberEval.class, result.getClass());
+		assertEquals(msg, expected, ((NumberEval) result).getStringValue());
+	}
+
+    private static void confirmValueError(String msg, String number1, ErrorEval numError) {
+        ValueEval result = invokeValue(number1);
+        assertEquals(ErrorEval.class, result.getClass());
+        assertEquals(msg, numError, result);
+    }
+
+	public void testBasic() {
+		confirmValue("Converts binary '00101' to decimal (5)", "00101", "5");
+		confirmValue("Converts binary '1111111111' to decimal (-1)", "1111111111", "-1");
+		confirmValue("Converts binary '1111111110' to decimal (-2)", "1111111110", "-2");
+        confirmValue("Converts binary '0111111111' to decimal (511)", "0111111111", "511");
+	}
+
+    public void testErrors() {
+        confirmValueError("does not support more than 10 digits","01010101010", ErrorEval.NUM_ERROR);
+        confirmValueError("not a valid binary number","GGGGGGG", ErrorEval.NUM_ERROR);
+        confirmValueError("not a valid binary number","3.14159", ErrorEval.NUM_ERROR);
+    }
+
+    public void testEvalOperationEvaluationContext() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0) };
+        ValueEval result = new Bin2Dec().evaluate(args, ctx);
+
+        assertEquals(NumberEval.class, result.getClass());
+        assertEquals("0", ((NumberEval) result).getStringValue());
+    }
+    
+    public void testEvalOperationEvaluationContextFails() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0), ctx.getRefEval(0, 0) };
+        ValueEval result = new Bin2Dec().evaluate(args, ctx);
+
+        assertEquals(ErrorEval.class, result.getClass());
+        assertEquals(ErrorEval.VALUE_INVALID, result);
+    }
+
+    private OperationEvaluationContext createContext() {
+        HSSFWorkbook wb = new HSSFWorkbook();
+        wb.createSheet();
+        HSSFEvaluationWorkbook workbook = HSSFEvaluationWorkbook.create(wb);
+        WorkbookEvaluator workbookEvaluator = new WorkbookEvaluator(workbook, new IStabilityClassifier() {
+            
+            public boolean isCellFinal(int sheetIndex, int rowIndex, int columnIndex) {
+                return true;
+            }
+        }, null);
+        OperationEvaluationContext ctx = new OperationEvaluationContext(workbookEvaluator, 
+                workbook, 0, 0, 0, null);
+        return ctx;
+    }
+
+    public void testRefs() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0) };
+        ValueEval result = new Bin2Dec().evaluate(args, -1, -1);
+
+        assertEquals(NumberEval.class, result.getClass());
+        assertEquals("0", ((NumberEval) result).getStringValue());
+    }
+}
diff --git a/src/testcases/org/apache/poi/ss/formula/functions/TestDec2Bin.java b/src/testcases/org/apache/poi/ss/formula/functions/TestDec2Bin.java
new file mode 100644
index 0000000000..0000b64b28
--- /dev/null
+++ b/src/testcases/org/apache/poi/ss/formula/functions/TestDec2Bin.java
@@ -0,0 +1,240 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.ss.formula.functions;
+
+import junit.framework.TestCase;
+
+import org.apache.poi.hssf.usermodel.HSSFEvaluationWorkbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
+import org.apache.poi.ss.formula.IStabilityClassifier;
+import org.apache.poi.ss.formula.OperationEvaluationContext;
+import org.apache.poi.ss.formula.WorkbookEvaluator;
+import org.apache.poi.ss.formula.eval.ErrorEval;
+import org.apache.poi.ss.formula.eval.NumberEval;
+import org.apache.poi.ss.formula.eval.StringEval;
+import org.apache.poi.ss.formula.eval.ValueEval;
+import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.ss.usermodel.Sheet;
+
+/**
+ * Tests for {@link Dec2Bin}
+ *
+ * @author cedric dot walter @ gmail dot com
+ */
+public final class TestDec2Bin extends TestCase {
+
+    private static ValueEval invokeValue(String number1) {
+		ValueEval[] args = new ValueEval[] { new StringEval(number1) };
+		return new Dec2Bin().evaluate(args, -1, -1);
+	}
+
+    private static ValueEval invokeBack(String number1) {
+        ValueEval[] args = new ValueEval[] { new StringEval(number1) };
+        return new Bin2Dec().evaluate(args, -1, -1);
+    }
+
+    private static void confirmValue(String msg, String number1, String expected) {
+		ValueEval result = invokeValue(number1);
+		assertEquals("Had: " + result.toString(), StringEval.class, result.getClass());
+		assertEquals(msg, expected, ((StringEval) result).getStringValue());
+	}
+
+    private static void confirmValueError(String msg, String number1, ErrorEval numError) {
+        ValueEval result = invokeValue(number1);
+        assertEquals(ErrorEval.class, result.getClass());
+        assertEquals(msg, numError, result);
+    }
+
+	public void testBasic() {
+		confirmValue("Converts binary '00101' from binary (5)", "5", "101");
+		confirmValue("Converts binary '1111111111' from binary (-1)", "-1",    "1111111111");
+		confirmValue("Converts binary '1111111110' from binary (-2)", "-2",    "1111111110");
+        confirmValue("Converts binary '0111111111' from binary (511)", "511",   "111111111");
+        confirmValue("Converts binary '1000000000' from binary (511)", "-512", "1000000000");
+	}
+
+    public void testErrors() {
+        confirmValueError("fails for >= 512 or < -512","512", ErrorEval.NUM_ERROR);
+        confirmValueError("fails for >= 512 or < -512","-513", ErrorEval.NUM_ERROR);
+        confirmValueError("not a valid decimal number","GGGGGGG", ErrorEval.VALUE_INVALID);
+        confirmValueError("not a valid decimal number","3.14159a", ErrorEval.VALUE_INVALID);
+    }
+
+    public void testEvalOperationEvaluationContext() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0) };
+        ValueEval result = new Dec2Bin().evaluate(args, ctx);
+
+        assertEquals(StringEval.class, result.getClass());
+        assertEquals("1101", ((StringEval) result).getStringValue());
+    }
+
+    public void testEvalOperationEvaluationContextFails() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ErrorEval.VALUE_INVALID };
+        ValueEval result = new Dec2Bin().evaluate(args, ctx);
+
+        assertEquals(ErrorEval.class, result.getClass());
+        assertEquals(ErrorEval.VALUE_INVALID, result);
+    }
+
+    private OperationEvaluationContext createContext() {
+        HSSFWorkbook wb = new HSSFWorkbook();
+        Sheet sheet = wb.createSheet();
+        Row row = sheet.createRow(0);
+        Cell cell = row.createCell(0);
+        cell.setCellValue("13.43");
+        cell = row.createCell(1);
+        cell.setCellValue("8");
+        cell = row.createCell(2);
+        cell.setCellValue("-8");
+        cell = row.createCell(3);
+        cell.setCellValue("1");
+
+        HSSFEvaluationWorkbook workbook = HSSFEvaluationWorkbook.create(wb);
+        WorkbookEvaluator workbookEvaluator = new WorkbookEvaluator(workbook, new IStabilityClassifier() {
+            
+            public boolean isCellFinal(int sheetIndex, int rowIndex, int columnIndex) {
+                return true;
+            }
+        }, null);
+        OperationEvaluationContext ctx = new OperationEvaluationContext(workbookEvaluator, 
+                workbook, 0, 0, 0, null);
+        return ctx;
+    }
+
+    public void testRefs() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0) };
+        ValueEval result = new Dec2Bin().evaluate(args, -1, -1);
+
+        assertEquals("Had: " + result.toString(), StringEval.class, result.getClass());
+        assertEquals("1101", ((StringEval) result).getStringValue());
+    }
+
+    public void testWithPlacesIntInt() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0), ctx.getRefEval(0, 1) };
+        ValueEval result = new Dec2Bin().evaluate(args, -1, -1);
+
+        assertEquals("Had: " + result.toString(), StringEval.class, result.getClass());
+        // TODO: documentation and behavior do not match here!
+        assertEquals("1101", ((StringEval) result).getStringValue());
+    }
+
+    public void testWithPlaces() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0), ctx.getRefEval(0, 1) };
+        ValueEval result = new Dec2Bin().evaluate(args, ctx);
+
+        assertEquals("Had: " + result.toString(), StringEval.class, result.getClass());
+        // TODO: documentation and behavior do not match here!
+        assertEquals("1101", ((StringEval) result).getStringValue());
+    }
+
+    public void testWithToShortPlaces() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0), ctx.getRefEval(0, 3) };
+        ValueEval result = new Dec2Bin().evaluate(args, -1, -1);
+
+        assertEquals(ErrorEval.class, result.getClass());
+        assertEquals(ErrorEval.NUM_ERROR, result);
+    }
+
+    public void testWithTooManyParamsIntInt() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0), ctx.getRefEval(0, 1), ctx.getRefEval(0, 1) };
+        ValueEval result = new Dec2Bin().evaluate(args, -1, -1);
+
+        assertEquals(ErrorEval.class, result.getClass());
+        assertEquals(ErrorEval.VALUE_INVALID, result);
+    }
+
+    public void testWithTooManyParams() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0), ctx.getRefEval(0, 1), ctx.getRefEval(0, 1) };
+        ValueEval result = new Dec2Bin().evaluate(args, ctx);
+
+        assertEquals(ErrorEval.class, result.getClass());
+        assertEquals(ErrorEval.VALUE_INVALID, result);
+    }
+
+    public void testWithErrorPlaces() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0), ErrorEval.NULL_INTERSECTION };
+        ValueEval result = new Dec2Bin().evaluate(args, -1, -1);
+
+        assertEquals(ErrorEval.class, result.getClass());
+        assertEquals(ErrorEval.NULL_INTERSECTION, result);
+    }
+
+    public void testWithNegativePlaces() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0), ctx.getRefEval(0, 2) };
+        ValueEval result = new Dec2Bin().evaluate(args, -1, -1);
+
+        assertEquals(ErrorEval.class, result.getClass());
+        assertEquals(ErrorEval.NUM_ERROR, result);
+    }
+
+    public void testWithZeroPlaces() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0), new NumberEval(0.0) };
+        ValueEval result = new Dec2Bin().evaluate(args, -1, -1);
+
+        assertEquals(ErrorEval.class, result.getClass());
+        assertEquals(ErrorEval.NUM_ERROR, result);
+    }
+
+    public void testWithEmptyPlaces() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0), ctx.getRefEval(1, 0) };
+        ValueEval result = new Dec2Bin().evaluate(args, -1, -1);
+
+        assertEquals(ErrorEval.class, result.getClass());
+        assertEquals(ErrorEval.VALUE_INVALID, result);
+    }
+    
+    public void testBackAndForth() {
+        for (int i = -512; i < 512; i++) {
+            ValueEval result = invokeValue(Integer.toString(i));
+            assertEquals("Had: " + result.toString(), StringEval.class,
+                    result.getClass());
+
+            ValueEval back = invokeBack(((StringEval) result).getStringValue());
+            assertEquals("Had: " + back.toString(), NumberEval.class,
+                    back.getClass());
+
+            assertEquals(Integer.toString(i),
+                    ((NumberEval) back).getStringValue());
+        }
+    }
+}
diff --git a/src/testcases/org/apache/poi/ss/formula/functions/TestDec2Hex.java b/src/testcases/org/apache/poi/ss/formula/functions/TestDec2Hex.java
index a2a77ebb2c..f860aff2a5 100644
--- a/src/testcases/org/apache/poi/ss/formula/functions/TestDec2Hex.java
+++ b/src/testcases/org/apache/poi/ss/formula/functions/TestDec2Hex.java
@@ -18,9 +18,19 @@
 package org.apache.poi.ss.formula.functions;
 
 import junit.framework.TestCase;
+
+import org.apache.poi.hssf.usermodel.HSSFEvaluationWorkbook;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
+import org.apache.poi.ss.formula.IStabilityClassifier;
+import org.apache.poi.ss.formula.OperationEvaluationContext;
+import org.apache.poi.ss.formula.WorkbookEvaluator;
 import org.apache.poi.ss.formula.eval.ErrorEval;
+import org.apache.poi.ss.formula.eval.NumberEval;
 import org.apache.poi.ss.formula.eval.StringEval;
 import org.apache.poi.ss.formula.eval.ValueEval;
+import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.ss.usermodel.Sheet;
 
 /**
  * Tests for {@link Dec2Hex}
@@ -34,6 +44,11 @@ public final class TestDec2Hex extends TestCase {
 		return new Dec2Hex().evaluate(args, -1, -1);
 	}
 
+    private static ValueEval invokeBack(String number1) {
+        ValueEval[] args = new ValueEval[] { new StringEval(number1) };
+        return new Hex2Dec().evaluate(args, -1, -1);
+    }
+
     private static ValueEval invokeValue(String number1) {
 		ValueEval[] args = new ValueEval[] { new StringEval(number1), };
 		return new Dec2Hex().evaluate(args, -1, -1);
@@ -75,4 +90,132 @@ public final class TestDec2Hex extends TestCase {
         confirmValueError("negative places not allowed","549755813888","-10", ErrorEval.NUM_ERROR);
         confirmValueError("non number places not allowed","ABCDEF","0", ErrorEval.VALUE_INVALID);
     }
+
+    public void testEvalOperationEvaluationContextFails() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ErrorEval.VALUE_INVALID };
+        ValueEval result = new Dec2Hex().evaluate(args, ctx);
+
+        assertEquals(ErrorEval.class, result.getClass());
+        assertEquals(ErrorEval.VALUE_INVALID, result);
+    }
+
+    private OperationEvaluationContext createContext() {
+        HSSFWorkbook wb = new HSSFWorkbook();
+        Sheet sheet = wb.createSheet();
+        Row row = sheet.createRow(0);
+        Cell cell = row.createCell(0);
+        cell.setCellValue("123.43");
+        cell = row.createCell(1);
+        cell.setCellValue("8");
+        cell = row.createCell(2);
+        cell.setCellValue("-8");
+
+        HSSFEvaluationWorkbook workbook = HSSFEvaluationWorkbook.create(wb);
+        WorkbookEvaluator workbookEvaluator = new WorkbookEvaluator(workbook, new IStabilityClassifier() {
+            
+            public boolean isCellFinal(int sheetIndex, int rowIndex, int columnIndex) {
+                return true;
+            }
+        }, null);
+        OperationEvaluationContext ctx = new OperationEvaluationContext(workbookEvaluator, 
+                workbook, 0, 0, 0, null);
+        return ctx;
+    }
+
+    public void testRefs() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0) };
+        ValueEval result = new Dec2Hex().evaluate(args, -1, -1);
+
+        assertEquals("Had: " + result.toString(), StringEval.class, result.getClass());
+        assertEquals("7B", ((StringEval) result).getStringValue());
+    }
+
+    public void testWithPlacesIntInt() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0), ctx.getRefEval(0, 1) };
+        ValueEval result = new Dec2Hex().evaluate(args, -1, -1);
+
+        assertEquals("Had: " + result.toString(), StringEval.class, result.getClass());
+        assertEquals("0000007B", ((StringEval) result).getStringValue());
+    }
+
+    public void testWithPlaces() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0), ctx.getRefEval(0, 1) };
+        ValueEval result = new Dec2Hex().evaluate(args, ctx);
+
+        assertEquals("Had: " + result.toString(), StringEval.class, result.getClass());
+        assertEquals("0000007B", ((StringEval) result).getStringValue());
+    }
+
+    public void testWithTooManyParamsIntInt() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0), ctx.getRefEval(0, 1), ctx.getRefEval(0, 1) };
+        ValueEval result = new Dec2Hex().evaluate(args, -1, -1);
+
+        assertEquals(ErrorEval.class, result.getClass());
+        assertEquals(ErrorEval.VALUE_INVALID, result);
+    }
+
+    public void testWithTooManyParams() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0), ctx.getRefEval(0, 1), ctx.getRefEval(0, 1) };
+        ValueEval result = new Dec2Hex().evaluate(args, ctx);
+
+        assertEquals(ErrorEval.class, result.getClass());
+        assertEquals(ErrorEval.VALUE_INVALID, result);
+    }
+
+    public void testWithErrorPlaces() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0), ErrorEval.NULL_INTERSECTION };
+        ValueEval result = new Dec2Hex().evaluate(args, -1, -1);
+
+        assertEquals(ErrorEval.class, result.getClass());
+        assertEquals(ErrorEval.NULL_INTERSECTION, result);
+    }
+
+    public void testWithNegativePlaces() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0), ctx.getRefEval(0, 2) };
+        ValueEval result = new Dec2Hex().evaluate(args, -1, -1);
+
+        assertEquals(ErrorEval.class, result.getClass());
+        assertEquals(ErrorEval.NUM_ERROR, result);
+    }
+
+    public void testWithEmptyPlaces() {
+        OperationEvaluationContext ctx = createContext();
+        
+        ValueEval[] args = new ValueEval[] { ctx.getRefEval(0, 0), ctx.getRefEval(1, 0) };
+        ValueEval result = new Dec2Hex().evaluate(args, -1, -1);
+
+        assertEquals(ErrorEval.class, result.getClass());
+        assertEquals(ErrorEval.VALUE_INVALID, result);
+    }
+
+    public void testBackAndForth() {
+        for (int i = -512; i < 512; i++) {
+            ValueEval result = invokeValue(Integer.toString(i));
+            assertEquals("Had: " + result.toString(), StringEval.class,
+                    result.getClass());
+
+            ValueEval back = invokeBack(((StringEval) result).getStringValue());
+            assertEquals("Had: " + back.toString(), NumberEval.class,
+                    back.getClass());
+
+            assertEquals(Integer.toString(i),
+                    ((NumberEval) back).getStringValue());
+        }
+    }
 }
diff --git a/src/testcases/org/apache/poi/ss/formula/functions/TestHex2Dec.java b/src/testcases/org/apache/poi/ss/formula/functions/TestHex2Dec.java
index b7ca30cd51..a3b971a357 100644
--- a/src/testcases/org/apache/poi/ss/formula/functions/TestHex2Dec.java
+++ b/src/testcases/org/apache/poi/ss/formula/functions/TestHex2Dec.java
@@ -54,14 +54,14 @@ public final class TestHex2Dec extends TestCase {
     }
 
 	public void testBasic() {
-		confirmValue("Converts octal 'A5' to decimal (165)", "A5", "165");
-		confirmValue("Converts octal FFFFFFFF5B to decimal (-165)", "FFFFFFFF5B", "-165");
-		confirmValue("Converts octal 3DA408B9 to decimal (-165)", "3DA408B9", "1034160313");
+		confirmValue("Converts hex 'A5' to decimal (165)", "A5", "165");
+		confirmValue("Converts hex FFFFFFFF5B to decimal (-165)", "FFFFFFFF5B", "-165");
+		confirmValue("Converts hex 3DA408B9 to decimal (-165)", "3DA408B9", "1034160313");
 	}
 
     public void testErrors() {
-        confirmValueError("not a valid octal number","GGGGGGG", ErrorEval.NUM_ERROR);
-        confirmValueError("not a valid octal number","3.14159", ErrorEval.NUM_ERROR);
+        confirmValueError("not a valid hex number","GGGGGGG", ErrorEval.NUM_ERROR);
+        confirmValueError("not a valid hex number","3.14159", ErrorEval.NUM_ERROR);
     }
 
     public void testEvalOperationEvaluationContext() {