]> source.dussan.org Git - poi.git/commitdiff
Adjust Bin2Dec similar to what we did for Hex2Dec in Bug 57196 and fix some smaller...
authorDominik Stadler <centic@apache.org>
Fri, 9 Jan 2015 20:37:11 +0000 (20:37 +0000)
committerDominik Stadler <centic@apache.org>
Fri, 9 Jan 2015 20:37:11 +0000 (20:37 +0000)
git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@1650654 13f79535-47bb-0310-9956-ffa450edef68

src/java/org/apache/poi/ss/formula/functions/Bin2Dec.java
src/java/org/apache/poi/ss/formula/functions/Dec2Bin.java
src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFBugs.java
src/testcases/org/apache/poi/ss/formula/functions/TestBin2Dec.java [new file with mode: 0644]
src/testcases/org/apache/poi/ss/formula/functions/TestDec2Bin.java [new file with mode: 0644]
src/testcases/org/apache/poi/ss/formula/functions/TestDec2Hex.java
src/testcases/org/apache/poi/ss/formula/functions/TestHex2Dec.java

index added40cc0ae571688309e1e5f6f8edf2234e2a7..9617877ca6675925576746e8a43dc9b79b36b538 100644 (file)
@@ -20,6 +20,7 @@ import org.apache.poi.ss.formula.OperationEvaluationContext;
 import org.apache.poi.ss.formula.eval.ErrorEval;\r
 import org.apache.poi.ss.formula.eval.NumberEval;\r
 import org.apache.poi.ss.formula.eval.OperandResolver;\r
+import org.apache.poi.ss.formula.eval.RefEval;\r
 import org.apache.poi.ss.formula.eval.ValueEval;\r
 \r
 /**\r
@@ -44,7 +45,13 @@ public class Bin2Dec extends Fixed1ArgFunction implements FreeRefFunction {
     public static final FreeRefFunction instance = new Bin2Dec();\r
 \r
     public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval numberVE) {\r
-        String number = OperandResolver.coerceValueToString(numberVE);\r
+        final String number;\r
+        if (numberVE instanceof RefEval) {\r
+            RefEval re = (RefEval) numberVE;\r
+            number = OperandResolver.coerceValueToString(re.getInnerValueEval(re.getFirstSheetIndex()));\r
+        } else {\r
+            number = OperandResolver.coerceValueToString(numberVE);\r
+        }\r
         if (number.length() > 10) {\r
             return ErrorEval.NUM_ERROR;\r
         }\r
@@ -62,22 +69,25 @@ public class Bin2Dec extends Fixed1ArgFunction implements FreeRefFunction {
         }\r
 \r
         String value;\r
-        int sum;\r
-        if (isPositive) {\r
-            //bit9*2^8 + bit8*2^7 + bit7*2^6 + bit6*2^5 + bit5*2^4+ bit3*2^2+ bit2*2^1+ bit1*2^0\r
-            sum = getDecimalValue(unsigned);\r
-            value = String.valueOf(sum);\r
-        } else {\r
-            //The leftmost bit is 1 -- this is negative number\r
-            //Inverse bits [1-9]\r
-            String inverted = toggleBits(unsigned);\r
-            // Calculate decimal number\r
-            sum = getDecimalValue(inverted);\r
-\r
-            //Add 1 to obtained number\r
-            sum++;\r
-\r
-            value = "-" + String.valueOf(sum);\r
+        try {\r
+            if (isPositive) {\r
+                //bit9*2^8 + bit8*2^7 + bit7*2^6 + bit6*2^5 + bit5*2^4+ bit3*2^2+ bit2*2^1+ bit1*2^0\r
+                int sum = getDecimalValue(unsigned);\r
+                value = String.valueOf(sum);\r
+            } else {\r
+                //The leftmost bit is 1 -- this is negative number\r
+                //Inverse bits [1-9]\r
+                String inverted = toggleBits(unsigned);\r
+                // Calculate decimal number\r
+                int sum = getDecimalValue(inverted);\r
+    \r
+                //Add 1 to obtained number\r
+                sum++;\r
+    \r
+                value = "-" + String.valueOf(sum);\r
+            }\r
+        } catch (NumberFormatException e) {\r
+            return ErrorEval.NUM_ERROR;\r
         }\r
 \r
         return new NumberEval(Long.parseLong(value));\r
index 814b3eb2c68029dd2550057820eca54767e9aed4..21d8bcfaf04dcd9147fce1498dbca6485643e4e9 100644 (file)
@@ -52,8 +52,8 @@ public class Dec2Bin extends Var1or2ArgFunction implements FreeRefFunction {
 \r
     public static final FreeRefFunction instance = new Dec2Bin();\r
 \r
-    private final static long MIN_VALUE = Long.parseLong("-512");\r
-    private final static long MAX_VALUE = Long.parseLong("512");\r
+    private final static long MIN_VALUE = -512;\r
+    private final static long MAX_VALUE =  511;\r
     private final static int DEFAULT_PLACES_VALUE = 10;\r
 \r
     public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval numberVE, ValueEval placesVE) {\r
index 49683edb0662bb5abdea83e9fe67699cd9fb99fb..dfbcdf02f250bb051a78a94031be37cc375c5e47 100644 (file)
@@ -1974,6 +1974,11 @@ public final class TestXSSFBugs extends BaseTestBugzillaIssues {
             XSSFSheet sheet = wb.createSheet("Sheet1");
             XSSFRow row = sheet.createRow(0);
             XSSFCell cell = row.createCell(0);
+            cell.setCellValue("0");
+            cell = row.createCell(1);
+            cell.setCellValue(0);
+            cell = row.createCell(2);
+            cell.setCellValue(0);
 
             // simple formula worked
             cell.setCellFormula("DEC2HEX(O2+D2)");
@@ -2004,6 +2009,30 @@ public final class TestXSSFBugs extends BaseTestBugzillaIssues {
 
             workbookEvaluator.setDebugEvaluationOutputForNextEval(true);
             workbookEvaluator.evaluate(new XSSFEvaluationCell(cell));
+
+            // what other similar functions
+            cell.setCellFormula("DEC2BIN(O8)-O2+D2");
+            workbookEvaluator.clearAllCachedResultValues();
+    
+            workbookEvaluator = new WorkbookEvaluator(XSSFEvaluationWorkbook.create(wb), null, null);
+            workbookEvaluator.setDebugEvaluationOutputForNextEval(true);
+            workbookEvaluator.evaluate(new XSSFEvaluationCell(cell));
+
+            // what other similar functions
+            cell.setCellFormula("DEC2BIN(A1)");
+            workbookEvaluator.clearAllCachedResultValues();
+    
+            workbookEvaluator = new WorkbookEvaluator(XSSFEvaluationWorkbook.create(wb), null, null);
+            workbookEvaluator.setDebugEvaluationOutputForNextEval(true);
+            workbookEvaluator.evaluate(new XSSFEvaluationCell(cell));
+
+            // what other similar functions
+            cell.setCellFormula("BIN2DEC(B1)");
+            workbookEvaluator.clearAllCachedResultValues();
+    
+            workbookEvaluator = new WorkbookEvaluator(XSSFEvaluationWorkbook.create(wb), null, null);
+            workbookEvaluator.setDebugEvaluationOutputForNextEval(true);
+            workbookEvaluator.evaluate(new XSSFEvaluationCell(cell));
         } finally {
             System.clearProperty("org.apache.poi.util.POILogger");
             System.clearProperty("poi.log.level");
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 (file)
index 0000000..0f3fff9
--- /dev/null
@@ -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 (file)
index 0000000..0000b64
--- /dev/null
@@ -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());
+        }
+    }
+}
index a2a77ebb2c082f43125169bccb9b2309ca421e02..f860aff2a51fd2494f9c83609b50723c60e1ce00 100644 (file)
 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());
+        }
+    }
 }
index b7ca30cd514a825e6cd2d2a20d6089f97f45d74a..a3b971a357e167313e8654cff4cc004c5c9671ea 100644 (file)
@@ -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() {