Added toString methods formatAsString to CellValue. Changed deprecation on CellValue.getRichTextStringValue

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

src/java/org/apache/poi/hssf/usermodel/HSSFFormulaEvaluator.java

@@ -179,7 +179,7 @@ public class HSSFFormulaEvaluator {
             case HSSFCell.CELL_TYPE_NUMERIC:
                 return new CellValue(cell.getNumericCellValue());
             case HSSFCell.CELL_TYPE_STRING:
-                return new CellValue(cell.getRichStringCellValue());
+                return new CellValue(cell.getRichStringCellValue().getString());
         }
         throw new IllegalStateException("Bad cell type (" + cell.getCellType() + ")");
     }
@@ -270,7 +270,7 @@ public class HSSFFormulaEvaluator {
                 cell.setCellValue(cv.getNumberValue());
                 break;
             case HSSFCell.CELL_TYPE_STRING:
-                cell.setCellValue(cv.getRichTextStringValue());
+                cell.setCellValue(new HSSFRichTextString(cv.getStringValue()));
                 break;
             case HSSFCell.CELL_TYPE_BLANK:
                 // never happens - blanks eventually get translated to zero
@@ -325,7 +325,7 @@ public class HSSFFormulaEvaluator {
         }
         if (eval instanceof StringEval) {
             StringEval ne = (StringEval) eval;
-            return new CellValue(new HSSFRichTextString(ne.getStringValue()));
+            return new CellValue(ne.getStringValue());
         }
         if (eval instanceof ErrorEval) {
             return CellValue.getError(((ErrorEval)eval).getErrorCode());
@@ -423,7 +423,7 @@ public class HSSFFormulaEvaluator {
             throw new IllegalStateException("evaluation stack not empty");
         }
         value = dereferenceValue(value, srcRowNum, srcColNum);
-        if (value instanceof BlankEval) {
+        if (value == BlankEval.INSTANCE) {
             // Note Excel behaviour here. A blank final final value is converted to zero.
             return NumberEval.ZERO;
             // Formulas _never_ evaluate to blank.  If a formula appears to have evaluated to
@@ -597,15 +597,15 @@ public class HSSFFormulaEvaluator {
         private final int _cellType;
         private final double _numberValue;
         private final boolean _booleanValue;
-        private final HSSFRichTextString _richTextStringValue;
+        private final String _textValue;
         private final int _errorCode;
 
         private CellValue(int cellType, double numberValue, boolean booleanValue, 
-                HSSFRichTextString textValue, int errorCode) {
+                String textValue, int errorCode) {
             _cellType = cellType;
             _numberValue = numberValue;
             _booleanValue = booleanValue;
-            _richTextStringValue = textValue;
+            _textValue = textValue;
             _errorCode = errorCode;
         }
         
@@ -616,7 +616,7 @@ public class HSSFFormulaEvaluator {
         /* package*/ static CellValue valueOf(boolean booleanValue) {
             return booleanValue ? TRUE : FALSE;
         }
-        /* package*/ CellValue(HSSFRichTextString stringValue) {
+        /* package*/ CellValue(String stringValue) {
             this(HSSFCell.CELL_TYPE_STRING, 0.0, false, stringValue, 0);
         }
         /* package*/ static CellValue getError(int errorCode) {
@@ -637,12 +637,10 @@ public class HSSFFormulaEvaluator {
             return _numberValue;
         }
         /**
-         * @return Returns the stringValue. This method is deprecated, use
+         * @return Returns the stringValue.
-         * getRichTextStringValue instead
-         * @deprecated
          */
         public String getStringValue() {
-            return _richTextStringValue.getString();
+            return _textValue;
         }
         /**
          * @return Returns the cellType.
@@ -658,9 +656,31 @@ public class HSSFFormulaEvaluator {
         }
         /**
          * @return Returns the richTextStringValue.
+         * @deprecated (Sep 2008) Text formatting is lost during formula evaluation.  Use {@link #getStringValue()}  
          */
         public HSSFRichTextString getRichTextStringValue() {
-            return _richTextStringValue;
+            return new HSSFRichTextString(_textValue);
+        }
+        public String toString() {
+            StringBuffer sb = new StringBuffer(64);
+            sb.append(getClass().getName()).append(" [");
+            sb.append(formatAsString());
+            sb.append("]");
+            return sb.toString();
+        }
+
+        public String formatAsString() {
+            switch (_cellType) {
+                case HSSFCell.CELL_TYPE_NUMERIC:
+                    return String.valueOf(_numberValue);
+                case HSSFCell.CELL_TYPE_STRING:
+                    return '"' + _textValue + '"';
+                case HSSFCell.CELL_TYPE_BOOLEAN:
+                    return _booleanValue ? "TRUE" : "FALSE";
+                case HSSFCell.CELL_TYPE_ERROR:
+                    return ErrorEval.getText(_errorCode);
+            }
+            return "<error unexpected cell type " + _cellType + ">";
         }
     }
 

src/testcases/org/apache/poi/hssf/record/formula/eval/TestFormulasFromSpreadsheet.java

@@ -132,7 +132,7 @@ public final class TestFormulasFromSpreadsheet extends TestCase {
 				break;
 			case HSSFCell.CELL_TYPE_STRING:
 				assertEquals(msg, HSSFCell.CELL_TYPE_STRING, actual.getCellType());
-				assertEquals(msg, expected.getRichStringCellValue().getString(), actual.getRichTextStringValue().getString());
+				assertEquals(msg, expected.getRichStringCellValue().getString(), actual.getStringValue());
 				break;
 		}
 	}
@@ -142,7 +142,7 @@ public final class TestFormulasFromSpreadsheet extends TestCase {
 		if (workbook == null) {
 			workbook = HSSFTestDataSamples.openSampleWorkbook(SS.FILENAME);
 			sheet = workbook.getSheetAt( 0 );
-		  }
+		}
 		_functionFailureCount = 0;
 		_functionSuccessCount = 0;
 		_evaluationFailureCount = 0;
@@ -177,7 +177,7 @@ public final class TestFormulasFromSpreadsheet extends TestCase {
 	 * Typically pass <code>null</code> to test all functions
 	 */
 	private void processFunctionGroup(int startRowIndex, String testFocusFunctionName) {
- 
+
 		HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(workbook);
 
 		int rowIndex = startRowIndex;
@@ -248,7 +248,7 @@ public final class TestFormulasFromSpreadsheet extends TestCase {
 				result = Result.SOME_EVALUATIONS_FAILED;
 			}
 		}
- 		return result;
+		return result;
 	}
 
 	/**

src/testcases/org/apache/poi/hssf/record/formula/functions/TestIndexFunctionFromSpreadsheet.java

@@ -59,7 +59,7 @@ public final class TestIndexFunctionFromSpreadsheet extends TestCase {
 
 	}
 
- 	// Note - multiple failures are aggregated before ending.
+	// Note - multiple failures are aggregated before ending.
 	// If one or more functions fail, a single AssertionFailedError is thrown at the end
 	private int _evaluationFailureCount;
 	private int _evaluationSuccessCount;
@@ -95,7 +95,7 @@ public final class TestIndexFunctionFromSpreadsheet extends TestCase {
 				assertEquals(expected.getNumericCellValue(), actual.getNumberValue(), 0.0);
 				break;
 			case HSSFCell.CELL_TYPE_STRING:
-				assertEquals(msg, expected.getRichStringCellValue().getString(), actual.getRichTextStringValue().getString());
+				assertEquals(msg, expected.getRichStringCellValue().getString(), actual.getStringValue());
 				break;
 		}
 	}
@@ -103,7 +103,7 @@ public final class TestIndexFunctionFromSpreadsheet extends TestCase {
 
 	private static AssertionFailedError wrongTypeError(String msgPrefix, HSSFCell expectedCell, CellValue actualValue) {
 		return new AssertionFailedError(msgPrefix + " Result type mismatch. Evaluated result was "
-				+ formatValue(actualValue)
+				+ actualValue.formatAsString()
 				+ " but the expected result was "
 				+ formatValue(expectedCell)
 				);
@@ -121,7 +121,7 @@ public final class TestIndexFunctionFromSpreadsheet extends TestCase {
 		if(actual.getCellType() != HSSFCell.CELL_TYPE_ERROR) {
 			throw new AssertionFailedError(msgPrefix + " Expected cell error ("
 					+ ErrorEval.getText(expectedErrorCode) + ") but actual value was "
-					+ formatValue(actual));
+					+ actual.formatAsString());
 		}
 		if(expectedErrorCode != actual.getErrorValue()) {
 			throw new AssertionFailedError(msgPrefix + " Expected cell error code ("
@@ -142,15 +142,6 @@ public final class TestIndexFunctionFromSpreadsheet extends TestCase {
 		}
 		throw new RuntimeException("Unexpected cell type of expected value (" + expecedCell.getCellType() + ")");
 	}
-	private static String formatValue(CellValue actual) {
-		switch (actual.getCellType()) {
-			case HSSFCell.CELL_TYPE_BLANK: return "<blank>";
-			case HSSFCell.CELL_TYPE_BOOLEAN: return String.valueOf(actual.getBooleanValue());
-			case HSSFCell.CELL_TYPE_NUMERIC: return String.valueOf(actual.getNumberValue());
-			case HSSFCell.CELL_TYPE_STRING: return actual.getRichTextStringValue().getString();
-		}
-		throw new RuntimeException("Unexpected cell type of evaluated value (" + actual.getCellType() + ")");
-	}
 
 
 	protected void setUp() {
@@ -166,13 +157,13 @@ public final class TestIndexFunctionFromSpreadsheet extends TestCase {
 		// confirm results
 		String successMsg = "There were "
 				+ _evaluationSuccessCount + " function(s) without error";
- 		if(_evaluationFailureCount > 0) {
+		if(_evaluationFailureCount > 0) {
 			String msg = _evaluationFailureCount + " evaluation(s) failed.  " + successMsg;
 			throw new AssertionFailedError(msg);
 		}
- 		if(false) { // normally no output for successful tests
+		if(false) { // normally no output for successful tests
- 			System.out.println(getClass().getName() + ": " + successMsg);
+			System.out.println(getClass().getName() + ": " + successMsg);
- 		}
+		}
 	}
 
 	private void processTestSheet(HSSFWorkbook workbook, String sheetName) {

src/testcases/org/apache/poi/hssf/record/formula/functions/TestLookupFunctionsFromSpreadsheet.java

@@ -37,33 +37,33 @@ import org.apache.poi.hssf.util.CellReference;
  * Tests lookup functions (VLOOKUP, HLOOKUP, LOOKUP, MATCH) as loaded from a test data spreadsheet.<p/>
  * These tests have been separated from the common function and operator tests because the lookup
  * functions have more complex test cases and test data setup.
- * 
+ *
  * Tests for bug fixes and specific/tricky behaviour can be found in the corresponding test class
  * (<tt>TestXxxx</tt>) of the target (<tt>Xxxx</tt>) implementor, where execution can be observed
  *  more easily.
- * 
+ *
  * @author Josh Micich
  */
 public final class TestLookupFunctionsFromSpreadsheet extends TestCase {
-	
+
 	private static final class Result {
 		public static final int SOME_EVALUATIONS_FAILED = -1;
 		public static final int ALL_EVALUATIONS_SUCCEEDED = +1;
 		public static final int NO_EVALUATIONS_FOUND = 0;
 	}
 
-	/** 
+	/**
 	 * This class defines constants for navigating around the test data spreadsheet used for these tests.
 	 */
 	private static final class SS {
-		
+
 		/** Name of the test spreadsheet (found in the standard test data folder) */
 		public final static String FILENAME = "LookupFunctionsTestCaseData.xls";
-		
+
 		/** Name of the first sheet in the spreadsheet (contains comments) */
 		public final static String README_SHEET_NAME = "Read Me";
-		
+
-		
+
 		/** Row (zero-based) in each sheet where the evaluation cases start.   */
 		public static final int START_TEST_CASES_ROW_INDEX = 4; // Row '5'
 		/**  Index of the column that contains the function names */
@@ -71,15 +71,15 @@ public final class TestLookupFunctionsFromSpreadsheet extends TestCase {
 		public static final int COLUMN_INDEX_EVALUATION = 1; // Column 'B'
 		public static final int COLUMN_INDEX_EXPECTED_RESULT = 2; // Column 'C'
 		public static final int COLUMN_ROW_COMMENT = 3; // Column 'D'
-	
+
 		/** Used to indicate when there are no more test cases on the current sheet   */
 		public static final String TEST_CASES_END_MARKER = "<end>";
 		/** Used to indicate that the test on the current row should be ignored */
 		public static final String SKIP_CURRENT_TEST_CASE_MARKER = "<skip>";
-	
+
 	}
 
- 	// Note - multiple failures are aggregated before ending.  
+	// Note - multiple failures are aggregated before ending.
 	// If one or more functions fail, a single AssertionFailedError is thrown at the end
 	private int _sheetFailureCount;
 	private int _sheetSuccessCount;
@@ -105,19 +105,19 @@ public final class TestLookupFunctionsFromSpreadsheet extends TestCase {
 		if(actual.getCellType() != expected.getCellType()) {
 			throw wrongTypeError(msg, expected, actual);
 		}
-		
+
-		
+
 		switch (expected.getCellType()) {
 			case HSSFCell.CELL_TYPE_BOOLEAN:
 				assertEquals(msg, expected.getBooleanCellValue(), actual.getBooleanValue());
 				break;
 			case HSSFCell.CELL_TYPE_FORMULA: // will never be used, since we will call method after formula evaluation
-				throw new AssertionFailedError("Cannot expect formula as result of formula evaluation: " + msg);
+				throw new IllegalStateException("Cannot expect formula as result of formula evaluation: " + msg);
 			case HSSFCell.CELL_TYPE_NUMERIC:
 				assertEquals(expected.getNumericCellValue(), actual.getNumberValue(), 0.0);
 				break;
 			case HSSFCell.CELL_TYPE_STRING:
-				assertEquals(msg, expected.getRichStringCellValue().getString(), actual.getRichTextStringValue().getString());
+				assertEquals(msg, expected.getRichStringCellValue().getString(), actual.getStringValue());
 				break;
 		}
 	}
@@ -125,14 +125,14 @@ public final class TestLookupFunctionsFromSpreadsheet extends TestCase {
 
 	private static AssertionFailedError wrongTypeError(String msgPrefix, HSSFCell expectedCell, CellValue actualValue) {
 		return new AssertionFailedError(msgPrefix + " Result type mismatch. Evaluated result was "
-				+ formatValue(actualValue) 
+				+ actualValue.formatAsString()
 				+ " but the expected result was "
 				+ formatValue(expectedCell)
 				);
 	}
 	private static AssertionFailedError unexpectedError(String msgPrefix, HSSFCell expected, int actualErrorCode) {
 		return new AssertionFailedError(msgPrefix + " Error code ("
-				+ ErrorEval.getText(actualErrorCode) 
+				+ ErrorEval.getText(actualErrorCode)
 				+ ") was evaluated, but the expected result was "
 				+ formatValue(expected)
 				);
@@ -141,15 +141,15 @@ public final class TestLookupFunctionsFromSpreadsheet extends TestCase {
 
 	private static void confirmErrorResult(String msgPrefix, int expectedErrorCode, CellValue actual) {
 		if(actual.getCellType() != HSSFCell.CELL_TYPE_ERROR) {
-			throw new AssertionFailedError(msgPrefix + " Expected cell error (" 
+			throw new AssertionFailedError(msgPrefix + " Expected cell error ("
 					+ ErrorEval.getText(expectedErrorCode) + ") but actual value was "
-					+ formatValue(actual));
+					+ actual.formatAsString());
 		}
 		if(expectedErrorCode != actual.getErrorValue()) {
-			throw new AssertionFailedError(msgPrefix + " Expected cell error code (" 
+			throw new AssertionFailedError(msgPrefix + " Expected cell error code ("
-					+ ErrorEval.getText(expectedErrorCode) 
+					+ ErrorEval.getText(expectedErrorCode)
 					+ ") but actual error code was ("
-					+ ErrorEval.getText(actual.getErrorValue()) 
+					+ ErrorEval.getText(actual.getErrorValue())
 					+ ")");
 		}
 	}
@@ -164,49 +164,40 @@ public final class TestLookupFunctionsFromSpreadsheet extends TestCase {
 		}
 		throw new RuntimeException("Unexpected cell type of expected value (" + expecedCell.getCellType() + ")");
 	}
-	private static String formatValue(CellValue actual) {
-		switch (actual.getCellType()) {
-			case HSSFCell.CELL_TYPE_BLANK: return "<blank>";
-			case HSSFCell.CELL_TYPE_BOOLEAN: return String.valueOf(actual.getBooleanValue());
-			case HSSFCell.CELL_TYPE_NUMERIC: return String.valueOf(actual.getNumberValue());
-			case HSSFCell.CELL_TYPE_STRING: return actual.getRichTextStringValue().getString();
-		}
-		throw new RuntimeException("Unexpected cell type of evaluated value (" + actual.getCellType() + ")");
-	}
 
 
-	protected void setUp() throws Exception {
+	protected void setUp() {
 		_sheetFailureCount = 0;
 		_sheetSuccessCount = 0;
 		_evaluationFailureCount = 0;
 		_evaluationSuccessCount = 0;
 	}
-	
+
 	public void testFunctionsFromTestSpreadsheet() {
 		HSSFWorkbook workbook = HSSFTestDataSamples.openSampleWorkbook(SS.FILENAME);
-   	
+
 		confirmReadMeSheet(workbook);
 		int nSheets = workbook.getNumberOfSheets();
 		for(int i=1; i< nSheets; i++) {
 			int sheetResult = processTestSheet(workbook, i, workbook.getSheetName(i));
 			switch(sheetResult) {
-				case Result.ALL_EVALUATIONS_SUCCEEDED: _sheetSuccessCount ++; break; 
+				case Result.ALL_EVALUATIONS_SUCCEEDED: _sheetSuccessCount ++; break;
-				case Result.SOME_EVALUATIONS_FAILED: _sheetFailureCount ++; break; 
+				case Result.SOME_EVALUATIONS_FAILED: _sheetFailureCount ++; break;
 			}
 		}
-		
+
 		// confirm results
-		String successMsg = "There were " 
+		String successMsg = "There were "
 				+ _sheetSuccessCount + " successful sheets(s) and "
 				+ _evaluationSuccessCount + " function(s) without error";
- 		if(_sheetFailureCount > 0) {
+		if(_sheetFailureCount > 0) {
 			String msg = _sheetFailureCount + " sheets(s) failed with "
 			+ _evaluationFailureCount + " evaluation(s).  " + successMsg;
 			throw new AssertionFailedError(msg);
 		}
- 		if(false) { // normally no output for successful tests
+		if(false) { // normally no output for successful tests
- 			System.out.println(getClass().getName() + ": " + successMsg);
+			System.out.println(getClass().getName() + ": " + successMsg);
- 		}
+		}
 	}
 
 	private int processTestSheet(HSSFWorkbook workbook, int sheetIndex, String sheetName) {
@@ -214,7 +205,7 @@ public final class TestLookupFunctionsFromSpreadsheet extends TestCase {
 		HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(workbook);
 		int maxRows = sheet.getLastRowNum()+1;
 		int result = Result.NO_EVALUATIONS_FOUND; // so far
-		
+
 		String currentGroupComment = null;
 		for(int rowIndex=SS.START_TEST_CASES_ROW_INDEX; rowIndex<maxRows; rowIndex++) {
 			HSSFRow r = sheet.getRow(rowIndex);
@@ -240,7 +231,7 @@ public final class TestLookupFunctionsFromSpreadsheet extends TestCase {
 			CellValue actualValue = evaluator.evaluate(c);
 			HSSFCell expectedValueCell = r.getCell(SS.COLUMN_INDEX_EXPECTED_RESULT);
 			String rowComment = getRowCommentColumnValue(r);
-			
+
 			String msgPrefix = formatTestCaseDetails(sheetName, r.getRowNum(), c, currentGroupComment, rowComment);
 			try {
 				confirmExpectedResult(msgPrefix, expectedValueCell, actualValue);
@@ -257,22 +248,22 @@ public final class TestLookupFunctionsFromSpreadsheet extends TestCase {
 				printShortStackTrace(System.err, e);
 				result = Result.SOME_EVALUATIONS_FAILED;
 			}
-			
+
 		}
-		throw new RuntimeException("Missing end marker '" + SS.TEST_CASES_END_MARKER 
+		throw new RuntimeException("Missing end marker '" + SS.TEST_CASES_END_MARKER
 				+ "' on sheet '" + sheetName + "'");
-		
+
 	}
 
 
 	private static String formatTestCaseDetails(String sheetName, int rowNum, HSSFCell c, String currentGroupComment,
 			String rowComment) {
-		
+
 		StringBuffer sb = new StringBuffer();
 		CellReference cr = new CellReference(sheetName, rowNum, c.getCellNum(), false, false);
 		sb.append(cr.formatAsString());
 		sb.append(" {=").append(c.getCellFormula()).append("}");
-		
+
 		if(currentGroupComment != null) {
 			sb.append(" '");
 			sb.append(currentGroupComment);
@@ -288,13 +279,13 @@ public final class TestLookupFunctionsFromSpreadsheet extends TestCase {
 				sb.append("' ");
 			}
 		}
-		
+
 		return sb.toString();
 	}
 
 	/**
-	 * Asserts that the 'read me' comment page exists, and has this class' name in one of the 
+	 * Asserts that the 'read me' comment page exists, and has this class' name in one of the
-	 * cells.  This back-link is to make it easy to find this class if a reader encounters the 
+	 * cells.  This back-link is to make it easy to find this class if a reader encounters the
 	 * spreadsheet first.
 	 */
 	private void confirmReadMeSheet(HSSFWorkbook workbook) {
@@ -313,7 +304,7 @@ public final class TestLookupFunctionsFromSpreadsheet extends TestCase {
 	 */
 	private static void printShortStackTrace(PrintStream ps, Throwable e) {
 		StackTraceElement[] stes = e.getStackTrace();
-		
+
 		int startIx = 0;
 		// skip any top frames inside junit.framework.Assert
 		while(startIx<stes.length) {
@@ -339,17 +330,17 @@ public final class TestLookupFunctionsFromSpreadsheet extends TestCase {
 		for(int i=startIx; i<endIx; i++) {
 			ps.println("\tat " + stes[i].toString());
 		}
-		
+
 	}
 
 	private static String getRowCommentColumnValue(HSSFRow r) {
 		return getCellTextValue(r, SS.COLUMN_ROW_COMMENT, "row comment");
 	}
-	
+
 	private static String getMarkerColumnValue(HSSFRow r) {
 		return getCellTextValue(r, SS.COLUMN_INDEX_MARKER, "marker");
 	}
-	
+
 	/**
 	 * @return <code>null</code> if cell is missing, empty or blank
 	 */
@@ -367,7 +358,7 @@ public final class TestLookupFunctionsFromSpreadsheet extends TestCase {
 		if(cell.getCellType() == HSSFCell.CELL_TYPE_STRING) {
 			return cell.getRichStringCellValue().getString();
 		}
-		
+
 		throw new RuntimeException("Bad cell type for '" + columnName + "' column: ("
 				+ cell.getCellType() + ") row (" + (r.getRowNum() +1) + ")");
 	}