mirrors
/
poi
mirror of https://github.com/apache/poi.git
Watch 1
Star 0
Fork 0
Code Issues 0 Releases 100 Wiki Activity
Browse Source

Bug 56315: Make rounding in MathX.round() behave equal to Excel, adjust/enhance some more tests in MathX 

git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@1588538 13f79535-47bb-0310-9956-ffa450edef68
tags/REL_3_11_BETA1
Dominik Stadler 10 years ago
parent
eaa29ed9d1
commit
d9bf061db7
4 changed files with 108 additions and 17 deletions
Split View Show Diff Stats
  1. 2
    1
      src/java/org/apache/poi/ss/formula/functions/MathX.java
  2. 9
    0
      src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFBugs.java
  3. 97
    16
      src/testcases/org/apache/poi/ss/formula/functions/TestMathX.java
  4. BIN
      test-data/spreadsheet/56315.xlsx

+ 2
- 1
src/java/org/apache/poi/ss/formula/functions/MathX.java View File

@@ -17,6 +17,7 @@

package org.apache.poi.ss.formula.functions;

import org.apache.poi.ss.util.NumberToTextConverter;

/**
* @author Amol S. Deshmukh < amolweb at ya hoo dot com >
@@ -53,7 +54,7 @@ final class MathX {
retval = Double.NaN;
}
else {
retval = java.math.BigDecimal.valueOf(n).setScale(p, java.math.RoundingMode.HALF_UP).doubleValue();
retval = new java.math.BigDecimal(NumberToTextConverter.toText(n)).setScale(p, java.math.RoundingMode.HALF_UP).doubleValue();
}

return retval;

+ 9
- 0
src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFBugs.java View File

@@ -1455,4 +1455,13 @@ public final class TestXSSFBugs extends BaseTestBugzillaIssues {
Workbook nwb = XSSFTestDataSamples.writeOutAndReadBack(wb);
assertEquals(0, nwb.getSheetIndex("Market Rates"));
}

@Test
public void bug56315() {
XSSFWorkbook wb = XSSFTestDataSamples.openSampleWorkbook("56315.xlsx");
Cell c = wb.getSheetAt(0).getRow(1).getCell(0);
CellValue cv = wb.getCreationHelper().createFormulaEvaluator().evaluate(c);
double rounded = cv.getNumberValue();
assertEquals(0.1, rounded, 0.0);
}
}

+ 97
- 16
src/testcases/org/apache/poi/ss/formula/functions/TestMathX.java View File

@@ -20,6 +20,8 @@
*/
package org.apache.poi.ss.formula.functions;

import java.lang.reflect.Constructor;

import org.apache.poi.ss.formula.functions.XYNumericFunction.Accumulator;


@@ -249,6 +251,16 @@ public class TestMathX extends AbstractNumericTestCase {
}

public void testProduct() {
assertEquals("Product ", 0, MathX.product(null));
assertEquals("Product ", 0, MathX.product(new double[] {}));
assertEquals("Product ", 0, MathX.product(new double[] {1, 0}));

assertEquals("Product ", 1, MathX.product(new double[] { 1 }));
assertEquals("Product ", 1, MathX.product(new double[] { 1, 1 }));
assertEquals("Product ", 10, MathX.product(new double[] { 10, 1 }));
assertEquals("Product ", -2, MathX.product(new double[] { 2, -1 }));
assertEquals("Product ", 99988000209999d, MathX.product(new double[] { 99999, 99999, 9999 }));
double[] d = new double[100];
d[0] = 1.1; d[1] = 2.1; d[2] = 3.1; d[3] = 4.1;
d[4] = 5.1; d[5] = 6.1; d[6] = 7.1; d[7] = 8.1;
@@ -256,8 +268,8 @@ public class TestMathX extends AbstractNumericTestCase {
d[12] = 13.1; d[13] = 14.1; d[14] = 15.1; d[15] = 16.1;
d[16] = 17.1; d[17] = 18.1; d[18] = 19.1; d[19] = 20.1;
double m = MathX.min(d);
assertEquals("Min ", 0, m);
double m = MathX.product(d);
assertEquals("Product ", 0, m);
d = new double[20];
d[0] = 1.1; d[1] = 2.1; d[2] = 3.1; d[3] = 4.1;
@@ -266,20 +278,12 @@ public class TestMathX extends AbstractNumericTestCase {
d[12] = 13.1; d[13] = 14.1; d[14] = 15.1; d[15] = 16.1;
d[16] = 17.1; d[17] = 18.1; d[18] = 19.1; d[19] = 20.1;
m = MathX.min(d);
assertEquals("Min ", 1.1, m);
m = MathX.product(d);
assertEquals("Product ", 3459946360003355534d, m);
d = new double[1000];
m = MathX.min(d);
assertEquals("Min ", 0, m);
d[0] = -1.1; d[1] = 2.1; d[2] = -3.1; d[3] = 4.1;
d[4] = -5.1; d[5] = 6.1; d[6] = -7.1; d[7] = 8.1;
d[8] = -9.1; d[9] = 10.1; d[10] = -11.1; d[11] = 12.1;
d[12] = -13.1; d[13] = 14.1; d[14] = -15.1; d[15] = 16.1;
d[16] = -17.1; d[17] = 18.1; d[18] = -19.1; d[19] = 20.1;
m = MathX.min(d);
assertEquals("Min ", -19.1, m);
m = MathX.product(d);
assertEquals("Product ", 0, m);
d = new double[20];
d[0] = -1.1; d[1] = -2.1; d[2] = -3.1; d[3] = -4.1;
@@ -287,8 +291,8 @@ public class TestMathX extends AbstractNumericTestCase {
d[8] = -9.1; d[9] = -10.1; d[10] = -11.1; d[11] = -12.1;
d[12] = -13.1; d[13] = -14.1; d[14] = -15.1; d[15] = -16.1;
d[16] = -17.1; d[17] = -18.1; d[18] = -19.1; d[19] = -20.1;
m = MathX.min(d);
assertEquals("Min ", -20.1, m);
m = MathX.product(d);
assertEquals("Product ", 3459946360003355534d, m);
}

public void testMod() {
@@ -299,10 +303,14 @@ public class TestMathX extends AbstractNumericTestCase {
assertEquals(-1.0, MathX.mod(3, -2));
assertEquals(-1.0, MathX.mod(-3, -2));

assertEquals(0.0, MathX.mod(0, 2));
assertEquals(Double.NaN, MathX.mod(3, 0));
assertEquals((double) 1.4, MathX.mod(3.4, 2));
assertEquals((double) -1.4, MathX.mod(-3.4, -2));
assertEquals((double) 0.6000000000000001, MathX.mod(-3.4, 2.0));// should actually be 0.6
assertEquals((double) -0.6000000000000001, MathX.mod(3.4, -2.0));// should actually be -0.6
assertEquals(3.0, MathX.mod(3, Double.MAX_VALUE));
assertEquals(2.0, MathX.mod(Double.MAX_VALUE, 3));

// Bugzilla 50033
assertEquals(1.0, MathX.mod(13, 12));
@@ -675,6 +683,27 @@ public class TestMathX extends AbstractNumericTestCase {

d = 2162.615d; p = 2;
assertEquals("round ", 2162.62d, MathX.round(d, p));
d = 0.049999999999999975d; p = 2;
assertEquals("round ", 0.05d, MathX.round(d, p));

d = 0.049999999999999975d; p = 1;
assertEquals("round ", 0.1d, MathX.round(d, p));
d = Double.NaN; p = 1;
assertEquals("round ", Double.NaN, MathX.round(d, p));

d = Double.POSITIVE_INFINITY; p = 1;
assertEquals("round ", Double.NaN, MathX.round(d, p));

d = Double.NEGATIVE_INFINITY; p = 1;
assertEquals("round ", Double.NaN, MathX.round(d, p));

d = Double.MAX_VALUE; p = 1;
assertEquals("round ", Double.MAX_VALUE, MathX.round(d, p));

d = Double.MIN_VALUE; p = 1;
assertEquals("round ", 0.0d, MathX.round(d, p));
}

public void testRoundDown() {
@@ -722,6 +751,27 @@ public class TestMathX extends AbstractNumericTestCase {
d = 150.0; p = -2;
assertEquals("roundDown ", 100, MathX.roundDown(d, p));
d = 0.049999999999999975d; p = 2;
assertEquals("round ", 0.04d, MathX.roundDown(d, p));

d = 0.049999999999999975d; p = 1;
assertEquals("round ", 0.0d, MathX.roundDown(d, p));
d = Double.NaN; p = 1;
assertEquals("round ", Double.NaN, MathX.roundDown(d, p));

d = Double.POSITIVE_INFINITY; p = 1;
assertEquals("round ", Double.NaN, MathX.roundDown(d, p));

d = Double.NEGATIVE_INFINITY; p = 1;
assertEquals("round ", Double.NaN, MathX.roundDown(d, p));

d = Double.MAX_VALUE; p = 1;
assertEquals("round ", Double.MAX_VALUE, MathX.roundDown(d, p));

d = Double.MIN_VALUE; p = 1;
assertEquals("round ", 0.0d, MathX.roundDown(d, p));
}

public void testRoundUp() {
@@ -769,6 +819,27 @@ public class TestMathX extends AbstractNumericTestCase {
d = 150.0; p = -2;
assertEquals("roundUp ", 200, MathX.roundUp(d, p));
d = 0.049999999999999975d; p = 2;
assertEquals("round ", 0.05d, MathX.roundUp(d, p));

d = 0.049999999999999975d; p = 1;
assertEquals("round ", 0.1d, MathX.roundUp(d, p));
d = Double.NaN; p = 1;
assertEquals("round ", Double.NaN, MathX.roundUp(d, p));

d = Double.POSITIVE_INFINITY; p = 1;
assertEquals("round ", Double.NaN, MathX.roundUp(d, p));

d = Double.NEGATIVE_INFINITY; p = 1;
assertEquals("round ", Double.NaN, MathX.roundUp(d, p));

d = Double.MAX_VALUE; p = 1;
assertEquals("round ", Double.MAX_VALUE, MathX.roundUp(d, p));

d = Double.MIN_VALUE; p = 1;
assertEquals("round ", 0.1d, MathX.roundUp(d, p));
}

public void testCeiling() {
@@ -877,4 +948,14 @@ public class TestMathX extends AbstractNumericTestCase {
assertEquals("floor ", 0, MathX.floor(d, s));
}

public void testCoverage() throws Exception {
// get the default constructor
final Constructor<MathX> c = MathX.class.getDeclaredConstructor(new Class[] {});

// make it callable from the outside
c.setAccessible(true);

// call it
c.newInstance((Object[]) null);
}
}

BIN
test-data/spreadsheet/56315.xlsx View File


Write Preview
Loading…
Cancel
Save