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
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
}\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
\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
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)");
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");
--- /dev/null
+/* ====================================================================
+ 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());
+ }
+}
--- /dev/null
+/* ====================================================================
+ 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());
+ }
+ }
+}
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}
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);
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());
+ }
+ }
}
}
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() {