/* ====================================================================
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.hssf.usermodel;
import junit.framework.AssertionFailedError;
import org.apache.poi.hssf.HSSFITestDataProvider;
import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.hssf.OldExcelFormatException;
import org.apache.poi.hssf.extractor.ExcelExtractor;
import org.apache.poi.hssf.model.InternalWorkbook;
import org.apache.poi.hssf.record.*;
import org.apache.poi.hssf.record.aggregates.FormulaRecordAggregate;
import org.apache.poi.hssf.record.common.UnicodeString;
import org.apache.poi.poifs.filesystem.NPOIFSFileSystem;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.ss.formula.ptg.Area3DPtg;
import org.apache.poi.ss.formula.ptg.DeletedArea3DPtg;
import org.apache.poi.ss.formula.ptg.Ptg;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.util.TempFile;
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
/**
* Testcases for bugs entered in bugzilla
* the Test name contains the bugzilla bug id
*
* YK: If a bug can be tested in terms of common ss interfaces,
* define the test in the base class {@link BaseTestBugzillaIssues}
*
* @author Avik Sengupta
* @author Yegor Kozlov
*/
public final class TestBugs extends BaseTestBugzillaIssues {
public TestBugs() {
super(HSSFITestDataProvider.instance);
}
private static HSSFWorkbook openSample(String sampleFileName) {
return HSSFITestDataProvider.instance.openSampleWorkbook(sampleFileName);
}
private static HSSFWorkbook writeOutAndReadBack(HSSFWorkbook original) {
return HSSFITestDataProvider.instance.writeOutAndReadBack(original);
}
private static void writeTestOutputFileForViewing(HSSFWorkbook wb, String simpleFileName) {
if (true) { // set to false to output test files
return;
}
System.setProperty("poi.keep.tmp.files", "true");
File file;
try {
file = TempFile.createTempFile(simpleFileName + "#", ".xls");
FileOutputStream out = new FileOutputStream(file);
wb.write(out);
out.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
if (!file.exists()) {
throw new RuntimeException("File was not written");
}
System.out.println("Open file '" + file.getAbsolutePath() + "' in Excel");
}
/** Test reading AND writing a complicated workbook
*Test opening resulting sheet in excel*/
public void test15228() {
HSSFWorkbook wb = openSample("15228.xls");
HSSFSheet s = wb.getSheetAt(0);
HSSFRow r = s.createRow(0);
HSSFCell c = r.createCell(0);
c.setCellValue(10);
writeTestOutputFileForViewing(wb, "test15228");
}
public void test13796() {
HSSFWorkbook wb = openSample("13796.xls");
HSSFSheet s = wb.getSheetAt(0);
HSSFRow r = s.createRow(0);
HSSFCell c = r.createCell(0);
c.setCellValue(10);
writeOutAndReadBack(wb);
}
/** test hyperlinks
* open resulting file in excel, and check that there is a link to Google
*/
public void test15353() {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet("My sheet");
HSSFRow row = sheet.createRow( 0 );
HSSFCell cell = row.createCell( 0 );
cell.setCellFormula("HYPERLINK(\"http://google.com\",\"Google\")");
writeOutAndReadBack(wb);
}
/** test reading of a formula with a name and a cell ref in one
**/
public void test14460() {
HSSFWorkbook wb = openSample("14460.xls");
wb.getSheetAt(0);
}
public void test14330() {
HSSFWorkbook wb = openSample("14330-1.xls");
wb.getSheetAt(0);
wb = openSample("14330-2.xls");
wb.getSheetAt(0);
}
private static void setCellText(HSSFCell cell, String text) {
cell.setCellValue(new HSSFRichTextString(text));
}
/** test rewriting a file with large number of unique strings
*open resulting file in Excel to check results!*/
public void test15375() {
HSSFWorkbook wb = openSample("15375.xls");
HSSFSheet sheet = wb.getSheetAt(0);
HSSFRow row = sheet.getRow(5);
HSSFCell cell = row.getCell(3);
if (cell == null)
cell = row.createCell(3);
// Write test
cell.setCellType(HSSFCell.CELL_TYPE_STRING);
setCellText(cell, "a test");
// change existing numeric cell value
HSSFRow oRow = sheet.getRow(14);
HSSFCell oCell = oRow.getCell(4);
oCell.setCellValue(75);
oCell = oRow.getCell(5);
setCellText(oCell, "0.3");
writeTestOutputFileForViewing(wb, "test15375");
}
/**
* test writing a file with large number of unique strings,
* open resulting file in Excel to check results!
*/
public void test15375_2() {
baseTest15375(6000);
}
/**Double byte strings*/
public void test15556() {
HSSFWorkbook wb = openSample("15556.xls");
HSSFSheet sheet = wb.getSheetAt(0);
HSSFRow row = sheet.getRow(45);
assertNotNull("Read row fine!" , row);
}
/**Double byte strings */
public void test22742() {
openSample("22742.xls");
}
/**Double byte strings */
public void test12561_1() {
openSample("12561-1.xls");
}
/** Double byte strings */
public void test12561_2() {
openSample("12561-2.xls");
}
/** Double byte strings
File supplied by jubeson*/
public void test12843_1() {
openSample("12843-1.xls");
}
/** Double byte strings
File supplied by Paul Chung*/
public void test12843_2() {
openSample("12843-2.xls");
}
/** Reference to Name*/
public void test13224() {
openSample("13224.xls");
}
/** Illegal argument exception - cannot store duplicate value in Map*/
public void test19599() {
openSample("19599-1.xls");
openSample("19599-2.xls");
}
public void test24215() {
HSSFWorkbook wb = openSample("24215.xls");
for (int sheetIndex = 0; sheetIndex < wb.getNumberOfSheets();sheetIndex++) {
HSSFSheet sheet = wb.getSheetAt(sheetIndex);
int rows = sheet.getLastRowNum();
for (int rowIndex = 0; rowIndex < rows; rowIndex++) {
HSSFRow row = sheet.getRow(rowIndex);
int cells = row.getLastCellNum();
for (int cellIndex = 0; cellIndex < cells; cellIndex++) {
row.getCell(cellIndex);
}
}
}
}
/**Tests read and write of Unicode strings in formula results
* bug and testcase submitted by Sompop Kumnoonsate
* The file contains THAI unicode characters.
*/
public void testUnicodeStringFormulaRead() {
HSSFWorkbook w = openSample("25695.xls");
HSSFCell a1 = w.getSheetAt(0).getRow(0).getCell(0);
HSSFCell a2 = w.getSheetAt(0).getRow(0).getCell(1);
HSSFCell b1 = w.getSheetAt(0).getRow(1).getCell(0);
HSSFCell b2 = w.getSheetAt(0).getRow(1).getCell(1);
HSSFCell c1 = w.getSheetAt(0).getRow(2).getCell(0);
HSSFCell c2 = w.getSheetAt(0).getRow(2).getCell(1);
HSSFCell d1 = w.getSheetAt(0).getRow(3).getCell(0);
HSSFCell d2 = w.getSheetAt(0).getRow(3).getCell(1);
if (false) {
// THAI code page
System.out.println("a1="+unicodeString(a1));
System.out.println("a2="+unicodeString(a2));
// US code page
System.out.println("b1="+unicodeString(b1));
System.out.println("b2="+unicodeString(b2));
// THAI+US
System.out.println("c1="+unicodeString(c1));
System.out.println("c2="+unicodeString(c2));
// US+THAI
System.out.println("d1="+unicodeString(d1));
System.out.println("d2="+unicodeString(d2));
}
confirmSameCellText(a1, a2);
confirmSameCellText(b1, b2);
confirmSameCellText(c1, c2);
confirmSameCellText(d1, d2);
HSSFWorkbook rw = writeOutAndReadBack(w);
HSSFCell ra1 = rw.getSheetAt(0).getRow(0).getCell(0);
HSSFCell ra2 = rw.getSheetAt(0).getRow(0).getCell(1);
HSSFCell rb1 = rw.getSheetAt(0).getRow(1).getCell(0);
HSSFCell rb2 = rw.getSheetAt(0).getRow(1).getCell(1);
HSSFCell rc1 = rw.getSheetAt(0).getRow(2).getCell(0);
HSSFCell rc2 = rw.getSheetAt(0).getRow(2).getCell(1);
HSSFCell rd1 = rw.getSheetAt(0).getRow(3).getCell(0);
HSSFCell rd2 = rw.getSheetAt(0).getRow(3).getCell(1);
confirmSameCellText(a1, ra1);
confirmSameCellText(b1, rb1);
confirmSameCellText(c1, rc1);
confirmSameCellText(d1, rd1);
confirmSameCellText(a1, ra2);
confirmSameCellText(b1, rb2);
confirmSameCellText(c1, rc2);
confirmSameCellText(d1, rd2);
}
private static void confirmSameCellText(HSSFCell a, HSSFCell b) {
assertEquals(a.getRichStringCellValue().getString(), b.getRichStringCellValue().getString());
}
private static String unicodeString(HSSFCell cell) {
String ss = cell.getRichStringCellValue().getString();
char s[] = ss.toCharArray();
StringBuffer sb = new StringBuffer();
for (int x=0;x 0) {
throw new AssertionFailedError("identified bug 44306");
}
}
}
/**
* Something up with the FileSharingRecord
*/
public void test43251() {
// Used to blow up with an IllegalArgumentException
// when creating a FileSharingRecord
HSSFWorkbook wb;
try {
wb = openSample("43251.xls");
} catch (IllegalArgumentException e) {
throw new AssertionFailedError("identified bug 43251");
}
assertEquals(1, wb.getNumberOfSheets());
}
/**
* Crystal reports generates files with short
* StyleRecords, which is against the spec
*/
public void test44471() {
// Used to blow up with an ArrayIndexOutOfBounds
// when creating a StyleRecord
HSSFWorkbook wb;
try {
wb = openSample("OddStyleRecord.xls");
} catch (ArrayIndexOutOfBoundsException e) {
throw new AssertionFailedError("Identified bug 44471");
}
assertEquals(1, wb.getNumberOfSheets());
}
/**
* Files with "read only recommended" were giving
* grief on the FileSharingRecord
*/
public void test44536() {
// Used to blow up with an IllegalArgumentException
// when creating a FileSharingRecord
HSSFWorkbook wb = openSample("ReadOnlyRecommended.xls");
// Check read only advised
assertEquals(3, wb.getNumberOfSheets());
assertTrue(wb.isWriteProtected());
// But also check that another wb isn't
wb = openSample("SimpleWithChoose.xls");
assertFalse(wb.isWriteProtected());
}
/**
* Some files were having problems with the DVRecord,
* probably due to dropdowns
*/
public void test44593() {
// Used to blow up with an IllegalArgumentException
// when creating a DVRecord
// Now won't, but no idea if this means we have
// rubbish in the DVRecord or not...
HSSFWorkbook wb;
try {
wb = openSample("44593.xls");
} catch (IllegalArgumentException e) {
throw new AssertionFailedError("Identified bug 44593");
}
assertEquals(2, wb.getNumberOfSheets());
}
/**
* Used to give problems due to trying to read a zero
* length string, but that's now properly handled
*/
public void test44643() {
// Used to blow up with an IllegalArgumentException
HSSFWorkbook wb;
try {
wb = openSample("44643.xls");
} catch (IllegalArgumentException e) {
throw new AssertionFailedError("identified bug 44643");
}
assertEquals(1, wb.getNumberOfSheets());
}
/**
* User reported the wrong number of rows from the
* iterator, but we can't replicate that
*/
public void test44693() {
HSSFWorkbook wb = openSample("44693.xls");
HSSFSheet s = wb.getSheetAt(0);
// Rows are 1 to 713
assertEquals(0, s.getFirstRowNum());
assertEquals(712, s.getLastRowNum());
assertEquals(713, s.getPhysicalNumberOfRows());
// Now check the iterator
int rowsSeen = 0;
for(Iterator i = s.rowIterator(); i.hasNext(); ) {
HSSFRow r = (HSSFRow)i.next();
assertNotNull(r);
rowsSeen++;
}
assertEquals(713, rowsSeen);
}
/**
* Bug 28774: Excel will crash when opening xls-files with images.
*/
public void test28774() {
HSSFWorkbook wb = openSample("28774.xls");
assertTrue("no errors reading sample xls", true);
writeOutAndReadBack(wb);
assertTrue("no errors writing sample xls", true);
}
/**
* Had a problem apparently, not sure what as it
* works just fine...
*/
public void test44891() {
HSSFWorkbook wb = openSample("44891.xls");
assertTrue("no errors reading sample xls", true);
writeOutAndReadBack(wb);
assertTrue("no errors writing sample xls", true);
}
/**
* Bug 44235: Ms Excel can't open save as excel file
*
* Works fine with poi-3.1-beta1.
*/
public void test44235() {
HSSFWorkbook wb = openSample("44235.xls");
assertTrue("no errors reading sample xls", true);
writeOutAndReadBack(wb);
assertTrue("no errors writing sample xls", true);
}
public void test36947() {
HSSFWorkbook wb = openSample("36947.xls");
assertTrue("no errors reading sample xls", true);
writeOutAndReadBack(wb);
assertTrue("no errors writing sample xls", true);
}
public void test39634() {
HSSFWorkbook wb = openSample("39634.xls");
assertTrue("no errors reading sample xls", true);
writeOutAndReadBack(wb);
assertTrue("no errors writing sample xls", true);
}
/**
* Problems with extracting check boxes from
* HSSFObjectData
* @throws Exception
*/
public void test44840() {
HSSFWorkbook wb = openSample("WithCheckBoxes.xls");
// Take a look at the embedded objects
List objects = wb.getAllEmbeddedObjects();
assertEquals(1, objects.size());
HSSFObjectData obj = (HSSFObjectData)objects.get(0);
assertNotNull(obj);
// Peek inside the underlying record
EmbeddedObjectRefSubRecord rec = obj.findObjectRecord();
assertNotNull(rec);
// assertEquals(32, rec.field_1_stream_id_offset);
assertEquals(0, rec.getStreamId().intValue()); // WRONG!
assertEquals("Forms.CheckBox.1", rec.getOLEClassName());
assertEquals(12, rec.getObjectData().length);
// Doesn't have a directory
assertFalse(obj.hasDirectoryEntry());
assertNotNull(obj.getObjectData());
assertEquals(12, obj.getObjectData().length);
assertEquals("Forms.CheckBox.1", obj.getOLE2ClassName());
try {
obj.getDirectory();
fail();
} catch(FileNotFoundException e) {
// expected during successful test
} catch (IOException e) {
throw new RuntimeException(e);
}
}
/**
* Test that we can delete sheets without
* breaking the build in named ranges
* used for printing stuff.
*/
public void test30978() {
HSSFWorkbook wb = openSample("30978-alt.xls");
assertEquals(1, wb.getNumberOfNames());
assertEquals(3, wb.getNumberOfSheets());
// Check all names fit within range, and use
// DeletedArea3DPtg
InternalWorkbook w = wb.getWorkbook();
for(int i=0; i namedStyles = Arrays.asList(
"20% - Accent1", "20% - Accent2", "20% - Accent3", "20% - Accent4", "20% - Accent5",
"20% - Accent6", "40% - Accent1", "40% - Accent2", "40% - Accent3", "40% - Accent4",
"40% - Accent5", "40% - Accent6", "60% - Accent1", "60% - Accent2", "60% - Accent3",
"60% - Accent4", "60% - Accent5", "60% - Accent6", "Accent1", "Accent2", "Accent3",
"Accent4", "Accent5", "Accent6", "Bad", "Calculation", "Check Cell", "Explanatory Text",
"Good", "Heading 1", "Heading 2", "Heading 3", "Heading 4", "Input", "Linked Cell",
"Neutral", "Note", "Output", "Title", "Total", "Warning Text");
List collecteddStyles = new ArrayList();
for (short i = 0; i < numCellStyles; i++) {
HSSFCellStyle cellStyle = wb.getCellStyleAt(i);
String styleName = cellStyle.getUserStyleName();
if (styleName != null) {
collecteddStyles.add(styleName);
}
}
assertTrue(namedStyles.containsAll(collecteddStyles));
}
/**
* Regression with the PageSettingsBlock
*/
public void test49931() throws Exception {
HSSFWorkbook wb = openSample("49931.xls");
assertEquals(1, wb.getNumberOfSheets());
assertEquals("Foo", wb.getSheetAt(0).getRow(0).getCell(0).getRichStringCellValue().toString());
}
/**
* Missing left/right/centre options on a footer
*/
public void test48325() throws Exception {
HSSFWorkbook wb = openSample("48325.xls");
HSSFSheet sh = wb.getSheetAt(0);
HSSFFooter f = sh.getFooter();
// Will show as the centre, as that is what excel does
// with an invalid footer lacking left/right/centre details
assertEquals("Left text should be empty", "", f.getLeft());
assertEquals("Right text should be empty", "", f.getRight());
assertEquals(
"Center text should contain the illegal value",
"BlahBlah blah blah ", f.getCenter()
);
}
/**
* IllegalStateException received when creating Data validation in sheet with macro
*/
public void test50020() throws Exception {
HSSFWorkbook wb = openSample("50020.xls");
writeOutAndReadBack(wb);
}
public void test50426() throws Exception {
HSSFWorkbook wb = openSample("50426.xls");
writeOutAndReadBack(wb);
}
/**
* Last row number when shifting rows
*/
public void test50416LastRowNumber() {
// Create the workbook with 1 sheet which contains 3 rows
HSSFWorkbook workbook = new HSSFWorkbook();
Sheet sheet = workbook.createSheet("Bug50416");
Row row1 = sheet.createRow(0);
Cell cellA_1 = row1.createCell(0,Cell.CELL_TYPE_STRING);
cellA_1.setCellValue("Cell A,1");
Row row2 = sheet.createRow(1);
Cell cellA_2 = row2.createCell(0,Cell.CELL_TYPE_STRING);
cellA_2.setCellValue("Cell A,2");
Row row3 = sheet.createRow(2);
Cell cellA_3 = row3.createCell(0,Cell.CELL_TYPE_STRING);
cellA_3.setCellValue("Cell A,3");
// Test the last Row number it currently correct
assertEquals(2, sheet.getLastRowNum());
// Shift the first row to the end
sheet.shiftRows(0, 0, 3);
assertEquals(3, sheet.getLastRowNum());
assertEquals(-1, sheet.getRow(0).getLastCellNum());
assertEquals("Cell A,2", sheet.getRow(1).getCell(0).getStringCellValue());
assertEquals("Cell A,3", sheet.getRow(2).getCell(0).getStringCellValue());
assertEquals("Cell A,1", sheet.getRow(3).getCell(0).getStringCellValue());
// Shift the 2nd row up to the first one
sheet.shiftRows(1, 1, -1);
assertEquals(3, sheet.getLastRowNum());
assertEquals("Cell A,2", sheet.getRow(0).getCell(0).getStringCellValue());
assertEquals(-1, sheet.getRow(1).getLastCellNum());
assertEquals("Cell A,3", sheet.getRow(2).getCell(0).getStringCellValue());
assertEquals("Cell A,1", sheet.getRow(3).getCell(0).getStringCellValue());
// Shift the 4th row up into the gap in the 3rd row
sheet.shiftRows(3, 3, -2);
assertEquals(2, sheet.getLastRowNum());
assertEquals("Cell A,2", sheet.getRow(0).getCell(0).getStringCellValue());
assertEquals("Cell A,1", sheet.getRow(1).getCell(0).getStringCellValue());
assertEquals("Cell A,3", sheet.getRow(2).getCell(0).getStringCellValue());
assertEquals(-1, sheet.getRow(3).getLastCellNum());
// Now zap the empty 4th row - won't do anything
sheet.removeRow(sheet.getRow(3));
// Test again the last row number which should be 2
assertEquals(2, sheet.getLastRowNum());
assertEquals("Cell A,2", sheet.getRow(0).getCell(0).getStringCellValue());
assertEquals("Cell A,1", sheet.getRow(1).getCell(0).getStringCellValue());
assertEquals("Cell A,3", sheet.getRow(2).getCell(0).getStringCellValue());
}
/**
* If you send a file between Excel and OpenOffice enough, something
* will turn the "General" format into "GENERAL"
*/
public void test50756() throws Exception {
HSSFWorkbook wb = openSample("50756.xls");
HSSFSheet s = wb.getSheetAt(0);
HSSFRow r17 = s.getRow(16);
HSSFRow r18 = s.getRow(17);
HSSFDataFormatter df = new HSSFDataFormatter();
assertEquals(10.0, r17.getCell(1).getNumericCellValue());
assertEquals(20.0, r17.getCell(2).getNumericCellValue());
assertEquals(20.0, r17.getCell(3).getNumericCellValue());
assertEquals("GENERAL", r17.getCell(1).getCellStyle().getDataFormatString());
assertEquals("GENERAL", r17.getCell(2).getCellStyle().getDataFormatString());
assertEquals("GENERAL", r17.getCell(3).getCellStyle().getDataFormatString());
assertEquals("10", df.formatCellValue(r17.getCell(1)));
assertEquals("20", df.formatCellValue(r17.getCell(2)));
assertEquals("20", df.formatCellValue(r17.getCell(3)));
assertEquals(16.0, r18.getCell(1).getNumericCellValue());
assertEquals(35.0, r18.getCell(2).getNumericCellValue());
assertEquals(123.0, r18.getCell(3).getNumericCellValue());
assertEquals("GENERAL", r18.getCell(1).getCellStyle().getDataFormatString());
assertEquals("GENERAL", r18.getCell(2).getCellStyle().getDataFormatString());
assertEquals("GENERAL", r18.getCell(3).getCellStyle().getDataFormatString());
assertEquals("16", df.formatCellValue(r18.getCell(1)));
assertEquals("35", df.formatCellValue(r18.getCell(2)));
assertEquals("123", df.formatCellValue(r18.getCell(3)));
}
/**
* A protected sheet with comments, when written out by
* POI, ends up upsetting excel.
* TODO Identify the cause and add extra asserts for
* the bit excel cares about
*/
public void test50833() throws Exception {
HSSFWorkbook wb = openSample("50833.xls");
HSSFSheet s = wb.getSheetAt(0);
assertEquals("Sheet1", s.getSheetName());
assertEquals(false, s.getProtect());
HSSFCell c = s.getRow(0).getCell(0);
assertEquals("test cell value", c.getRichStringCellValue().getString());
HSSFComment cmt = c.getCellComment();
assertNotNull(cmt);
assertEquals("Robert Lawrence", cmt.getAuthor());
assertEquals("Robert Lawrence:\ntest comment", cmt.getString().getString());
// Reload
wb = writeOutAndReadBack(wb);
s = wb.getSheetAt(0);
c = s.getRow(0).getCell(0);
// Re-check the comment
cmt = c.getCellComment();
assertNotNull(cmt);
assertEquals("Robert Lawrence", cmt.getAuthor());
assertEquals("Robert Lawrence:\ntest comment", cmt.getString().getString());
// TODO Identify what excel doesn't like, and check for that
}
public void test50779() throws Exception {
HSSFWorkbook wb1 = openSample("50779_1.xls");
writeOutAndReadBack(wb1);
HSSFWorkbook wb2 = openSample("50779_2.xls");
writeOutAndReadBack(wb2);
}
/**
* The spec says that ChartEndObjectRecord has 6 reserved
* bytes on the end, but we sometimes find files without...
*/
public void test50939() throws Exception {
HSSFWorkbook wb = openSample("50939.xls");
assertEquals(2, wb.getNumberOfSheets());
}
public void test49219() throws Exception {
HSSFWorkbook wb = openSample("49219.xls");
assertEquals(1, wb.getNumberOfSheets());
assertEquals("DGATE", wb.getSheetAt(0).getRow(1).getCell(0).getStringCellValue());
}
public void test48968() throws Exception {
HSSFWorkbook wb = openSample("48968.xls");
assertEquals(1, wb.getNumberOfSheets());
DataFormatter fmt = new DataFormatter();
// Check the dates
HSSFSheet s = wb.getSheetAt(0);
Cell cell_d20110325 = s.getRow(0).getCell(0);
Cell cell_d19000102 = s.getRow(11).getCell(0);
Cell cell_d19000100 = s.getRow(21).getCell(0);
assertEquals(s.getRow(0).getCell(3).getStringCellValue(), fmt.formatCellValue(cell_d20110325));
assertEquals(s.getRow(11).getCell(3).getStringCellValue(), fmt.formatCellValue(cell_d19000102));
// There is no such thing as 00/01/1900...
assertEquals("00/01/1900 06:14:24", s.getRow(21).getCell(3).getStringCellValue());
assertEquals("31/12/1899 06:14:24", fmt.formatCellValue(cell_d19000100));
// Check the cached values
assertEquals("HOUR(A1)", s.getRow(5).getCell(0).getCellFormula());
assertEquals(11.0, s.getRow(5).getCell(0).getNumericCellValue());
assertEquals("MINUTE(A1)", s.getRow(6).getCell(0).getCellFormula());
assertEquals(39.0, s.getRow(6).getCell(0).getNumericCellValue());
assertEquals("SECOND(A1)", s.getRow(7).getCell(0).getCellFormula());
assertEquals(54.0, s.getRow(7).getCell(0).getNumericCellValue());
// Re-evaulate and check
HSSFFormulaEvaluator.evaluateAllFormulaCells(wb);
assertEquals("HOUR(A1)", s.getRow(5).getCell(0).getCellFormula());
assertEquals(11.0, s.getRow(5).getCell(0).getNumericCellValue());
assertEquals("MINUTE(A1)", s.getRow(6).getCell(0).getCellFormula());
assertEquals(39.0, s.getRow(6).getCell(0).getNumericCellValue());
assertEquals("SECOND(A1)", s.getRow(7).getCell(0).getCellFormula());
assertEquals(54.0, s.getRow(7).getCell(0).getNumericCellValue());
// Push the time forward a bit and check
double date = s.getRow(0).getCell(0).getNumericCellValue();
s.getRow(0).getCell(0).setCellValue(date + 1.26);
HSSFFormulaEvaluator.evaluateAllFormulaCells(wb);
assertEquals("HOUR(A1)", s.getRow(5).getCell(0).getCellFormula());
assertEquals(11.0+6.0, s.getRow(5).getCell(0).getNumericCellValue());
assertEquals("MINUTE(A1)", s.getRow(6).getCell(0).getCellFormula());
assertEquals(39.0+14.0+1, s.getRow(6).getCell(0).getNumericCellValue());
assertEquals("SECOND(A1)", s.getRow(7).getCell(0).getCellFormula());
assertEquals(54.0+24.0-60, s.getRow(7).getCell(0).getNumericCellValue());
}
/**
* HLookup and VLookup with optional arguments
*/
public void test51024() throws Exception {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet s = wb.createSheet();
HSSFRow r1 = s.createRow(0);
HSSFRow r2 = s.createRow(1);
r1.createCell(0).setCellValue("v A1");
r2.createCell(0).setCellValue("v A2");
r1.createCell(1).setCellValue("v B1");
HSSFCell c = r1.createCell(4);
HSSFFormulaEvaluator eval = new HSSFFormulaEvaluator(wb);
c.setCellFormula("VLOOKUP(\"v A1\", A1:B2, 1)");
assertEquals("v A1", eval.evaluate(c).getStringValue());
c.setCellFormula("VLOOKUP(\"v A1\", A1:B2, 1, 1)");
assertEquals("v A1", eval.evaluate(c).getStringValue());
c.setCellFormula("VLOOKUP(\"v A1\", A1:B2, 1, )");
assertEquals("v A1", eval.evaluate(c).getStringValue());
c.setCellFormula("HLOOKUP(\"v A1\", A1:B2, 1)");
assertEquals("v A1", eval.evaluate(c).getStringValue());
c.setCellFormula("HLOOKUP(\"v A1\", A1:B2, 1, 1)");
assertEquals("v A1", eval.evaluate(c).getStringValue());
c.setCellFormula("HLOOKUP(\"v A1\", A1:B2, 1, )");
assertEquals("v A1", eval.evaluate(c).getStringValue());
}
/**
* Mixture of Ascii and Unicode strings in a
* NameComment record
*/
public void test51143() throws Exception {
HSSFWorkbook wb = openSample("51143.xls");
assertEquals(1, wb.getNumberOfSheets());
wb = writeOutAndReadBack(wb);
assertEquals(1, wb.getNumberOfSheets());
}
/**
* File with exactly 256 data blocks (+header block)
* shouldn't break on POIFS loading
*/
public void test51461() throws Exception {
byte[] data = HSSFITestDataProvider.instance.getTestDataFileContent("51461.xls");
HSSFWorkbook wbPOIFS = new HSSFWorkbook(new POIFSFileSystem(
new ByteArrayInputStream(data)).getRoot(), false);
HSSFWorkbook wbNPOIFS = new HSSFWorkbook(new NPOIFSFileSystem(
new ByteArrayInputStream(data)).getRoot(), false);
assertEquals(2, wbPOIFS.getNumberOfSheets());
assertEquals(2, wbNPOIFS.getNumberOfSheets());
}
/**
* Large row numbers and NPOIFS vs POIFS
*/
public void test51535() throws Exception {
byte[] data = HSSFITestDataProvider.instance.getTestDataFileContent("51535.xls");
HSSFWorkbook wbPOIFS = new HSSFWorkbook(new POIFSFileSystem(
new ByteArrayInputStream(data)).getRoot(), false);
HSSFWorkbook wbNPOIFS = new HSSFWorkbook(new NPOIFSFileSystem(
new ByteArrayInputStream(data)).getRoot(), false);
for(HSSFWorkbook wb : new HSSFWorkbook[] {wbPOIFS, wbNPOIFS}) {
assertEquals(3, wb.getNumberOfSheets());
// Check directly
HSSFSheet s = wb.getSheetAt(0);
assertEquals("Top Left Cell", s.getRow(0).getCell(0).getStringCellValue());
assertEquals("Top Right Cell", s.getRow(0).getCell(255).getStringCellValue());
assertEquals("Bottom Left Cell", s.getRow(65535).getCell(0).getStringCellValue());
assertEquals("Bottom Right Cell", s.getRow(65535).getCell(255).getStringCellValue());
// Extract and check
ExcelExtractor ex = new ExcelExtractor(wb);
String text = ex.getText();
assertTrue(text.contains("Top Left Cell"));
assertTrue(text.contains("Top Right Cell"));
assertTrue(text.contains("Bottom Left Cell"));
assertTrue(text.contains("Bottom Right Cell"));
}
}
public void test51670() {
HSSFWorkbook wb = openSample("51670.xls");
writeOutAndReadBack(wb);
}
}