Attachment #33263 for bug #58591

View | Details | Raw Unified | Return to bug 58591
Collapse All | Expand All




package org.apache.poi.ss.formula;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.fail;

import java.io.IOException;

import org.junit.Ignore;
import org.junit.Test;

import org.apache.poi.hssf.HSSFTestDataSamples;

        
        wb.close();
    }
    
// Test IF-Equals Formula Evaluation (bug 58591)
    
    private Workbook testIFEqualsFormulaEvaluation_setup(String formula, int a1CellType) {
        Workbook wb = new HSSFWorkbook();
        Sheet sheet = wb.createSheet("IFEquals");
        Row row = sheet.createRow(0);
        Cell A1 = row.createCell(0);
        Cell B1 = row.createCell(1);
        Cell C1 = row.createCell(2);
        Cell D1 = row.createCell(3);
        
        switch (a1CellType) {
            case Cell.CELL_TYPE_NUMERIC:
                A1.setCellValue(1.0);
                // "A1=1" should return true
                break;
            case Cell.CELL_TYPE_STRING:
                A1.setCellValue("1");
                // "A1=1" should return false
                // "A1=\"1\"" should return true
                break;
            case Cell.CELL_TYPE_BOOLEAN:
                A1.setCellValue(true);
                // "A1=1" should return true
                break;
            case Cell.CELL_TYPE_FORMULA:
                A1.setCellFormula("1");
                // "A1=1" should return true
                break;
            case Cell.CELL_TYPE_BLANK:
                A1.setCellValue((String) null);
                // "A1=1" should return false
                break;
        }
        B1.setCellValue(2.0);
        C1.setCellValue(3.0);
        D1.setCellFormula(formula);
        
        return wb;
    }
    
    private void testIFEqualsFormulaEvaluation_teardown(Workbook wb) {
        try {
            wb.close();
        } catch (final IOException e) {
            fail("Unable to close workbook");
        }
    }
    
    
    
    private void testIFEqualsFormulaEvaluation_evaluate(
        String formula, int cellType, String expectedFormula, double expectedResult) {
        Workbook wb = testIFEqualsFormulaEvaluation_setup(formula, cellType);
        Cell D1 = wb.getSheet("IFEquals").getRow(0).getCell(3);
        
        FormulaEvaluator eval = wb.getCreationHelper().createFormulaEvaluator();
        CellValue result = eval.evaluate(D1);
        
        // Call should not modify the contents
        assertEquals(Cell.CELL_TYPE_FORMULA, D1.getCellType());
        assertEquals(expectedFormula, D1.getCellFormula());
        
        assertEquals(Cell.CELL_TYPE_NUMERIC, result.getCellType());
        assertEquals(expectedResult, result.getNumberValue(), EPSILON);
        
        testIFEqualsFormulaEvaluation_teardown(wb);
    }
    
    private void testIFEqualsFormulaEvaluation_eval(
            final String formula, final int cellType, final String expectedFormula, final double expectedValue) {
        testIFEqualsFormulaEvaluation_evaluate(formula, cellType, expectedFormula, expectedValue);
        testIFEqualsFormulaEvaluation_evaluateFormulaCell(formula, cellType, expectedFormula, expectedValue);
        testIFEqualsFormulaEvaluation_evaluateInCell(formula, cellType, expectedFormula, expectedValue);
        testIFEqualsFormulaEvaluation_evaluateAll(formula, cellType, expectedFormula, expectedValue);
        testIFEqualsFormulaEvaluation_evaluateAllFormulaCells(formula, cellType, expectedFormula, expectedValue);
    }
    
    @Test
    public void testIFEqualsFormulaEvaluation_NumericLiteral() {
        final String formula = "IF(A1=1, 2, 3)";
        final int cellType = Cell.CELL_TYPE_NUMERIC;
        final String expectedFormula = "IF(A1=1,2,3)";
        final double expectedValue = 2.0;
        testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
    }
    
    @Test
    public void testIFEqualsFormulaEvaluation_Numeric() {
        final String formula = "IF(A1=1, B1, C1)";
        final int cellType = Cell.CELL_TYPE_NUMERIC;
        final String expectedFormula = "IF(A1=1,B1,C1)";
        final double expectedValue = 2.0;
        testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
    }
    
    @Test
    public void testIFEqualsFormulaEvaluation_NumericCoerceToString() {
        final String formula = "IF(A1&\"\"=\"1\", B1, C1)";
        final int cellType = Cell.CELL_TYPE_NUMERIC;
        final String expectedFormula = "IF(A1&\"\"=\"1\",B1,C1)";
        final double expectedValue = 2.0;
        testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
    }
    
    @Test
    public void testIFEqualsFormulaEvaluation_String() {
        final String formula = "IF(A1=1, B1, C1)";
        final int cellType = Cell.CELL_TYPE_STRING;
        final String expectedFormula = "IF(A1=1,B1,C1)";
        final double expectedValue = 3.0;
        testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
    }
    
    @Test
    public void testIFEqualsFormulaEvaluation_StringCompareToString() {
        final String formula = "IF(A1=\"1\", B1, C1)";
        final int cellType = Cell.CELL_TYPE_STRING;
        final String expectedFormula = "IF(A1=\"1\",B1,C1)";
        final double expectedValue = 2.0;
        testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
    }
    
    @Test
    public void testIFEqualsFormulaEvaluation_StringCoerceToNumeric() {
        final String formula = "IF(A1+0=1, B1, C1)";
        final int cellType = Cell.CELL_TYPE_STRING;
        final String expectedFormula = "IF(A1+0=1,B1,C1)";
        final double expectedValue = 2.0;
        testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
    }
    
    @Ignore("Bug 58591: this test currently fails")
    @Test
    public void testIFEqualsFormulaEvaluation_Boolean() {
        final String formula = "IF(A1=1, B1, C1)";
        final int cellType = Cell.CELL_TYPE_BOOLEAN;
        final String expectedFormula = "IF(A1=1,B1,C1)";
        final double expectedValue = 2.0;
        testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
    }
    
    @Test
    public void testIFEqualsFormulaEvaluation_BooleanSimple() {
        final String formula = "3-(A1=1)";
        final int cellType = Cell.CELL_TYPE_BOOLEAN;
        final String expectedFormula = "3-(A1=1)";
        final double expectedValue = 2.0;
        testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
    }
    
    @Test
    public void testIFEqualsFormulaEvaluation_Formula() {
        final String formula = "IF(A1=1, B1, C1)";
        final int cellType = Cell.CELL_TYPE_FORMULA;
        final String expectedFormula = "IF(A1=1,B1,C1)";
        final double expectedValue = 2.0;
        testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
    }
    
    @Test
    public void testIFEqualsFormulaEvaluation_Blank() {
        final String formula = "IF(A1=1, B1, C1)";
        final int cellType = Cell.CELL_TYPE_BLANK;
        final String expectedFormula = "IF(A1=1,B1,C1)";
        final double expectedValue = 3.0;
        testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
    }
    
    @Test
    public void testIFEqualsFormulaEvaluation_BlankCompareToZero() {
        final String formula = "IF(A1=0, B1, C1)";
        final int cellType = Cell.CELL_TYPE_BLANK;
        final String expectedFormula = "IF(A1=0,B1,C1)";
        final double expectedValue = 2.0;
        testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
    }
    
    @Ignore("Bug 58591: this test currently fails")
    @Test
    public void testIFEqualsFormulaEvaluation_BlankInverted() {
        final String formula = "IF(NOT(A1)=1, B1, C1)";
        final int cellType = Cell.CELL_TYPE_BLANK;
        final String expectedFormula = "IF(NOT(A1)=1,B1,C1)";
        final double expectedValue = 2.0;
        testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
    }
    
    @Test
    public void testIFEqualsFormulaEvaluation_BlankInvertedSimple() {
        final String formula = "3-(NOT(A1)=1)";
        final int cellType = Cell.CELL_TYPE_BLANK;
        final String expectedFormula = "3-(NOT(A1)=1)";
        final double expectedValue = 2.0;
        testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
    }
    
    
    private void testIFEqualsFormulaEvaluation_evaluateFormulaCell(
            String formula, int cellType, String expectedFormula, double expectedResult) {
        Workbook wb = testIFEqualsFormulaEvaluation_setup(formula, cellType);
        Cell D1 = wb.getSheet("IFEquals").getRow(0).getCell(3);
        
        FormulaEvaluator eval = wb.getCreationHelper().createFormulaEvaluator();
        int resultCellType = eval.evaluateFormulaCell(D1);
        
        // Call should modify the contents, but leave the formula intact
        assertEquals(Cell.CELL_TYPE_FORMULA, D1.getCellType());
        assertEquals(expectedFormula, D1.getCellFormula());
        assertEquals(Cell.CELL_TYPE_NUMERIC, resultCellType);
        assertEquals(Cell.CELL_TYPE_NUMERIC, D1.getCachedFormulaResultType());
        assertEquals(expectedResult, D1.getNumericCellValue(), EPSILON);
        
        testIFEqualsFormulaEvaluation_teardown(wb);
    }
    
    private void testIFEqualsFormulaEvaluation_evaluateInCell(
            String formula, int cellType, String expectedFormula, double expectedResult) {
        Workbook wb = testIFEqualsFormulaEvaluation_setup(formula, cellType);
        Cell D1 = wb.getSheet("IFEquals").getRow(0).getCell(3);
        
        FormulaEvaluator eval = wb.getCreationHelper().createFormulaEvaluator();
        Cell result = eval.evaluateInCell(D1);
        
        // Call should modify the contents and replace the formula with the result
        assertSame(D1, result); // returns the same cell that was provided as an argument so that calls can be chained.
        try {
            D1.getCellFormula();
            fail("cell formula should be overwritten with formula result");
        } catch (final IllegalStateException expected) { }
        assertEquals(Cell.CELL_TYPE_NUMERIC, D1.getCellType());
        assertEquals(expectedResult, D1.getNumericCellValue(), EPSILON);
        
        testIFEqualsFormulaEvaluation_teardown(wb);
    }
    
    private void testIFEqualsFormulaEvaluation_evaluateAll(
            String formula, int cellType, String expectedFormula, double expectedResult) {
        Workbook wb = testIFEqualsFormulaEvaluation_setup(formula, cellType);
        Cell D1 = wb.getSheet("IFEquals").getRow(0).getCell(3);
        
        FormulaEvaluator eval = wb.getCreationHelper().createFormulaEvaluator();
        eval.evaluateAll();
        
        // Call should modify the contents
        assertEquals(Cell.CELL_TYPE_FORMULA, D1.getCellType());
        assertEquals(expectedFormula, D1.getCellFormula());
        
        assertEquals(Cell.CELL_TYPE_NUMERIC, D1.getCachedFormulaResultType());
        assertEquals(expectedResult, D1.getNumericCellValue(), EPSILON);
        
        testIFEqualsFormulaEvaluation_teardown(wb);
    }
    
    private void testIFEqualsFormulaEvaluation_evaluateAllFormulaCells(
            String formula, int cellType, String expectedFormula, double expectedResult) {
        Workbook wb = testIFEqualsFormulaEvaluation_setup(formula, cellType);
        Cell D1 = wb.getSheet("IFEquals").getRow(0).getCell(3);
        
        HSSFFormulaEvaluator.evaluateAllFormulaCells(wb);
        
        // Call should modify the contents
        assertEquals(Cell.CELL_TYPE_FORMULA, D1.getCellType());
        // whitespace gets deleted because formula is parsed and re-rendered
        assertEquals(expectedFormula, D1.getCellFormula());
        
        assertEquals(Cell.CELL_TYPE_NUMERIC, D1.getCachedFormulaResultType());
        assertEquals(expectedResult, D1.getNumericCellValue(), EPSILON);
        
        testIFEqualsFormulaEvaluation_teardown(wb);
    }
}

Return to bug 58591

Lines 18-27 Link Here

(-)src/testcases/org/apache/poi/ss/formula/TestWorkbookEvaluator.java (+274 lines)
18	package org.apache.poi.ss.formula;	18	package org.apache.poi.ss.formula;
19		19
20	import static org.junit.Assert.assertEquals;	20	import static org.junit.Assert.assertEquals;
		21	import static org.junit.Assert.assertSame;
21	import static org.junit.Assert.fail;	22	import static org.junit.Assert.fail;
22		23
23	import java.io.IOException;	24	import java.io.IOException;
24		25
		26	import org.junit.Ignore;
25	import org.junit.Test;	27	import org.junit.Test;
26		28
27	import org.apache.poi.hssf.HSSFTestDataSamples;	29	import org.apache.poi.hssf.HSSFTestDataSamples;
Lines 300-303 Link Here
300		302
301	wb.close();	303	wb.close();
302	}	304	}
		305
		306	// Test IF-Equals Formula Evaluation (bug 58591)
		307
		308	private Workbook testIFEqualsFormulaEvaluation_setup(String formula, int a1CellType) {
		309	Workbook wb = new HSSFWorkbook();
		310	Sheet sheet = wb.createSheet("IFEquals");
		311	Row row = sheet.createRow(0);
		312	Cell A1 = row.createCell(0);
		313	Cell B1 = row.createCell(1);
		314	Cell C1 = row.createCell(2);
		315	Cell D1 = row.createCell(3);
		316
		317	switch (a1CellType) {
		318	case Cell.CELL_TYPE_NUMERIC:
		319	A1.setCellValue(1.0);
		320	// "A1=1" should return true
		321	break;
		322	case Cell.CELL_TYPE_STRING:
		323	A1.setCellValue("1");
		324	// "A1=1" should return false
		325	// "A1=\"1\"" should return true
		326	break;
		327	case Cell.CELL_TYPE_BOOLEAN:
		328	A1.setCellValue(true);
		329	// "A1=1" should return true
		330	break;
		331	case Cell.CELL_TYPE_FORMULA:
		332	A1.setCellFormula("1");
		333	// "A1=1" should return true
		334	break;
		335	case Cell.CELL_TYPE_BLANK:
		336	A1.setCellValue((String) null);
		337	// "A1=1" should return false
		338	break;
		339	}
		340	B1.setCellValue(2.0);
		341	C1.setCellValue(3.0);
		342	D1.setCellFormula(formula);
		343
		344	return wb;
		345	}
		346
		347	private void testIFEqualsFormulaEvaluation_teardown(Workbook wb) {
		348	try {
		349	wb.close();
		350	} catch (final IOException e) {
		351	fail("Unable to close workbook");
		352	}
		353	}
		354
		355
		356
		357	private void testIFEqualsFormulaEvaluation_evaluate(
		358	String formula, int cellType, String expectedFormula, double expectedResult) {
		359	Workbook wb = testIFEqualsFormulaEvaluation_setup(formula, cellType);
		360	Cell D1 = wb.getSheet("IFEquals").getRow(0).getCell(3);
		361
		362	FormulaEvaluator eval = wb.getCreationHelper().createFormulaEvaluator();
		363	CellValue result = eval.evaluate(D1);
		364
		365	// Call should not modify the contents
		366	assertEquals(Cell.CELL_TYPE_FORMULA, D1.getCellType());
		367	assertEquals(expectedFormula, D1.getCellFormula());
		368
369	assertEquals(Cell.CELL_TYPE_NUMERIC, result.getCellType());
370	assertEquals(expectedResult, result.getNumberValue(), EPSILON);
371
372	testIFEqualsFormulaEvaluation_teardown(wb);
373	}
374
375	private void testIFEqualsFormulaEvaluation_eval(
376	final String formula, final int cellType, final String expectedFormula, final double expectedValue) {
377	testIFEqualsFormulaEvaluation_evaluate(formula, cellType, expectedFormula, expectedValue);
378	testIFEqualsFormulaEvaluation_evaluateFormulaCell(formula, cellType, expectedFormula, expectedValue);
379	testIFEqualsFormulaEvaluation_evaluateInCell(formula, cellType, expectedFormula, expectedValue);
380	testIFEqualsFormulaEvaluation_evaluateAll(formula, cellType, expectedFormula, expectedValue);
381	testIFEqualsFormulaEvaluation_evaluateAllFormulaCells(formula, cellType, expectedFormula, expectedValue);
382	}
383
384	@Test
385	public void testIFEqualsFormulaEvaluation_NumericLiteral() {
386	final String formula = "IF(A1=1, 2, 3)";
387	final int cellType = Cell.CELL_TYPE_NUMERIC;
388	final String expectedFormula = "IF(A1=1,2,3)";
389	final double expectedValue = 2.0;
390	testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
391	}
392
393	@Test
394	public void testIFEqualsFormulaEvaluation_Numeric() {
395	final String formula = "IF(A1=1, B1, C1)";
396	final int cellType = Cell.CELL_TYPE_NUMERIC;
397	final String expectedFormula = "IF(A1=1,B1,C1)";
398	final double expectedValue = 2.0;
399	testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
400	}
401
402	@Test
403	public void testIFEqualsFormulaEvaluation_NumericCoerceToString() {
404	final String formula = "IF(A1&\"\"=\"1\", B1, C1)";
405	final int cellType = Cell.CELL_TYPE_NUMERIC;
406	final String expectedFormula = "IF(A1&\"\"=\"1\",B1,C1)";
407	final double expectedValue = 2.0;
408	testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
409	}
410
411	@Test
412	public void testIFEqualsFormulaEvaluation_String() {
413	final String formula = "IF(A1=1, B1, C1)";
414	final int cellType = Cell.CELL_TYPE_STRING;
415	final String expectedFormula = "IF(A1=1,B1,C1)";
416	final double expectedValue = 3.0;
417	testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
418	}
419
420	@Test
421	public void testIFEqualsFormulaEvaluation_StringCompareToString() {
422	final String formula = "IF(A1=\"1\", B1, C1)";
423	final int cellType = Cell.CELL_TYPE_STRING;
424	final String expectedFormula = "IF(A1=\"1\",B1,C1)";
425	final double expectedValue = 2.0;
426	testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
427	}
428
429	@Test
430	public void testIFEqualsFormulaEvaluation_StringCoerceToNumeric() {
431	final String formula = "IF(A1+0=1, B1, C1)";
432	final int cellType = Cell.CELL_TYPE_STRING;
433	final String expectedFormula = "IF(A1+0=1,B1,C1)";
434	final double expectedValue = 2.0;
435	testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
436	}
437
438	@Ignore("Bug 58591: this test currently fails")
439	@Test
440	public void testIFEqualsFormulaEvaluation_Boolean() {
441	final String formula = "IF(A1=1, B1, C1)";
442	final int cellType = Cell.CELL_TYPE_BOOLEAN;
443	final String expectedFormula = "IF(A1=1,B1,C1)";
444	final double expectedValue = 2.0;
445	testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
446	}
447
448	@Test
449	public void testIFEqualsFormulaEvaluation_BooleanSimple() {
450	final String formula = "3-(A1=1)";
451	final int cellType = Cell.CELL_TYPE_BOOLEAN;
452	final String expectedFormula = "3-(A1=1)";
453	final double expectedValue = 2.0;
454	testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
455	}
456
457	@Test
458	public void testIFEqualsFormulaEvaluation_Formula() {
459	final String formula = "IF(A1=1, B1, C1)";
460	final int cellType = Cell.CELL_TYPE_FORMULA;
461	final String expectedFormula = "IF(A1=1,B1,C1)";
462	final double expectedValue = 2.0;
463	testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
464	}
465
466	@Test
467	public void testIFEqualsFormulaEvaluation_Blank() {
468	final String formula = "IF(A1=1, B1, C1)";
469	final int cellType = Cell.CELL_TYPE_BLANK;
470	final String expectedFormula = "IF(A1=1,B1,C1)";
471	final double expectedValue = 3.0;
472	testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
473	}
474
475	@Test
476	public void testIFEqualsFormulaEvaluation_BlankCompareToZero() {
477	final String formula = "IF(A1=0, B1, C1)";
478	final int cellType = Cell.CELL_TYPE_BLANK;
479	final String expectedFormula = "IF(A1=0,B1,C1)";
480	final double expectedValue = 2.0;
481	testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
482	}
483
484	@Ignore("Bug 58591: this test currently fails")
485	@Test
486	public void testIFEqualsFormulaEvaluation_BlankInverted() {
487	final String formula = "IF(NOT(A1)=1, B1, C1)";
488	final int cellType = Cell.CELL_TYPE_BLANK;
489	final String expectedFormula = "IF(NOT(A1)=1,B1,C1)";
490	final double expectedValue = 2.0;
491	testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
492	}
493
494	@Test
495	public void testIFEqualsFormulaEvaluation_BlankInvertedSimple() {
496	final String formula = "3-(NOT(A1)=1)";
497	final int cellType = Cell.CELL_TYPE_BLANK;
498	final String expectedFormula = "3-(NOT(A1)=1)";
499	final double expectedValue = 2.0;
500	testIFEqualsFormulaEvaluation_eval(formula, cellType, expectedFormula, expectedValue);
501	}
502
503
504	private void testIFEqualsFormulaEvaluation_evaluateFormulaCell(
505	String formula, int cellType, String expectedFormula, double expectedResult) {
506	Workbook wb = testIFEqualsFormulaEvaluation_setup(formula, cellType);
507	Cell D1 = wb.getSheet("IFEquals").getRow(0).getCell(3);
508
509	FormulaEvaluator eval = wb.getCreationHelper().createFormulaEvaluator();
510	int resultCellType = eval.evaluateFormulaCell(D1);
511
512	// Call should modify the contents, but leave the formula intact
513	assertEquals(Cell.CELL_TYPE_FORMULA, D1.getCellType());
514	assertEquals(expectedFormula, D1.getCellFormula());
515	assertEquals(Cell.CELL_TYPE_NUMERIC, resultCellType);
516	assertEquals(Cell.CELL_TYPE_NUMERIC, D1.getCachedFormulaResultType());
517	assertEquals(expectedResult, D1.getNumericCellValue(), EPSILON);
518
519	testIFEqualsFormulaEvaluation_teardown(wb);
520	}
521
522	private void testIFEqualsFormulaEvaluation_evaluateInCell(
523	String formula, int cellType, String expectedFormula, double expectedResult) {
524	Workbook wb = testIFEqualsFormulaEvaluation_setup(formula, cellType);
525	Cell D1 = wb.getSheet("IFEquals").getRow(0).getCell(3);
526
527	FormulaEvaluator eval = wb.getCreationHelper().createFormulaEvaluator();
528	Cell result = eval.evaluateInCell(D1);
529
530	// Call should modify the contents and replace the formula with the result
531	assertSame(D1, result); // returns the same cell that was provided as an argument so that calls can be chained.
532	try {
533	D1.getCellFormula();
534	fail("cell formula should be overwritten with formula result");
535	} catch (final IllegalStateException expected) { }
536	assertEquals(Cell.CELL_TYPE_NUMERIC, D1.getCellType());
537	assertEquals(expectedResult, D1.getNumericCellValue(), EPSILON);
538
539	testIFEqualsFormulaEvaluation_teardown(wb);
540	}
541
542	private void testIFEqualsFormulaEvaluation_evaluateAll(
543	String formula, int cellType, String expectedFormula, double expectedResult) {
544	Workbook wb = testIFEqualsFormulaEvaluation_setup(formula, cellType);
545	Cell D1 = wb.getSheet("IFEquals").getRow(0).getCell(3);
546
547	FormulaEvaluator eval = wb.getCreationHelper().createFormulaEvaluator();
548	eval.evaluateAll();
549
550	// Call should modify the contents
551	assertEquals(Cell.CELL_TYPE_FORMULA, D1.getCellType());
552	assertEquals(expectedFormula, D1.getCellFormula());
553
554	assertEquals(Cell.CELL_TYPE_NUMERIC, D1.getCachedFormulaResultType());
555	assertEquals(expectedResult, D1.getNumericCellValue(), EPSILON);
556
557	testIFEqualsFormulaEvaluation_teardown(wb);
558	}
559
560	private void testIFEqualsFormulaEvaluation_evaluateAllFormulaCells(
561	String formula, int cellType, String expectedFormula, double expectedResult) {
562	Workbook wb = testIFEqualsFormulaEvaluation_setup(formula, cellType);
563	Cell D1 = wb.getSheet("IFEquals").getRow(0).getCell(3);
564
565	HSSFFormulaEvaluator.evaluateAllFormulaCells(wb);
566
567	// Call should modify the contents
568	assertEquals(Cell.CELL_TYPE_FORMULA, D1.getCellType());
569	// whitespace gets deleted because formula is parsed and re-rendered
570	assertEquals(expectedFormula, D1.getCellFormula());
571
572	assertEquals(Cell.CELL_TYPE_NUMERIC, D1.getCachedFormulaResultType());
573	assertEquals(expectedResult, D1.getNumericCellValue(), EPSILON);
574
575	testIFEqualsFormulaEvaluation_teardown(wb);
576	}
303	}	577	}