public void TestEscapes() { DataFormatter dfUS = new DataFormatter(CultureShim.GetCultureInfo("en-US")); Assert.AreEqual("1901-01-01", dfUS.FormatRawCellContents(367.0, -1, "yyyy-mm-dd")); Assert.AreEqual("1901-01-01", dfUS.FormatRawCellContents(367.0, -1, "yyyy\\-mm\\-dd")); Assert.AreEqual("1901.01.01", dfUS.FormatRawCellContents(367.0, -1, "yyyy.mm.dd")); Assert.AreEqual("1901.01.01", dfUS.FormatRawCellContents(367.0, -1, "yyyy\\.mm\\.dd")); Assert.AreEqual("1901/01/01", dfUS.FormatRawCellContents(367.0, -1, "yyyy/mm/dd")); Assert.AreEqual("1901/01/01", dfUS.FormatRawCellContents(367.0, -1, "yyyy\\/mm\\/dd")); }
public void TestAMPM() { DataFormatter dfUS = new DataFormatter(CultureShim.GetCultureInfo("en-US")); Assert.AreEqual("06:00", dfUS.FormatRawCellContents(0.25, -1, "hh:mm")); Assert.AreEqual("18:00", dfUS.FormatRawCellContents(0.75, -1, "hh:mm")); Assert.AreEqual("06:00 AM", dfUS.FormatRawCellContents(0.25, -1, "hh:mm AM/PM")); Assert.AreEqual("06:00 PM", dfUS.FormatRawCellContents(0.75, -1, "hh:mm AM/PM")); Assert.AreEqual("1904-01-01 06:00:00 AM", dfUS.FormatRawCellContents(0.25, -1, "yyyy-mm-dd hh:mm:ss AM/PM", true)); Assert.AreEqual("1904-01-01 06:00:00 PM", dfUS.FormatRawCellContents(0.75, -1, "yyyy-mm-dd hh:mm:ss AM/PM", true)); }
public void TestCustomFormats() { DataFormatter dfUS = new DataFormatter(CultureShim.GetCultureInfo("en-US"), true); String fmt; fmt = "\"At\" H:MM AM/PM \"on\" DDDD MMMM D\",\" YYYY"; Assert.AreEqual( "At 4:20 AM on Thursday May 17, 2007", dfUS.FormatRawCellContents(39219.1805636921, -1, fmt) ); fmt = "0 \"dollars and\" .00 \"cents\""; Assert.AreEqual("19 dollars and .99 cents", dfUS.FormatRawCellContents(19.99, -1, fmt)); }
public void TestInvalidDate() { //DataFormatter df1 = new DataFormatter(Locale.US); DataFormatter df1 = new DataFormatter(CultureShim.GetCultureInfo("en-US")); //Assert.AreEqual("-1.0", df1.FormatRawCellContents(-1, -1, "mm/dd/yyyy")); //in java -1.toString() is "-1.0", but in C# -1.ToString() is "-1". Assert.AreEqual("-1", df1.FormatRawCellContents(-1, -1, "mm/dd/yyyy")); //DataFormatter df2 = new DataFormatter(Locale.US); DataFormatter df2 = new DataFormatter(CultureShim.GetCultureInfo("en-US"), true); Assert.AreEqual("###############################################################################################################################################################################################################################################################", df2.FormatRawCellContents(-1, -1, "mm/dd/yyyy")); }
public void NumericCells() { CultureShim.SetCurrentCulture("en-US"); IWorkbook workbook = _testDataProvider.CreateWorkbook(); FixFonts(workbook); IDataFormat df = workbook.GetCreationHelper().CreateDataFormat(); ISheet sheet = workbook.CreateSheet(); IRow row = sheet.CreateRow(0); row.CreateCell(0).SetCellValue(0); // GetCachedFormulaResult() returns 0 for not Evaluated formula cells row.CreateCell(1).SetCellValue(10); row.CreateCell(2).SetCellValue("10"); row.CreateCell(3).CellFormula = (/*setter*/ "(A1+B1)*1.0"); // a formula that returns '10' ICell cell4 = row.CreateCell(4); // numeric cell with a custom style ICellStyle style4 = workbook.CreateCellStyle(); style4.DataFormat = (/*setter*/ df.GetFormat("0.0000")); cell4.CellStyle = (/*setter*/ style4); cell4.SetCellValue(10); // formatted as '10.0000' row.CreateCell(5).SetCellValue("10.0000"); // autosize not-Evaluated cells, formula cells are sized as if the result is 0 for (int i = 0; i < 6; i++) { sheet.AutoSizeColumn(i); } Assert.IsTrue(sheet.GetColumnWidth(0) < sheet.GetColumnWidth(1)); // width of '0' is less then width of '10' Assert.AreEqual(sheet.GetColumnWidth(1), sheet.GetColumnWidth(2)); // 10 and '10' should be sized Equally Assert.AreEqual(sheet.GetColumnWidth(3), sheet.GetColumnWidth(0)); // formula result is unknown, the width is calculated for '0' Assert.AreEqual(sheet.GetColumnWidth(4), sheet.GetColumnWidth(5)); // 10.0000 and '10.0000' // Evaluate formulas and re-autosize EvaluateWorkbook(workbook); for (int i = 0; i < 6; i++) { sheet.AutoSizeColumn(i); } Assert.IsTrue(sheet.GetColumnWidth(0) < sheet.GetColumnWidth(1)); // width of '0' is less then width of '10' Assert.AreEqual(sheet.GetColumnWidth(1), sheet.GetColumnWidth(2)); // columns 1, 2 and 3 should have the same width Assert.AreEqual(sheet.GetColumnWidth(2), sheet.GetColumnWidth(3)); // columns 1, 2 and 3 should have the same width Assert.AreEqual(sheet.GetColumnWidth(4), sheet.GetColumnWidth(5)); // 10.0000 and '10.0000' }
public void TestPaddingSpaces() { //DataFormatter dfUS = new DataFormatter(Locale.US); DataFormatter dfUS = new DataFormatter(CultureShim.GetCultureInfo("en-US")); Assert.AreEqual("12.34", dfUS.FormatRawCellContents(12.343, -1, "##.##_ ")); Assert.AreEqual("12.34", dfUS.FormatRawCellContents(12.343, -1, "##.##_1")); Assert.AreEqual("12.34", dfUS.FormatRawCellContents(12.343, -1, "##.##_)")); Assert.AreEqual("12.34", dfUS.FormatRawCellContents(12.343, -1, "_-##.##")); Assert.AreEqual("12.34", dfUS.FormatRawCellContents(12.343, -1, "##.##* ")); Assert.AreEqual("12.34", dfUS.FormatRawCellContents(12.343, -1, "##.##*1")); Assert.AreEqual("12.34", dfUS.FormatRawCellContents(12.343, -1, "##.##*)")); Assert.AreEqual("12.34", dfUS.FormatRawCellContents(12.343, -1, "*-##.##")); }
public void TestErrors() { DataFormatter dfUS = new DataFormatter(CultureShim.GetCultureInfo("en-US"), true); // Create a spreadsheet with some formula errors in it IWorkbook wb = new HSSFWorkbook(); ISheet s = wb.CreateSheet(); IRow r = s.CreateRow(0); ICell c = r.CreateCell(0, CellType.Error); c.SetCellErrorValue(FormulaError.DIV0.Code); Assert.AreEqual(FormulaError.DIV0.String, dfUS.FormatCellValue(c)); c.SetCellErrorValue(FormulaError.REF.Code); Assert.AreEqual(FormulaError.REF.String, dfUS.FormatCellValue(c)); }
public void TestColoursAndBrackets() { //DataFormatter dfUS = new DataFormatter(Locale.US); DataFormatter dfUS = new DataFormatter(CultureShim.GetCultureInfo("en-US")); // Without currency symbols String[] formats = new String[] { "#,##0.00;[Blue](#,##0.00)", }; foreach (String format in formats) { Assert.AreEqual( "12.34", dfUS.FormatRawCellContents(12.343, -1, format), "Wrong format for: " + format ); Assert.AreEqual( "(12.34)", dfUS.FormatRawCellContents(-12.343, -1, format), "Wrong format for: " + format ); } // With formats = new String[] { "$#,##0.00;[Red]($#,##0.00)" }; foreach (String format in formats) { Assert.AreEqual( "$12.34", dfUS.FormatRawCellContents(12.343, -1, format), "Wrong format for: " + format ); Assert.AreEqual( "($12.34)", dfUS.FormatRawCellContents(-12.343, -1, format), "Wrong format for: " + format ); } }
public void TestNegativeZero() { //DataFormatter dfUS = new DataFormatter(Locale.US); DataFormatter dfUS = new DataFormatter(CultureShim.GetCultureInfo("en-US")); String all2dp = "00.00"; String alln1dp = "(00.0)"; String p1dp_n1dp = "00.0;(00.0)"; String p2dp_n1dp = "00.00;(00.0)"; String p2dp_n1dp_z0 = "00.00;(00.0);0"; String all2dpTSP = "00.00_x"; String p2dp_n2dpTSP = "00.00_x;(00.00)_x"; Assert.AreEqual("12.34", dfUS.FormatRawCellContents(12.343, -1, all2dp)); Assert.AreEqual("12.34", dfUS.FormatRawCellContents(12.343, -1, p2dp_n1dp)); Assert.AreEqual("12.34", dfUS.FormatRawCellContents(12.343, -1, p2dp_n1dp_z0)); Assert.AreEqual("(12.3)", dfUS.FormatRawCellContents(12.343, -1, alln1dp)); Assert.AreEqual("-(12.3)", dfUS.FormatRawCellContents(-12.343, -1, alln1dp)); Assert.AreEqual("12.3", dfUS.FormatRawCellContents(12.343, -1, p1dp_n1dp)); Assert.AreEqual("(12.3)", dfUS.FormatRawCellContents(-12.343, -1, p1dp_n1dp)); Assert.AreEqual("-12.34", dfUS.FormatRawCellContents(-12.343, -1, all2dp)); // TODO - fix case of negative subpattern differing from the // positive one by more than just the prefix+suffix, which // is all DecimalFormat supports... // Assert.AreEqual("(12.3)", dfUS.FormatRawCellContents(-12.343, -1, p2dp_n1dp)); // Assert.AreEqual("(12.3)", dfUS.FormatRawCellContents(-12.343, -1, p2dp_n1dp_z0)); Assert.AreEqual("00.00", dfUS.FormatRawCellContents(0, -1, all2dp)); Assert.AreEqual("00.00", dfUS.FormatRawCellContents(0, -1, p2dp_n1dp)); Assert.AreEqual("0", dfUS.FormatRawCellContents(0, -1, p2dp_n1dp_z0)); // Spaces are skipped Assert.AreEqual("12.34", dfUS.FormatRawCellContents(12.343, -1, all2dpTSP)); Assert.AreEqual("12.34", dfUS.FormatRawCellContents(12.343, -1, p2dp_n2dpTSP)); Assert.AreEqual("(12.34)", dfUS.FormatRawCellContents(-12.343, -1, p2dp_n2dpTSP)); //String p2dp_n1dpTSP = "00.00_x;(00.0)_x"; // Assert.AreEqual("12.34", dfUS.FormatRawCellContents(12.343, -1, p2dp_n1dpTSP)); // Assert.AreEqual("(12.3)", dfUS.FormatRawCellContents(-12.343, -1, p2dp_n1dpTSP)); }
public void TestTextWithDateFormatSecondArg() { // Test with Java style M=Month CultureShim.SetCurrentCulture("en-US"); ValueEval numArg = new NumberEval(321.321); ValueEval formatArg = new StringEval("dd:MM:yyyy hh:mm:ss"); ValueEval[] args = { numArg, formatArg }; ValueEval result = TextFunction.TEXT.Evaluate(args, -1, (short)-1); ValueEval testResult = new StringEval("16:11:1900 07:42:14"); Assert.AreEqual(testResult.ToString(), result.ToString()); // Excel also supports "m before h is month" formatArg = new StringEval("dd:mm:yyyy hh:mm:ss"); args[1] = formatArg; result = TextFunction.TEXT.Evaluate(args, -1, (short)-1); testResult = new StringEval("16:11:1900 07:42:14"); //Assert.AreEqual(testResult.ToString(), result.ToString()); // this line is intended to compute how "November" would look like in the current locale string november = new SimpleDateFormat("MMMM").Format(new DateTime(2010, 11, 15), CultureInfo.CurrentCulture); // Again with Java style formatArg = new StringEval("MMMM dd, yyyy"); args[1] = formatArg; //fix error in non-en Culture Npoi.Core.SS.Formula.Functions.Text.Formatter = new Npoi.Core.SS.UserModel.DataFormatter(CultureInfo.CurrentCulture); result = TextFunction.TEXT.Evaluate(args, -1, (short)-1); testResult = new StringEval(november + " 16, 1900"); Assert.AreEqual(testResult.ToString(), result.ToString()); // And Excel style formatArg = new StringEval("mmmm dd, yyyy"); args[1] = formatArg; result = TextFunction.TEXT.Evaluate(args, -1, (short)-1); testResult = new StringEval(november + " 16, 1900"); Assert.AreEqual(testResult.ToString(), result.ToString()); }
public void TestDatesWithLocales() { DataFormatter dfUS = new DataFormatter(CultureShim.GetCultureInfo("en-US"), true); String dateFormatEnglish = "[$-409]mmmm dd yyyy h:mm AM/PM"; String dateFormatChinese = "[$-804]mmmm dd yyyy h:mm AM/PM"; // Check we format the English one correctly double date = 26995.477777777778; Assert.AreEqual( "November 27 1973 11:28 AM", dfUS.FormatRawCellContents(date, -1, dateFormatEnglish) ); // Check that, in the absence of locale support, we handle // the Chinese one the same as the English one Assert.AreEqual( "November 27 1973 11:28 AM", dfUS.FormatRawCellContents(date, -1, dateFormatChinese) ); }
public void TestElapsedTime() { //DataFormatter dfUS = new DataFormatter(Locale.US); DataFormatter dfUS = new DataFormatter(CultureShim.GetCultureInfo("en-US")); double hour = 1.0 / 24.0; Assert.AreEqual("01:00", dfUS.FormatRawCellContents(1 * hour, -1, "hh:mm")); Assert.AreEqual("05:00", dfUS.FormatRawCellContents(5 * hour, -1, "hh:mm")); Assert.AreEqual("20:00", dfUS.FormatRawCellContents(20 * hour, -1, "hh:mm")); Assert.AreEqual("23:00", dfUS.FormatRawCellContents(23 * hour, -1, "hh:mm")); Assert.AreEqual("00:00", dfUS.FormatRawCellContents(24 * hour, -1, "hh:mm")); Assert.AreEqual("02:00", dfUS.FormatRawCellContents(26 * hour, -1, "hh:mm")); Assert.AreEqual("20:00", dfUS.FormatRawCellContents(44 * hour, -1, "hh:mm")); Assert.AreEqual("02:00", dfUS.FormatRawCellContents(50 * hour, -1, "hh:mm")); Assert.AreEqual("01:00", dfUS.FormatRawCellContents(1 * hour, -1, "[hh]:mm")); Assert.AreEqual("05:00", dfUS.FormatRawCellContents(5 * hour, -1, "[hh]:mm")); Assert.AreEqual("20:00", dfUS.FormatRawCellContents(20 * hour, -1, "[hh]:mm")); Assert.AreEqual("23:00", dfUS.FormatRawCellContents(23 * hour, -1, "[hh]:mm")); Assert.AreEqual("24:00", dfUS.FormatRawCellContents(24 * hour, -1, "[hh]:mm")); Assert.AreEqual("26:00", dfUS.FormatRawCellContents(26 * hour, -1, "[hh]:mm")); Assert.AreEqual("44:00", dfUS.FormatRawCellContents(44 * hour, -1, "[hh]:mm")); Assert.AreEqual("50:00", dfUS.FormatRawCellContents(50 * hour, -1, "[hh]:mm")); Assert.AreEqual("01", dfUS.FormatRawCellContents(1 * hour, -1, "[hh]")); Assert.AreEqual("05", dfUS.FormatRawCellContents(5 * hour, -1, "[hh]")); Assert.AreEqual("20", dfUS.FormatRawCellContents(20 * hour, -1, "[hh]")); Assert.AreEqual("23", dfUS.FormatRawCellContents(23 * hour, -1, "[hh]")); Assert.AreEqual("24", dfUS.FormatRawCellContents(24 * hour, -1, "[hh]")); Assert.AreEqual("26", dfUS.FormatRawCellContents(26 * hour, -1, "[hh]")); Assert.AreEqual("44", dfUS.FormatRawCellContents(44 * hour, -1, "[hh]")); Assert.AreEqual("50", dfUS.FormatRawCellContents(50 * hour, -1, "[hh]")); double minute = 1.0 / 24.0 / 60.0; Assert.AreEqual("01:00", dfUS.FormatRawCellContents(1 * minute, -1, "[mm]:ss")); Assert.AreEqual("05:00", dfUS.FormatRawCellContents(5 * minute, -1, "[mm]:ss")); Assert.AreEqual("20:00", dfUS.FormatRawCellContents(20 * minute, -1, "[mm]:ss")); Assert.AreEqual("23:00", dfUS.FormatRawCellContents(23 * minute, -1, "[mm]:ss")); Assert.AreEqual("24:00", dfUS.FormatRawCellContents(24 * minute, -1, "[mm]:ss")); Assert.AreEqual("26:00", dfUS.FormatRawCellContents(26 * minute, -1, "[mm]:ss")); Assert.AreEqual("44:00", dfUS.FormatRawCellContents(44 * minute, -1, "[mm]:ss")); Assert.AreEqual("50:00", dfUS.FormatRawCellContents(50 * minute, -1, "[mm]:ss")); Assert.AreEqual("59:00", dfUS.FormatRawCellContents(59 * minute, -1, "[mm]:ss")); Assert.AreEqual("60:00", dfUS.FormatRawCellContents(60 * minute, -1, "[mm]:ss")); Assert.AreEqual("61:00", dfUS.FormatRawCellContents(61 * minute, -1, "[mm]:ss")); Assert.AreEqual("119:00", dfUS.FormatRawCellContents(119 * minute, -1, "[mm]:ss")); Assert.AreEqual("120:00", dfUS.FormatRawCellContents(120 * minute, -1, "[mm]:ss")); Assert.AreEqual("121:00", dfUS.FormatRawCellContents(121 * minute, -1, "[mm]:ss")); Assert.AreEqual("01", dfUS.FormatRawCellContents(1 * minute, -1, "[mm]")); Assert.AreEqual("05", dfUS.FormatRawCellContents(5 * minute, -1, "[mm]")); Assert.AreEqual("20", dfUS.FormatRawCellContents(20 * minute, -1, "[mm]")); Assert.AreEqual("23", dfUS.FormatRawCellContents(23 * minute, -1, "[mm]")); Assert.AreEqual("24", dfUS.FormatRawCellContents(24 * minute, -1, "[mm]")); Assert.AreEqual("26", dfUS.FormatRawCellContents(26 * minute, -1, "[mm]")); Assert.AreEqual("44", dfUS.FormatRawCellContents(44 * minute, -1, "[mm]")); Assert.AreEqual("50", dfUS.FormatRawCellContents(50 * minute, -1, "[mm]")); Assert.AreEqual("59", dfUS.FormatRawCellContents(59 * minute, -1, "[mm]")); Assert.AreEqual("60", dfUS.FormatRawCellContents(60 * minute, -1, "[mm]")); Assert.AreEqual("61", dfUS.FormatRawCellContents(61 * minute, -1, "[mm]")); Assert.AreEqual("119", dfUS.FormatRawCellContents(119 * minute, -1, "[mm]")); Assert.AreEqual("120", dfUS.FormatRawCellContents(120 * minute, -1, "[mm]")); Assert.AreEqual("121", dfUS.FormatRawCellContents(121 * minute, -1, "[mm]")); double second = 1.0 / 24.0 / 60.0 / 60.0; Assert.AreEqual("86400", dfUS.FormatRawCellContents(86400 * second, -1, "[ss]")); Assert.AreEqual("01", dfUS.FormatRawCellContents(1 * second, -1, "[ss]")); Assert.AreEqual("05", dfUS.FormatRawCellContents(5 * second, -1, "[ss]")); Assert.AreEqual("20", dfUS.FormatRawCellContents(20 * second, -1, "[ss]")); Assert.AreEqual("23", dfUS.FormatRawCellContents(23 * second, -1, "[ss]")); Assert.AreEqual("24", dfUS.FormatRawCellContents(24 * second, -1, "[ss]")); Assert.AreEqual("26", dfUS.FormatRawCellContents(26 * second, -1, "[ss]")); Assert.AreEqual("44", dfUS.FormatRawCellContents(44 * second, -1, "[ss]")); Assert.AreEqual("50", dfUS.FormatRawCellContents(50 * second, -1, "[ss]")); Assert.AreEqual("59", dfUS.FormatRawCellContents(59 * second, -1, "[ss]")); Assert.AreEqual("60", dfUS.FormatRawCellContents(60 * second, -1, "[ss]")); Assert.AreEqual("61", dfUS.FormatRawCellContents(61 * second, -1, "[ss]")); Assert.AreEqual("119", dfUS.FormatRawCellContents(119 * second, -1, "[ss]")); Assert.AreEqual("120", dfUS.FormatRawCellContents(120 * second, -1, "[ss]")); Assert.AreEqual("121", dfUS.FormatRawCellContents(121 * second, -1, "[ss]")); //boolean jdk_1_5 = System.getProperty("java.vm.version").startsWith("1.5"); //if(!jdk_1_5) { // YK: the tests below were written under JDK 1.6 and assume that // the rounding mode in the underlying decimal formatters is HALF_UP // It is not so JDK 1.5 where the default rounding mode is HALV_EVEN and cannot be changed. Assert.AreEqual("27:18:08", dfUS.FormatRawCellContents(1.1376, -1, "[h]:mm:ss")); Assert.AreEqual("28:48:00", dfUS.FormatRawCellContents(1.2, -1, "[h]:mm:ss")); Assert.AreEqual("29:31:12", dfUS.FormatRawCellContents(1.23, -1, "[h]:mm:ss")); Assert.AreEqual("31:26:24", dfUS.FormatRawCellContents(1.31, -1, "[h]:mm:ss")); Assert.AreEqual("27:18:08", dfUS.FormatRawCellContents(1.1376, -1, "[hh]:mm:ss")); Assert.AreEqual("28:48:00", dfUS.FormatRawCellContents(1.2, -1, "[hh]:mm:ss")); Assert.AreEqual("29:31:12", dfUS.FormatRawCellContents(1.23, -1, "[hh]:mm:ss")); Assert.AreEqual("31:26:24", dfUS.FormatRawCellContents(1.31, -1, "[hh]:mm:ss")); Assert.AreEqual("57:07.2", dfUS.FormatRawCellContents(.123, -1, "mm:ss.0;@")); Assert.AreEqual("57:41.8", dfUS.FormatRawCellContents(.1234, -1, "mm:ss.0;@")); Assert.AreEqual("57:41.76", dfUS.FormatRawCellContents(.1234, -1, "mm:ss.00;@")); Assert.AreEqual("57:41.760", dfUS.FormatRawCellContents(.1234, -1, "mm:ss.000;@")); Assert.AreEqual("24:00.0", dfUS.FormatRawCellContents(123456.6, -1, "mm:ss.0")); //} }
public void TestFractions() { DataFormatter dfUS = new DataFormatter(CultureShim.GetCultureInfo("en-US")); // Excel often prefers "# #/#" Assert.AreEqual("321 1/3", dfUS.FormatRawCellContents(321.321, -1, "# #/#")); Assert.AreEqual("321 26/81", dfUS.FormatRawCellContents(321.321, -1, "# #/##")); Assert.AreEqual("26027/81", dfUS.FormatRawCellContents(321.321, -1, "#/##")); // OOo seems to like the "# ?/?" form Assert.AreEqual("321 1/3", dfUS.FormatRawCellContents(321.321, -1, "# ?/?")); Assert.AreEqual("321 26/81", dfUS.FormatRawCellContents(321.321, -1, "# ?/??")); Assert.AreEqual("26027/81", dfUS.FormatRawCellContents(321.321, -1, "?/??")); // p;n;z;s parts Assert.AreEqual("321 1/3", dfUS.FormatRawCellContents(321.321, -1, "# #/#;# ##/#;0;xxx")); Assert.AreEqual("-321 1/3", dfUS.FormatRawCellContents(-321.321, -1, "# #/#;# ##/#;0;xxx")); Assert.AreEqual("0", dfUS.FormatRawCellContents(0, -1, "# #/#;# ##/#;0;xxx")); // Assert.AreEqual("0.0", dfUS.FormatRawCellContents(0, -1, "# #/#;# ##/#;#.#;xxx")); // currently hard coded to 0 // Custom formats with text are not currently supported // Assert.AreEqual("+ve", dfUS.FormatRawCellContents(0, -1, "+ve;-ve;zero;xxx")); // Assert.AreEqual("-ve", dfUS.FormatRawCellContents(0, -1, "-ve;-ve;zero;xxx")); // Assert.AreEqual("zero", dfUS.FormatRawCellContents(0, -1, "zero;-ve;zero;xxx")); // Custom formats - check text is stripped, including multiple spaces Assert.AreEqual("321 1/3", dfUS.FormatRawCellContents(321.321, -1, "# #/#")); Assert.AreEqual("321 1/3", dfUS.FormatRawCellContents(321.321, -1, "#\" \" #/#")); Assert.AreEqual("321 1/3", dfUS.FormatRawCellContents(321.321, -1, "#\"FRED\" #/#")); Assert.AreEqual("321 1/3", dfUS.FormatRawCellContents(321.321, -1, "#\\ #/#")); Assert.AreEqual("321 1/3", dfUS.FormatRawCellContents(321.321, -1, "# \\q#/#")); // Cases that were very slow Assert.AreEqual("321 1/3", dfUS.FormatRawCellContents(321.321, -1, "0\" \"?/?;?/?")); // 0" "?/?;?/? - length of -ve part was used Assert.AreEqual("321 1/3", dfUS.FormatRawCellContents(321.321, -1, "0 \"#\"\\#\\#?/?")); // 0 "#"\#\#?/? - length of text was used Assert.AreEqual("321 295/919", dfUS.FormatRawCellContents(321.321, -1, "# #/###")); Assert.AreEqual("321 321/1000", dfUS.FormatRawCellContents(321.321, -1, "# #/####")); // Code limits to #### as that is as slow as we want to get Assert.AreEqual("321 321/1000", dfUS.FormatRawCellContents(321.321, -1, "# #/##########")); // Not a valid fraction formats (too many #/# or ?/?) - hence the strange expected results /*Assert.AreEqual("321 / ?/?", dfUS.FormatRawCellContents(321.321, -1, "# #/# ?/?")); * Assert.AreEqual("321 / /", dfUS.FormatRawCellContents(321.321, -1, "# #/# #/#")); * Assert.AreEqual("321 ?/? ?/?", dfUS.FormatRawCellContents(321.321, -1, "# ?/? ?/?")); * Assert.AreEqual("321 ?/? / /", dfUS.FormatRawCellContents(321.321, -1, "# ?/? #/# #/#")); */ //Bug54686 patch sets default behavior of # #/## if there is a failure to parse Assert.AreEqual("321 1/3", dfUS.FormatRawCellContents(321.321, -1, "# #/# ?/?")); Assert.AreEqual("321 1/3", dfUS.FormatRawCellContents(321.321, -1, "# #/# #/#")); Assert.AreEqual("321 1/3", dfUS.FormatRawCellContents(321.321, -1, "# ?/? ?/?")); Assert.AreEqual("321 1/3", dfUS.FormatRawCellContents(321.321, -1, "# ?/? #/# #/#")); // Where both p and n don't include a fraction, so cannot always be formatted //Assert.AreEqual("123", dfUS.FormatRawCellContents(-123.321, -1, "0 ?/?;0")); //Bug54868 patch has a hit on the first string before the ";" Assert.AreEqual("-123 1/3", dfUS.FormatRawCellContents(-123.321, -1, "0 ?/?;0")); //Bug53150 formatting a whole number with fractions should just give the number Assert.AreEqual("1", dfUS.FormatRawCellContents(1.0, -1, "# #/#")); Assert.AreEqual("11", dfUS.FormatRawCellContents(11.0, -1, "# #/#")); }