{
/* Write the dictionary item in Unicode. */
int sLength = value.length() + 1;
- if (sLength % 2 == 1)
+ if ((sLength & 1) == 1) {
sLength++;
+ }
length += TypeWriter.writeUIntToStream(out, key.longValue());
length += TypeWriter.writeUIntToStream(out, sLength);
final byte[] ca = CodePageUtil.getBytesInCodePage(value, codepage);
import java.io.File;
import java.io.IOException;
-import java.util.Iterator;
import java.util.List;
import org.apache.poi.poifs.filesystem.NPOIFSFileSystem;
* @param args the names of the files to be displayed
*/
- public static void main(final String args[])
- {
- if (args.length < 0)
- {
+ public static void main(final String args[]) {
+ if (args.length == 0) {
System.err.println("Must specify at least one file to view");
System.exit(1);
}
}
}
- private static void viewFile(final String filename,
- final boolean printName)
- {
- if (printName)
- {
+ private static void viewFile(String filename, boolean printName) {
+ if (printName) {
StringBuffer flowerbox = new StringBuffer();
flowerbox.append(".");
- for (int j = 0; j < filename.length(); j++)
- {
+ for (int j = 0; j < filename.length(); j++) {
flowerbox.append("-");
}
flowerbox.append(".");
System.out.println("|" + filename + "|");
System.out.println(flowerbox);
}
- try
- {
- POIFSViewable fs =
- new NPOIFSFileSystem(new File(filename));
- List<String> strings = POIFSViewEngine.inspectViewable(fs, true,
- 0, " ");
- Iterator<String> iter = strings.iterator();
-
- while (iter.hasNext())
- {
- System.out.print(iter.next());
+ try {
+ NPOIFSFileSystem fs = new NPOIFSFileSystem(new File(filename));
+ List<String> strings = POIFSViewEngine.inspectViewable(fs, true, 0, " ");
+ for (String s : strings) {
+ System.out.print(s);
}
- }
- catch (IOException e)
- {
+ fs.close();
+ } catch (IOException e) {
System.out.println(e.getMessage());
}
}
/**
+ * Returns the font size which is either set directly on this text run or
+ * given from the slide layout
+ *
* @return font size in points or null if font size is not set.
*/
Double getFontSize();
/**
+ * Sets the font size directly on this text run, if null is given, the
+ * font size defaults to the values given from the slide layout
+ *
* @param fontSize font size in points, if null the underlying fontsize will be unset
*/
void setFontSize(Double fontSize);
*/
@Override
@Test
- public void cloneSheet() {
+ public void cloneSheet() throws IOException {
thrown.expect(RuntimeException.class);
thrown.expectMessage("NotImplemented");
super.cloneSheet();
@Override
@Test
- public void cloneSheetMultipleTimes() {
+ public void cloneSheetMultipleTimes() throws IOException {
thrown.expect(RuntimeException.class);
thrown.expectMessage("NotImplemented");
super.cloneSheetMultipleTimes();
*/
@Override
@Test
- public void shiftMerged(){
+ public void shiftMerged() throws IOException {
thrown.expect(RuntimeException.class);
thrown.expectMessage("NotImplemented");
super.shiftMerged();
*/
@Override
@Test
- public void bug35084(){
+ public void bug35084() throws IOException {
thrown.expect(RuntimeException.class);
thrown.expectMessage("NotImplemented");
super.bug35084();
sheet.createRow(2);
} finally {
wb.close();
+ template.close();
}
}
- @Test
- public void createRowAfterLastRow() {
+ @Test(expected=IllegalArgumentException.class)
+ public void createRowAfterLastRow() throws IOException {
createRowAfterLastRow(SpreadsheetVersion.EXCEL2007);
}
}
*/\r
package org.apache.poi.xssf.usermodel;\r
\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertNotNull;\r
+\r
+import java.io.IOException;\r
+\r
import org.apache.poi.ss.usermodel.BaseTestConditionalFormatting;\r
import org.apache.poi.ss.usermodel.Color;\r
import org.apache.poi.xssf.XSSFITestDataProvider;\r
+import org.junit.Test;\r
\r
/**\r
* XSSF-specific Conditional Formatting tests\r
}\r
}\r
\r
- public void testRead(){\r
+ @Test\r
+ public void testRead() throws IOException {\r
testRead("WithConditionalFormatting.xlsx");\r
}\r
\r
- public void testReadOffice2007() {\r
+ @Test\r
+ public void testReadOffice2007() throws IOException {\r
testReadOffice2007("NewStyleConditionalFormattings.xlsx");\r
}\r
}\r
package org.apache.poi.xssf.usermodel;
+import static org.junit.Assert.*;
+
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import org.apache.poi.ss.util.CellReference;
import org.apache.poi.xssf.XSSFITestDataProvider;
import org.apache.poi.xssf.XSSFTestDataSamples;
+import org.junit.Ignore;
+import org.junit.Test;
public final class TestXSSFFormulaEvaluation extends BaseTestFormulaEvaluator {
super(XSSFITestDataProvider.instance);
}
- public void testSharedFormulas(){
+ @Test
+ public void testSharedFormulas() throws IOException {
baseTestSharedFormulas("shared_formulas.xlsx");
}
- public void testSharedFormulas_evaluateInCell(){
+ @Test
+ public void testSharedFormulas_evaluateInCell() throws IOException {
XSSFWorkbook wb = (XSSFWorkbook)_testDataProvider.openSampleWorkbook("49872.xlsx");
FormulaEvaluator evaluator = wb.getCreationHelper().createFormulaEvaluator();
XSSFSheet sheet = wb.getSheetAt(0);
// get B3 and evaluate it in the cell
XSSFCell b3 = sheet.getRow(2).getCell(1);
- assertEquals(result, evaluator.evaluateInCell(b3).getNumericCellValue());
+ assertEquals(result, evaluator.evaluateInCell(b3).getNumericCellValue(), 0);
//at this point the master formula is gone, but we are still able to evaluate dependent cells
XSSFCell c3 = sheet.getRow(2).getCell(2);
- assertEquals(result, evaluator.evaluateInCell(c3).getNumericCellValue());
+ assertEquals(result, evaluator.evaluateInCell(c3).getNumericCellValue(), 0);
XSSFCell d3 = sheet.getRow(2).getCell(3);
- assertEquals(result, evaluator.evaluateInCell(d3).getNumericCellValue());
+ assertEquals(result, evaluator.evaluateInCell(d3).getNumericCellValue(), 0);
+
+ wb.close();
}
/**
* Evaluation of cell references with column indexes greater than 255. See bugzilla 50096
*/
- public void testEvaluateColumnGreaterThan255() {
+ @Test
+ public void testEvaluateColumnGreaterThan255() throws IOException {
XSSFWorkbook wb = (XSSFWorkbook) _testDataProvider.openSampleWorkbook("50096.xlsx");
XSSFFormulaEvaluator evaluator = wb.getCreationHelper().createFormulaEvaluator();
CellValue cv_noformula = evaluator.evaluate(cell_noformula);
CellValue cv_formula = evaluator.evaluate(cell_formula);
assertEquals("Wrong evaluation result in " + ref_formula.formatAsString(),
- cv_noformula.getNumberValue(), cv_formula.getNumberValue());
+ cv_noformula.getNumberValue(), cv_formula.getNumberValue(), 0);
}
+
+ wb.close();
}
/**
* formulas that refer to cells and named ranges in multiple other
* workbooks, both HSSF and XSSF ones
*/
+ @Test
public void testReferencesToOtherWorkbooks() throws Exception {
XSSFWorkbook wb = (XSSFWorkbook) _testDataProvider.openSampleWorkbook("ref2-56737.xlsx");
XSSFFormulaEvaluator evaluator = wb.getCreationHelper().createFormulaEvaluator();
assertEquals("Hello!", cXSLX_cell.getStringCellValue());
assertEquals("Test A1", cXSLX_sNR.getStringCellValue());
- assertEquals(142.0, cXSLX_gNR.getNumericCellValue());
+ assertEquals(142.0, cXSLX_gNR.getNumericCellValue(), 0);
// References to a .xls file
Row rXSL = s.getRow(4);
assertEquals("Hello!", cXSL_cell.getStringCellValue());
assertEquals("Test A1", cXSL_sNR.getStringCellValue());
- assertEquals(142.0, cXSL_gNR.getNumericCellValue());
+ assertEquals(142.0, cXSL_gNR.getNumericCellValue(), 0);
// Try to evaluate without references, won't work
// (At least, not unit we fix bug #56752 that is)
} finally {
alt.close();
}
+
+ wb.close();
}
/**
* TODO Add the support then add a unit test
* See bug #56752
*/
- public void TODOtestCachedReferencesToOtherWorkbooks() throws Exception {
+ @Test
+ @Ignore
+ public void testCachedReferencesToOtherWorkbooks() throws Exception {
// TODO
}
* This test, based on common test files for HSSF and XSSF, checks
* that we can correctly evaluate these
*/
+ @Test
public void testMultiSheetReferencesHSSFandXSSF() throws Exception {
- Workbook[] wbs = new Workbook[] {
- HSSFTestDataSamples.openSampleWorkbook("55906-MultiSheetRefs.xls"),
- XSSFTestDataSamples.openSampleWorkbook("55906-MultiSheetRefs.xlsx")
- };
- for (Workbook wb : wbs) {
+ Workbook wb1 = HSSFTestDataSamples.openSampleWorkbook("55906-MultiSheetRefs.xls");
+ Workbook wb2 = XSSFTestDataSamples.openSampleWorkbook("55906-MultiSheetRefs.xlsx");
+
+ for (Workbook wb : new Workbook[] {wb1,wb2}) {
FormulaEvaluator evaluator = wb.getCreationHelper().createFormulaEvaluator();
Sheet s1 = wb.getSheetAt(0);
assertEquals("COUNTA(Sheet1:Sheet3!E1)", countA_3F.getCellFormula());
assertEquals("3.0", evaluator.evaluate(countA_3F).formatAsString());
}
+
+ wb2.close();
+ wb1.close();
}
+
/**
* A handful of functions (such as SUM, COUNTA, MIN) support
* multi-sheet areas (eg Sheet1:Sheet3!A1:B2 = Cell A1 to Cell B2,
* This test, based on common test files for HSSF and XSSF, checks
* that we can correctly evaluate these
*/
- public void testMultiSheetAreasHSSFandXSSF() throws Exception {
- Workbook[] wbs = new Workbook[] {
- HSSFTestDataSamples.openSampleWorkbook("55906-MultiSheetRefs.xls"),
- XSSFTestDataSamples.openSampleWorkbook("55906-MultiSheetRefs.xlsx")
- };
- for (Workbook wb : wbs) {
+ @Test
+ public void testMultiSheetAreasHSSFandXSSF() throws IOException {
+ Workbook wb1 = HSSFTestDataSamples.openSampleWorkbook("55906-MultiSheetRefs.xls");
+ Workbook wb2 = XSSFTestDataSamples.openSampleWorkbook("55906-MultiSheetRefs.xlsx");
+
+ for (Workbook wb : new Workbook[]{wb1,wb2}) {
FormulaEvaluator evaluator = wb.getCreationHelper().createFormulaEvaluator();
Sheet s1 = wb.getSheetAt(0);
assertEquals("COUNT(Sheet1:Sheet3!$A$1:$B$2)", countFA.getCellFormula());
assertEquals("4.0", evaluator.evaluate(countFA).formatAsString());
}
+
+ wb2.close();
+ wb1.close();
}
+ @Test
public void testMultisheetFormulaEval() throws IOException {
XSSFWorkbook wb = new XSSFWorkbook();
try {
wb.getCreationHelper().createFormulaEvaluator().evaluateAll();
cell = sheet1.getRow(1).getCell(0);
- assertEquals(3.0, cell.getNumericCellValue());
+ assertEquals(3.0, cell.getNumericCellValue(), 0);
cell = sheet1.getRow(2).getCell(0);
- assertEquals(4.0, cell.getNumericCellValue());
+ assertEquals(4.0, cell.getNumericCellValue(), 0);
} finally {
wb.close();
}
}
+ @Test
public void testBug55843() throws IOException {
XSSFWorkbook wb = new XSSFWorkbook();
try {
XSSFFormulaEvaluator formulaEvaluator = wb.getCreationHelper().createFormulaEvaluator();
cellA2.setCellFormula("IF(B1=0,\"\",((ROW()-ROW(A$1))*12))");
CellValue evaluate = formulaEvaluator.evaluate(cellA2);
- System.out.println(evaluate);
assertEquals("12.0", evaluate.formatAsString());
cellA2.setCellFormula("IF(NOT(B1=0),((ROW()-ROW(A$1))*12),\"\")");
CellValue evaluateN = formulaEvaluator.evaluate(cellA2);
- System.out.println(evaluateN);
assertEquals(evaluate.toString(), evaluateN.toString());
assertEquals("12.0", evaluateN.formatAsString());
}
}
+ @Test
public void testBug55843a() throws IOException {
XSSFWorkbook wb = new XSSFWorkbook();
try {
XSSFFormulaEvaluator formulaEvaluator = wb.getCreationHelper().createFormulaEvaluator();
cellA2.setCellFormula("IF(B1=0,\"\",((ROW(A$1))))");
CellValue evaluate = formulaEvaluator.evaluate(cellA2);
- System.out.println(evaluate);
assertEquals("1.0", evaluate.formatAsString());
cellA2.setCellFormula("IF(NOT(B1=0),((ROW(A$1))),\"\")");
CellValue evaluateN = formulaEvaluator.evaluate(cellA2);
- System.out.println(evaluateN);
assertEquals(evaluate.toString(), evaluateN.toString());
assertEquals("1.0", evaluateN.formatAsString());
}
}
+ @Test
public void testBug55843b() throws IOException {
XSSFWorkbook wb = new XSSFWorkbook();
try {
cellA2.setCellFormula("IF(B1=0,\"\",((ROW())))");
CellValue evaluate = formulaEvaluator.evaluate(cellA2);
- System.out.println(evaluate);
assertEquals("2.0", evaluate.formatAsString());
cellA2.setCellFormula("IF(NOT(B1=0),((ROW())),\"\")");
CellValue evaluateN = formulaEvaluator.evaluate(cellA2);
- System.out.println(evaluateN);
assertEquals(evaluate.toString(), evaluateN.toString());
assertEquals("2.0", evaluateN.formatAsString());
}
}
+ @Test
public void testBug55843c() throws IOException {
XSSFWorkbook wb = new XSSFWorkbook();
try {
cellA2.setCellFormula("IF(NOT(B1=0),((ROW())))");
CellValue evaluateN = formulaEvaluator.evaluate(cellA2);
- System.out.println(evaluateN);
assertEquals("2.0", evaluateN.formatAsString());
} finally {
wb.close();
}
}
+ @Test
public void testBug55843d() throws IOException {
XSSFWorkbook wb = new XSSFWorkbook();
try {
cellA2.setCellFormula("IF(NOT(B1=0),((ROW())),\"\")");
CellValue evaluateN = formulaEvaluator.evaluate(cellA2);
- System.out.println(evaluateN);
assertEquals("2.0", evaluateN.formatAsString());
} finally {
wb.close();
}
}
+ @Test
public void testBug55843e() throws IOException {
XSSFWorkbook wb = new XSSFWorkbook();
try {
cellA2.setCellFormula("IF(B1=0,\"\",((ROW())))");
CellValue evaluate = formulaEvaluator.evaluate(cellA2);
- System.out.println(evaluate);
assertEquals("2.0", evaluate.formatAsString());
} finally {
wb.close();
}
}
+ @Test
public void testBug55843f() throws IOException {
XSSFWorkbook wb = new XSSFWorkbook();
try {
cellA2.setCellFormula("IF(B1=0,\"\",IF(B1=10,3,4))");
CellValue evaluate = formulaEvaluator.evaluate(cellA2);
- System.out.println(evaluate);
assertEquals("3.0", evaluate.formatAsString());
} finally {
wb.close();
}
}
+ @Test
public void testBug56655() throws IOException {
Workbook wb = new XSSFWorkbook();
Sheet sheet = wb.createSheet();
wb.close();
}
+ @Test
public void testBug56655a() throws IOException {
Workbook wb = new XSSFWorkbook();
Sheet sheet = wb.createSheet();
package org.apache.poi.xssf.usermodel;
-import static junit.framework.TestCase.assertNotNull;
-import static junit.framework.TestCase.assertTrue;
import static org.apache.poi.xssf.XSSFTestDataSamples.openSampleWorkbook;
import static org.apache.poi.xssf.XSSFTestDataSamples.writeOutAndReadBack;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
import java.io.IOException;
import java.util.Arrays;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.helpers.ColumnHelper;
import org.junit.Test;
-import org.openxmlformats.schemas.spreadsheetml.x2006.main.*;
+import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTCalcPr;
+import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTCell;
+import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTCol;
+import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTCols;
+import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTComments;
+import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTRow;
+import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTSheetData;
+import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTSheetProtection;
+import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTWorksheet;
+import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTXf;
+import org.openxmlformats.schemas.spreadsheetml.x2006.main.STCalcMode;
+import org.openxmlformats.schemas.spreadsheetml.x2006.main.STPane;
@SuppressWarnings("resource")
}
@Test
- public void getSetMargin() {
+ public void getSetMargin() throws IOException {
baseTestGetSetMargin(new double[]{0.7, 0.7, 0.75, 0.75, 0.3, 0.3});
}
@Test
- public void existingHeaderFooter() {
- XSSFWorkbook workbook = XSSFTestDataSamples.openSampleWorkbook("45540_classic_Header.xlsx");
+ public void existingHeaderFooter() throws IOException {
+ XSSFWorkbook wb1 = XSSFTestDataSamples.openSampleWorkbook("45540_classic_Header.xlsx");
XSSFOddHeader hdr;
XSSFOddFooter ftr;
// Sheet 1 has a header with center and right text
- XSSFSheet s1 = workbook.getSheetAt(0);
+ XSSFSheet s1 = wb1.getSheetAt(0);
assertNotNull(s1.getHeader());
assertNotNull(s1.getFooter());
hdr = (XSSFOddHeader) s1.getHeader();
assertEquals("", ftr.getRight());
// Sheet 2 has a footer, but it's empty
- XSSFSheet s2 = workbook.getSheetAt(1);
+ XSSFSheet s2 = wb1.getSheetAt(1);
assertNotNull(s2.getHeader());
assertNotNull(s2.getFooter());
hdr = (XSSFOddHeader) s2.getHeader();
assertEquals("", ftr.getRight());
// Save and reload
- XSSFWorkbook wb = XSSFTestDataSamples.writeOutAndReadBack(workbook);
+ XSSFWorkbook wb2 = XSSFTestDataSamples.writeOutAndReadBack(wb1);
+ wb1.close();
- hdr = (XSSFOddHeader) wb.getSheetAt(0).getHeader();
- ftr = (XSSFOddFooter) wb.getSheetAt(0).getFooter();
+ hdr = (XSSFOddHeader) wb2.getSheetAt(0).getHeader();
+ ftr = (XSSFOddFooter) wb2.getSheetAt(0).getFooter();
assertEquals("", hdr.getLeft());
assertEquals("testdoc", hdr.getCenter());
assertEquals("", ftr.getLeft());
assertEquals("", ftr.getCenter());
assertEquals("", ftr.getRight());
+
+ wb2.close();
}
@Test
- public void getAllHeadersFooters() {
+ public void getAllHeadersFooters() throws IOException {
XSSFWorkbook workbook = new XSSFWorkbook();
XSSFSheet sheet = workbook.createSheet("Sheet 1");
assertNotNull(sheet.getOddFooter());
// Defaults are odd
assertEquals("odd footer left", sheet.getFooter().getLeft());
assertEquals("odd header center", sheet.getHeader().getCenter());
+
+ workbook.close();
}
@Test
- public void autoSizeColumn() {
+ public void autoSizeColumn() throws IOException {
XSSFWorkbook workbook = new XSSFWorkbook();
XSSFSheet sheet = workbook.createSheet("Sheet 1");
sheet.createRow(0).createCell(13).setCellValue("test");
ColumnHelper columnHelper = sheet.getColumnHelper();
CTCol col = columnHelper.getColumn(13, false);
assertTrue(col.getBestFit());
+ workbook.close();
}
@Test
- public void setCellComment() {
+ public void setCellComment() throws IOException {
XSSFWorkbook workbook = new XSSFWorkbook();
XSSFSheet sheet = workbook.createSheet();
assertEquals("A1", ctComments.getCommentList().getCommentArray(0).getRef());
comment.setAuthor("test A1 author");
assertEquals("test A1 author", comments.getAuthor((int) ctComments.getCommentList().getCommentArray(0).getAuthorId()));
+ workbook.close();
}
@Test
- public void getActiveCell() {
+ public void getActiveCell() throws IOException {
XSSFWorkbook workbook = new XSSFWorkbook();
XSSFSheet sheet = workbook.createSheet();
sheet.setActiveCell("R5");
assertEquals("R5", sheet.getActiveCell());
-
+ workbook.close();
}
@Test
- public void createFreezePane_XSSF() {
+ public void createFreezePane_XSSF() throws IOException {
XSSFWorkbook workbook = new XSSFWorkbook();
XSSFSheet sheet = workbook.createSheet();
CTWorksheet ctWorksheet = sheet.getCTWorksheet();
sheet.createSplitPane(4, 8, 12, 12, 1);
assertEquals(8.0, ctWorksheet.getSheetViews().getSheetViewArray(0).getPane().getYSplit(), 0.0);
assertEquals(STPane.BOTTOM_RIGHT, ctWorksheet.getSheetViews().getSheetViewArray(0).getPane().getActivePane());
+
+ workbook.close();
}
@Test
- public void removeMergedRegion_lowlevel() {
+ public void removeMergedRegion_lowlevel() throws IOException {
XSSFWorkbook workbook = new XSSFWorkbook();
XSSFSheet sheet = workbook.createSheet();
CTWorksheet ctWorksheet = sheet.getCTWorksheet();
sheet.removeMergedRegions(rmIdx);
assertEquals("A1:B2", ctWorksheet.getMergeCells().getMergeCellArray(0).getRef());
assertEquals("E5:F6", ctWorksheet.getMergeCells().getMergeCellArray(1).getRef());
+ workbook.close();
}
@Test
- public void setDefaultColumnStyle() {
+ public void setDefaultColumnStyle() throws IOException {
XSSFWorkbook workbook = new XSSFWorkbook();
XSSFSheet sheet = workbook.createSheet();
CTWorksheet ctWorksheet = sheet.getCTWorksheet();
sheet.setDefaultColumnStyle(3, cellStyle);
assertEquals(1, ctWorksheet.getColsArray(0).getColArray(0).getStyle());
+ workbook.close();
}
@Test
@SuppressWarnings("deprecation")
- public void groupUngroupColumn() {
+ public void groupUngroupColumn() throws IOException {
XSSFWorkbook workbook = new XSSFWorkbook();
XSSFSheet sheet = workbook.createSheet();
colArray = cols.getColArray();
assertEquals(4, colArray.length);
assertEquals(2, sheet.getCTWorksheet().getSheetFormatPr().getOutlineLevelCol());
+
+ workbook.close();
}
@Test
- public void groupUngroupRow() {
+ public void groupUngroupRow() throws IOException {
XSSFWorkbook workbook = new XSSFWorkbook();
XSSFSheet sheet = workbook.createSheet();
assertEquals(3, sheet.getPhysicalNumberOfRows());
assertEquals(1, sheet.getCTWorksheet().getSheetFormatPr().getOutlineLevelRow());
+
+ workbook.close();
}
- @Test
- public void setZoom() {
+ @Test(expected=IllegalArgumentException.class)
+ public void setZoom() throws IOException {
XSSFWorkbook workBook = new XSSFWorkbook();
XSSFSheet sheet1 = workBook.createSheet("new sheet");
sheet1.setZoom(3, 4); // 75 percent magnification
zoom = sheet1.getCTWorksheet().getSheetViews().getSheetViewArray(0).getZoomScale();
assertEquals(zoom, 200);
+ // Valid scale values range from 10 to 400
try {
sheet1.setZoom(500);
- fail("Expecting exception");
- } catch (IllegalArgumentException e) {
- assertEquals("Valid scale values range from 10 to 400", e.getMessage());
+ } finally {
+ workBook.close();
}
}
* better should really review this!
*/
@Test
- public void setColumnGroupCollapsed(){
+ public void setColumnGroupCollapsed() throws IOException {
Workbook wb = new XSSFWorkbook();
XSSFSheet sheet1 =(XSSFSheet) wb.createSheet();
assertEquals(false,cols.getColArray(5).isSetCollapsed());
assertEquals(14, cols.getColArray(5).getMin()); // 1 based
assertEquals(14, cols.getColArray(5).getMax()); // 1 based
+
+ wb.close();
}
/**
* better should really review this!
*/
@Test
- public void setRowGroupCollapsed(){
+ public void setRowGroupCollapsed() throws IOException {
Workbook wb = new XSSFWorkbook();
XSSFSheet sheet1 = (XSSFSheet)wb.createSheet();
sheet1.groupRow( 16, 19 );
assertEquals(14,sheet1.getPhysicalNumberOfRows());
- assertEquals(false,sheet1.getRow(6).getCTRow().isSetCollapsed());
- assertEquals(false,sheet1.getRow(6).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(7).getCTRow().isSetCollapsed());
- assertEquals(false,sheet1.getRow(7).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(9).getCTRow().isSetCollapsed());
- assertEquals(false,sheet1.getRow(9).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(14).getCTRow().isSetCollapsed());
- assertEquals(false,sheet1.getRow(14).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(16).getCTRow().isSetCollapsed());
- assertEquals(false,sheet1.getRow(16).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(18).getCTRow().isSetCollapsed());
- assertEquals(false,sheet1.getRow(18).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(6).getCTRow().isSetCollapsed());
+ assertFalse(sheet1.getRow(6).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(7).getCTRow().isSetCollapsed());
+ assertFalse(sheet1.getRow(7).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(9).getCTRow().isSetCollapsed());
+ assertFalse(sheet1.getRow(9).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(14).getCTRow().isSetCollapsed());
+ assertFalse(sheet1.getRow(14).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(16).getCTRow().isSetCollapsed());
+ assertFalse(sheet1.getRow(16).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(18).getCTRow().isSetCollapsed());
+ assertFalse(sheet1.getRow(18).getCTRow().isSetHidden());
//collapsed
sheet1.setRowGroupCollapsed( 7, true );
- assertEquals(false,sheet1.getRow(6).getCTRow().isSetCollapsed());
- assertEquals(false,sheet1.getRow(6).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(7).getCTRow().isSetCollapsed());
- assertEquals(true, sheet1.getRow(7).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(9).getCTRow().isSetCollapsed());
- assertEquals(true, sheet1.getRow(9).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(14).getCTRow().isSetCollapsed());
- assertEquals(true, sheet1.getRow(14).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(16).getCTRow().isSetCollapsed());
- assertEquals(false,sheet1.getRow(16).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(18).getCTRow().isSetCollapsed());
- assertEquals(false,sheet1.getRow(18).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(6).getCTRow().isSetCollapsed());
+ assertFalse(sheet1.getRow(6).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(7).getCTRow().isSetCollapsed());
+ assertTrue (sheet1.getRow(7).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(9).getCTRow().isSetCollapsed());
+ assertTrue (sheet1.getRow(9).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(14).getCTRow().isSetCollapsed());
+ assertTrue (sheet1.getRow(14).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(16).getCTRow().isSetCollapsed());
+ assertFalse(sheet1.getRow(16).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(18).getCTRow().isSetCollapsed());
+ assertFalse(sheet1.getRow(18).getCTRow().isSetHidden());
//expanded
sheet1.setRowGroupCollapsed( 7, false );
- assertEquals(false,sheet1.getRow(6).getCTRow().isSetCollapsed());
- assertEquals(false,sheet1.getRow(6).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(7).getCTRow().isSetCollapsed());
- assertEquals(true, sheet1.getRow(7).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(9).getCTRow().isSetCollapsed());
- assertEquals(true, sheet1.getRow(9).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(14).getCTRow().isSetCollapsed());
- assertEquals(true, sheet1.getRow(14).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(16).getCTRow().isSetCollapsed());
- assertEquals(false,sheet1.getRow(16).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(18).getCTRow().isSetCollapsed());
- assertEquals(false,sheet1.getRow(18).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(6).getCTRow().isSetCollapsed());
+ assertFalse(sheet1.getRow(6).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(7).getCTRow().isSetCollapsed());
+ assertTrue (sheet1.getRow(7).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(9).getCTRow().isSetCollapsed());
+ assertTrue (sheet1.getRow(9).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(14).getCTRow().isSetCollapsed());
+ assertTrue (sheet1.getRow(14).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(16).getCTRow().isSetCollapsed());
+ assertFalse(sheet1.getRow(16).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(18).getCTRow().isSetCollapsed());
+ assertFalse(sheet1.getRow(18).getCTRow().isSetHidden());
// Save and re-load
wb = XSSFTestDataSamples.writeOutAndReadBack(wb);
sheet1 = (XSSFSheet)wb.getSheetAt(0);
- assertEquals(false,sheet1.getRow(6).getCTRow().isSetCollapsed());
- assertEquals(false,sheet1.getRow(6).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(7).getCTRow().isSetCollapsed());
- assertEquals(true, sheet1.getRow(7).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(9).getCTRow().isSetCollapsed());
- assertEquals(true, sheet1.getRow(9).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(14).getCTRow().isSetCollapsed());
- assertEquals(true, sheet1.getRow(14).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(16).getCTRow().isSetCollapsed());
- assertEquals(false,sheet1.getRow(16).getCTRow().isSetHidden());
- assertEquals(false,sheet1.getRow(18).getCTRow().isSetCollapsed());
- assertEquals(false,sheet1.getRow(18).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(6).getCTRow().isSetCollapsed());
+ assertFalse(sheet1.getRow(6).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(7).getCTRow().isSetCollapsed());
+ assertTrue (sheet1.getRow(7).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(9).getCTRow().isSetCollapsed());
+ assertTrue (sheet1.getRow(9).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(14).getCTRow().isSetCollapsed());
+ assertTrue (sheet1.getRow(14).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(16).getCTRow().isSetCollapsed());
+ assertFalse(sheet1.getRow(16).getCTRow().isSetHidden());
+ assertFalse(sheet1.getRow(18).getCTRow().isSetCollapsed());
+ assertFalse(sheet1.getRow(18).getCTRow().isSetHidden());
+
+ wb.close();
}
/**
* Get / Set column width and check the actual values of the underlying XML beans
*/
@Test
- public void columnWidth_lowlevel() {
+ public void columnWidth_lowlevel() throws IOException {
XSSFWorkbook workbook = new XSSFWorkbook();
XSSFSheet sheet = workbook.createSheet("Sheet 1");
sheet.setColumnWidth(1, 22 * 256);
assertEquals(4, col.getMax());
assertEquals(33.0, col.getWidth(), 0.0);
assertTrue(col.getCustomWidth());
+
+ workbook.close();
}
/**
* Setting width of a column included in a column span
*/
@Test
- public void bug47862() {
+ public void bug47862() throws IOException {
XSSFWorkbook wb = XSSFTestDataSamples.openSampleWorkbook("47862.xlsx");
XSSFSheet sheet = wb.getSheetAt(0);
CTCols cols = sheet.getCTWorksheet().getColsArray(0);
assertEquals(cw[i]*256, sheet.getColumnWidth(i));
assertEquals(cw[i], cols.getColArray(i).getWidth(), 0.0);
}
+
+ wb.close();
}
/**
* Hiding a column included in a column span
*/
@Test
- public void bug47804() {
+ public void bug47804() throws IOException {
XSSFWorkbook wb = XSSFTestDataSamples.openSampleWorkbook("47804.xlsx");
XSSFSheet sheet = wb.getSheetAt(0);
CTCols cols = sheet.getCTWorksheet().getColsArray(0);
assertFalse(sheet.isColumnHidden(3));
assertFalse(sheet.isColumnHidden(4));
assertFalse(sheet.isColumnHidden(5));
+
+ wb.close();
}
@Test
- public void commentsTable() {
+ public void commentsTable() throws IOException {
XSSFWorkbook workbook = new XSSFWorkbook();
XSSFSheet sheet1 = workbook.createSheet();
CommentsTable comment1 = sheet1.getCommentsTable(false);
assertNotNull(comment1);
assertEquals("/xl/comments1.xml", comment1.getPackageRelationship().getTargetURI().toString());
assertSame(comment1, sheet1.getCommentsTable(true));
+
+ workbook.close();
}
/**
@Override
@Test
@SuppressWarnings("deprecation")
- public void createRow() {
+ public void createRow() throws IOException {
XSSFWorkbook workbook = new XSSFWorkbook();
XSSFSheet sheet = workbook.createSheet();
CTWorksheet wsh = sheet.getCTWorksheet();
assertEquals(2, xrow[2].sizeOfCArray());
assertEquals(3, xrow[2].getR());
+ workbook.close();
}
- @Test
- public void createRowAfterLastRow() {
+ @Test(expected=IllegalArgumentException.class)
+ public void createRowAfterLastRow() throws IOException {
createRowAfterLastRow(SpreadsheetVersion.EXCEL2007);
}
@Test
- public void setAutoFilter() {
+ public void setAutoFilter() throws IOException {
XSSFWorkbook wb = new XSSFWorkbook();
XSSFSheet sheet = wb.createSheet("new sheet");
sheet.setAutoFilter(CellRangeAddress.valueOf("A1:D100"));
assertEquals(true, nm.getCTName().getHidden());
assertEquals("_xlnm._FilterDatabase", nm.getCTName().getName());
assertEquals("'new sheet'!$A$1:$D$100", nm.getCTName().getStringValue());
+
+ wb.close();
}
@Test
- public void protectSheet_lowlevel() {
+ public void protectSheet_lowlevel() throws IOException {
XSSFWorkbook wb = new XSSFWorkbook();
XSSFSheet sheet = wb.createSheet();
CTSheetProtection pr = sheet.getCTWorksheet().getSheetProtection();
sheet.protectSheet(null);
assertNull("protectSheet(null) should unset CTSheetProtection", sheet.getCTWorksheet().getSheetProtection());
+
+ wb.close();
}
@Test
- public void protectSheet_lowlevel_2013() {
+ public void protectSheet_lowlevel_2013() throws IOException {
String password = "test";
XSSFWorkbook wb = new XSSFWorkbook();
XSSFSheet xs = wb.createSheet();
wb = openSampleWorkbook("workbookProtection-sheet_password-2013.xlsx");
assertTrue(wb.getSheetAt(0).validateSheetPassword("pwd"));
+
+ wb.close();
}
@Test
- public void bug49966() {
- XSSFWorkbook wb = XSSFTestDataSamples.openSampleWorkbook("49966.xlsx");
- CalculationChain calcChain = wb.getCalculationChain();
- assertNotNull(wb.getCalculationChain());
+ public void bug49966() throws IOException {
+ XSSFWorkbook wb1 = XSSFTestDataSamples.openSampleWorkbook("49966.xlsx");
+ CalculationChain calcChain = wb1.getCalculationChain();
+ assertNotNull(wb1.getCalculationChain());
assertEquals(3, calcChain.getCTCalcChain().sizeOfCArray());
- XSSFSheet sheet = wb.getSheetAt(0);
+ XSSFSheet sheet = wb1.getSheetAt(0);
XSSFRow row = sheet.getRow(0);
sheet.removeRow(row);
0, calcChain.getCTCalcChain().sizeOfCArray());
//calcChain should be gone
- wb = XSSFTestDataSamples.writeOutAndReadBack(wb);
- assertNull(wb.getCalculationChain());
-
+ XSSFWorkbook wb2 = XSSFTestDataSamples.writeOutAndReadBack(wb1);
+ wb1.close();
+ assertNull(wb2.getCalculationChain());
+ wb2.close();
}
/**
* See bug #50829
*/
@Test
- public void tables() {
+ public void tables() throws IOException {
XSSFWorkbook wb = XSSFTestDataSamples.openSampleWorkbook("WithTable.xlsx");
assertEquals(3, wb.getNumberOfSheets());
assertEquals(0, s2.getTables().size());
XSSFSheet s3 = wb.getSheetAt(2);
assertEquals(0, s3.getTables().size());
+ wb.close();
}
/**
* Test to trigger OOXML-LITE generating to include org.openxmlformats.schemas.spreadsheetml.x2006.main.CTSheetCalcPr
*/
@Test
- public void setForceFormulaRecalculation() {
- XSSFWorkbook workbook = new XSSFWorkbook();
- XSSFSheet sheet = workbook.createSheet("Sheet 1");
+ public void setForceFormulaRecalculation() throws IOException {
+ XSSFWorkbook wb1 = new XSSFWorkbook();
+ XSSFSheet sheet = wb1.createSheet("Sheet 1");
assertFalse(sheet.getForceFormulaRecalculation());
assertEquals(true, sheet.getForceFormulaRecalculation());
// calcMode="manual" is unset when forceFormulaRecalculation=true
- CTCalcPr calcPr = workbook.getCTWorkbook().addNewCalcPr();
+ CTCalcPr calcPr = wb1.getCTWorkbook().addNewCalcPr();
calcPr.setCalcMode(STCalcMode.MANUAL);
sheet.setForceFormulaRecalculation(true);
assertEquals(STCalcMode.AUTO, calcPr.getCalcMode());
// Save, re-load, and re-check
- workbook = XSSFTestDataSamples.writeOutAndReadBack(workbook);
- sheet = workbook.getSheet("Sheet 1");
+ XSSFWorkbook wb2 = XSSFTestDataSamples.writeOutAndReadBack(wb1);
+ wb1.close();
+ sheet = wb2.getSheet("Sheet 1");
assertEquals(false, sheet.getForceFormulaRecalculation());
+ wb2.close();
}
@Test
}*/
assertEquals("Sheet should contain 8 tables", 8, tables.size());
assertNotNull("Sheet should contain a comments table", sheet.getCommentsTable(false));
+ wb.close();
}
@Test
- public void bug55723b(){
+ public void bug55723b() throws IOException {
XSSFWorkbook wb = new XSSFWorkbook();
Sheet sheet = wb.createSheet();
name = wb.getBuiltInName(XSSFName.BUILTIN_FILTER_DB, 0);
assertNotNull(name);
assertEquals("Sheet0!$B:$C", name.getRefersToFormula());
+
+ wb.close();
}
@Test(timeout=180000)
- public void bug51585(){
- XSSFTestDataSamples.openSampleWorkbook("51585.xlsx");
+ public void bug51585() throws IOException {
+ XSSFTestDataSamples.openSampleWorkbook("51585.xlsx").close();;
}
private XSSFWorkbook setupSheet(){
}
@Test
- public void testCreateTwoPivotTablesInOneSheet(){
+ public void testCreateTwoPivotTablesInOneSheet() throws IOException {
XSSFWorkbook wb = setupSheet();
XSSFSheet sheet = wb.getSheetAt(0);
XSSFPivotTable pivotTable2 = sheet.createPivotTable(new AreaReference("A1:B2"), new CellReference("L5"), sheet);
assertNotNull(pivotTable2);
assertTrue(wb.getPivotTables().size() > 1);
+ wb.close();
}
@Test
- public void testCreateTwoPivotTablesInTwoSheets(){
+ public void testCreateTwoPivotTablesInTwoSheets() throws IOException {
XSSFWorkbook wb = setupSheet();
XSSFSheet sheet = wb.getSheetAt(0);
XSSFPivotTable pivotTable2 = sheet2.createPivotTable(new AreaReference("A1:B2"), new CellReference("H5"), sheet);
assertNotNull(pivotTable2);
assertTrue(wb.getPivotTables().size() > 1);
+ wb.close();
}
@Test
- public void testCreatePivotTable(){
+ public void testCreatePivotTable() throws IOException {
XSSFWorkbook wb = setupSheet();
XSSFSheet sheet = wb.getSheetAt(0);
XSSFPivotTable pivotTable = sheet.createPivotTable(new AreaReference("A1:B2"), new CellReference("H5"));
assertNotNull(pivotTable);
assertTrue(wb.getPivotTables().size() > 0);
+ wb.close();
}
@Test
- public void testCreatePivotTableInOtherSheetThanDataSheet(){
+ public void testCreatePivotTableInOtherSheetThanDataSheet() throws IOException {
XSSFWorkbook wb = setupSheet();
XSSFSheet sheet1 = wb.getSheetAt(0);
XSSFSheet sheet2 = wb.createSheet();
assertEquals(1, wb.getPivotTables().size());
assertEquals(0, sheet1.getPivotTables().size());
assertEquals(1, sheet2.getPivotTables().size());
+ wb.close();
}
@Test
- public void testCreatePivotTableInOtherSheetThanDataSheetUsingAreaReference(){
+ public void testCreatePivotTableInOtherSheetThanDataSheetUsingAreaReference() throws IOException {
XSSFWorkbook wb = setupSheet();
XSSFSheet sheet = wb.getSheetAt(0);
XSSFSheet sheet2 = wb.createSheet();
XSSFPivotTable pivotTable = sheet2.createPivotTable
(new AreaReference(sheet.getSheetName()+"!A$1:B$2"), new CellReference("H5"));
assertEquals(0, pivotTable.getRowLabelColumns().size());
+ wb.close();
}
- @Test
- public void testCreatePivotTableWithConflictingDataSheets(){
+ @Test(expected=IllegalArgumentException.class)
+ public void testCreatePivotTableWithConflictingDataSheets() throws IOException {
XSSFWorkbook wb = setupSheet();
XSSFSheet sheet = wb.getSheetAt(0);
XSSFSheet sheet2 = wb.createSheet();
- try {
- sheet2.createPivotTable(new AreaReference(sheet.getSheetName()+"!A$1:B$2"), new CellReference("H5"), sheet2);
- } catch(IllegalArgumentException e) {
- return;
- }
- fail();
+ sheet2.createPivotTable(new AreaReference(sheet.getSheetName()+"!A$1:B$2"), new CellReference("H5"), sheet2);
}
- @Test
- public void testReadFails() {
+ @Test(expected=POIXMLException.class)
+ public void testReadFails() throws IOException {
XSSFWorkbook wb = new XSSFWorkbook();
XSSFSheet sheet = wb.createSheet();
- try {
- sheet.onDocumentRead();
- fail("Throws exception because we cannot read here");
- } catch (POIXMLException e) {
- // expected here
- }
+ // Throws exception because we cannot read here
+ sheet.onDocumentRead();
}
@SuppressWarnings("deprecation")
@Test
- public void testCreateComment() {
+ public void testCreateComment() throws IOException {
XSSFWorkbook wb = new XSSFWorkbook();
XSSFSheet sheet = wb.createSheet();
assertNotNull(sheet.createComment());
+ wb.close();
}
@Test
- public void testNoMergedRegionsIsEmptyList() {
+ public void testNoMergedRegionsIsEmptyList() throws IOException {
XSSFWorkbook wb = new XSSFWorkbook();
XSSFSheet sheet = wb.createSheet();
assertTrue(sheet.getMergedRegions().isEmpty());
+ wb.close();
}
}
\ No newline at end of file
// the upx will always start on a word boundary.
- if(upxSize % 2 == 1)
+ if((upxSize & 1) == 1)
{
++varOffset;
}
//byte hpsPos = (byte)((param & 0xff0000) >>> 8);
byte hpsPos = (byte) ((operand & 0xff0000) >>> 16);
- if (hpsPos != 0x80)
+ if (hpsPos != (byte)0x80)
{
newCHP.setHpsPos (hpsPos);
}
package org.apache.poi.hssf.usermodel;
+import static org.junit.Assert.*;
import java.io.FileNotFoundException;
import java.io.IOException;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.SheetConditionalFormatting;
import org.apache.poi.ss.usermodel.Workbook;
+import org.junit.Test;
/**
* HSSF-specific Conditional Formatting tests
}
}
- public void testRead() {
+ @Test
+ public void testRead() throws IOException {
testRead("WithConditionalFormatting.xls");
}
- public void testReadOffice2007() {
+ @Test
+ public void testReadOffice2007() throws IOException {
testReadOffice2007("NewStyleConditionalFormattings.xls");
}
+ @Test
public void test53691() throws IOException {
SheetConditionalFormatting cf;
- final Workbook wb;
- wb = HSSFITestDataProvider.instance.openSampleWorkbook("53691.xls");
+ final Workbook wb = HSSFITestDataProvider.instance.openSampleWorkbook("53691.xls");
/*
FileInputStream s = new FileInputStream("C:\\temp\\53691bbadfixed.xls");
try {
removeConditionalFormatting(sheet);
removeConditionalFormatting(wb.getSheetAt(0));
writeTemp53691(wb, "fgood");
+
+ wb.close();
}
private void removeConditionalFormatting(Sheet sheet) {
}
}
- private void writeTemp53691(Workbook wb, String suffix) throws FileNotFoundException,
- IOException {
+ private void writeTemp53691(Workbook wb, String suffix) throws FileNotFoundException, IOException {
// assert that we can write/read it in memory
Workbook wbBack = HSSFITestDataProvider.instance.writeOutAndReadBack(wb);
assertNotNull(wbBack);
-
- /* Just necessary for local testing... */
- /*OutputStream out = new FileOutputStream("C:\\temp\\53691" + suffix + ".xls");
- try {
- wb.write(out);
- } finally {
- out.close();
- }*/
+ wbBack.close();
}
}
package org.apache.poi.hssf.usermodel;
-import junit.framework.AssertionFailedError;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
import org.apache.poi.hssf.HSSFITestDataProvider;
import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.ss.usermodel.BaseTestFormulaEvaluator;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellValue;
+import org.junit.Test;
/**
*
* Test that the HSSFFormulaEvaluator can evaluate simple named ranges
* (single cells and rectangular areas)
*/
- public void testEvaluateSimple() {
+ @Test
+ public void testEvaluateSimple() throws IOException {
HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("testNames.xls");
HSSFSheet sheet = wb.getSheetAt(0);
HSSFCell cell = sheet.getRow(8).getCell(0);
CellValue cv = fe.evaluate(cell);
assertEquals(HSSFCell.CELL_TYPE_NUMERIC, cv.getCellType());
assertEquals(3.72, cv.getNumberValue(), 0.0);
+ wb.close();
}
/**
* Test for bug due to attempt to convert a cached formula error result to a boolean
*/
+ @Test
@Override
- public void testUpdateCachedFormulaResultFromErrorToNumber_bug46479() {
+ public void testUpdateCachedFormulaResultFromErrorToNumber_bug46479() throws IOException {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet("Sheet1");
fe.evaluateInCell(cellB1);
} catch (IllegalStateException e) {
if (e.getMessage().equals("Cannot get a numeric value from a error formula cell")) {
- throw new AssertionFailedError("Identified bug 46479a");
+ fail("Identified bug 46479a");
}
}
assertEquals(3.5, cellB1.getNumericCellValue(), 0.0);
+
+ wb.close();
}
/**
* which contained a simple area ref. It is not clear what the 'complex' flag is used
* for but POI should look elsewhere to decide whether it can evaluate the name.
*/
- public void testDefinedNameWithComplexFlag_bug47048() {
+ @Test
+ public void testDefinedNameWithComplexFlag_bug47048() throws IOException {
// Mock up a spreadsheet to match the critical details of the sample
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet("Input");
CellValue value;
try {
value = hsf.evaluate(cellA1);
+
+ assertEquals(Cell.CELL_TYPE_NUMERIC, value.getCellType());
+ assertEquals(5.33, value.getNumberValue(), 0.0);
+
} catch (RuntimeException e) {
if (e.getMessage().equals("Don't now how to evalate name 'Is_Multicar_Vehicle'")) {
- throw new AssertionFailedError("Identified bug 47048a");
+ fail("Identified bug 47048a");
}
throw e;
+ } finally {
+ wb.close();
}
-
- assertEquals(Cell.CELL_TYPE_NUMERIC, value.getCellType());
- assertEquals(5.33, value.getNumberValue(), 0.0);
}
+
private static final class EvalCountListener extends EvaluationListener {
private int _evalCount;
public EvalCountListener() {
/**
* The HSSFFormula evaluator performance benefits greatly from caching of intermediate cell values
*/
- public void testShortCircuitIfEvaluation() {
+ @Test
+ public void testShortCircuitIfEvaluation() throws IOException {
// Set up a simple IF() formula that has measurable evaluation cost for its operands.
HSSFWorkbook wb = new HSSFWorkbook();
int evalCount = evalListener.getEvalCount();
if (evalCount == 6) {
// Without short-circuit-if evaluation, evaluating cell 'A1' takes 3 extra evaluations (for D1,E1,F1)
- throw new AssertionFailedError("Identifed bug 48195 - Formula evaluator should short-circuit IF() calculations.");
+ fail("Identifed bug 48195 - Formula evaluator should short-circuit IF() calculations.");
}
assertEquals(3, evalCount);
assertEquals(2.0, ((NumberEval)ve).getNumberValue(), 0D);
+
+ wb.close();
}
/**
* Ensures that we can handle NameXPtgs in the formulas
* we parse.
*/
- public void testXRefs() throws Exception {
- HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("XRefCalc.xls");
- HSSFWorkbook wbData = HSSFTestDataSamples.openSampleWorkbook("XRefCalcData.xls");
+ @Test
+ public void testXRefs() throws IOException {
+ HSSFWorkbook wb1 = HSSFTestDataSamples.openSampleWorkbook("XRefCalc.xls");
+ HSSFWorkbook wb2 = HSSFTestDataSamples.openSampleWorkbook("XRefCalcData.xls");
Cell cell;
// VLookup on a name in another file
- cell = wb.getSheetAt(0).getRow(1).getCell(2);
+ cell = wb1.getSheetAt(0).getRow(1).getCell(2);
assertEquals(Cell.CELL_TYPE_FORMULA, cell.getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, cell.getCachedFormulaResultType());
assertEquals(12.30, cell.getNumericCellValue(), 0.0001);
// Simple reference to a name in another file
- cell = wb.getSheetAt(0).getRow(1).getCell(4);
+ cell = wb1.getSheetAt(0).getRow(1).getCell(4);
assertEquals(Cell.CELL_TYPE_FORMULA, cell.getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, cell.getCachedFormulaResultType());
assertEquals(36.90, cell.getNumericCellValue(), 0.0001);
// Evaluate the cells
- HSSFFormulaEvaluator eval = new HSSFFormulaEvaluator(wb);
+ HSSFFormulaEvaluator eval = new HSSFFormulaEvaluator(wb1);
HSSFFormulaEvaluator.setupEnvironment(
new String[] { "XRefCalc.xls", "XRefCalcData.xls" },
new HSSFFormulaEvaluator[] {
eval,
- new HSSFFormulaEvaluator(wbData)
+ new HSSFFormulaEvaluator(wb2)
}
);
eval.evaluateFormulaCell(
- wb.getSheetAt(0).getRow(1).getCell(2)
+ wb1.getSheetAt(0).getRow(1).getCell(2)
);
eval.evaluateFormulaCell(
- wb.getSheetAt(0).getRow(1).getCell(4)
+ wb1.getSheetAt(0).getRow(1).getCell(4)
);
// Re-check VLOOKUP one
- cell = wb.getSheetAt(0).getRow(1).getCell(2);
+ cell = wb1.getSheetAt(0).getRow(1).getCell(2);
assertEquals(Cell.CELL_TYPE_FORMULA, cell.getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, cell.getCachedFormulaResultType());
assertEquals(12.30, cell.getNumericCellValue(), 0.0001);
// Re-check ref one
- cell = wb.getSheetAt(0).getRow(1).getCell(4);
+ cell = wb1.getSheetAt(0).getRow(1).getCell(4);
assertEquals(Cell.CELL_TYPE_FORMULA, cell.getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, cell.getCachedFormulaResultType());
assertEquals(36.90, cell.getNumericCellValue(), 0.0001);
// Add a formula that refers to one of the existing external workbooks
- cell = wb.getSheetAt(0).getRow(1).createCell(40);
+ cell = wb1.getSheetAt(0).getRow(1).createCell(40);
cell.setCellFormula("Cost*[XRefCalcData.xls]MarkupSheet!$B$1");
// Check is was stored correctly
// Check it evaluates correctly
eval.evaluateFormulaCell(cell);
- assertEquals(24.60*1.8, cell.getNumericCellValue());
+ assertEquals(24.60*1.8, cell.getNumericCellValue(), 0);
// Try to add a formula for a new external workbook, won't be allowed to start
try {
- cell = wb.getSheetAt(0).getRow(1).createCell(42);
+ cell = wb1.getSheetAt(0).getRow(1).createCell(42);
cell.setCellFormula("[alt.xls]Sheet0!$A$1");
fail("New workbook not linked, shouldn't be able to add");
} catch(Exception e) {}
// Link our new workbook
- HSSFWorkbook alt = new HSSFWorkbook();
- alt.createSheet().createRow(0).createCell(0).setCellValue("In another workbook");
- wb.linkExternalWorkbook("alt.xls", alt);
+ HSSFWorkbook wb3 = new HSSFWorkbook();
+ wb3.createSheet().createRow(0).createCell(0).setCellValue("In another workbook");
+ wb1.linkExternalWorkbook("alt.xls", wb3);
// Now add a formula that refers to our new workbook
cell.setCellFormula("[alt.xls]Sheet0!$A$1");
new String[] { "XRefCalc.xls", "XRefCalcData.xls", "alt.xls" },
new HSSFFormulaEvaluator[] {
eval,
- new HSSFFormulaEvaluator(wbData),
- new HSSFFormulaEvaluator(alt)
+ new HSSFFormulaEvaluator(wb2),
+ new HSSFFormulaEvaluator(wb3)
}
);
eval.evaluateFormulaCell(cell);
// Save and re-load
- wb = HSSFTestDataSamples.writeOutAndReadBack(wb);
- eval = new HSSFFormulaEvaluator(wb);
+ HSSFWorkbook wb4 = HSSFTestDataSamples.writeOutAndReadBack(wb1);
+ eval = new HSSFFormulaEvaluator(wb4);
HSSFFormulaEvaluator.setupEnvironment(
new String[] { "XRefCalc.xls", "XRefCalcData.xls", "alt.xls" },
new HSSFFormulaEvaluator[] {
eval,
- new HSSFFormulaEvaluator(wbData),
- new HSSFFormulaEvaluator(alt)
+ new HSSFFormulaEvaluator(wb2),
+ new HSSFFormulaEvaluator(wb3)
}
);
// Check the one referring to the previously existing workbook behaves
- cell = wb.getSheetAt(0).getRow(1).getCell(40);
+ cell = wb4.getSheetAt(0).getRow(1).getCell(40);
assertEquals("Cost*[XRefCalcData.xls]MarkupSheet!$B$1", cell.getCellFormula());
eval.evaluateFormulaCell(cell);
- assertEquals(24.60*1.8, cell.getNumericCellValue());
+ assertEquals(24.60*1.8, cell.getNumericCellValue(), 0);
// Now check the newly added reference
- cell = wb.getSheetAt(0).getRow(1).getCell(42);
+ cell = wb4.getSheetAt(0).getRow(1).getCell(42);
assertEquals("[alt.xls]Sheet0!$A$1", cell.getCellFormula());
eval.evaluateFormulaCell(cell);
assertEquals("In another workbook", cell.getStringCellValue());
+
+ wb4.close();
+ wb3.close();
+ wb2.close();
+ wb1.close();
}
- public void testSharedFormulas(){
+ @Test
+ public void testSharedFormulas() throws IOException {
baseTestSharedFormulas("shared_formulas.xls");
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
+import java.io.IOException;
import java.util.List;
import org.apache.poi.ddf.EscherDgRecord;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.ss.util.CellRangeAddressList;
-import org.apache.poi.util.TempFile;
import org.junit.Test;
/**
super(HSSFITestDataProvider.instance);
}
- @Test
- public void createRowAfterLastRow() {
+ @Test(expected=IllegalArgumentException.class)
+ public void createRowAfterLastRow() throws IOException {
createRowAfterLastRow(SpreadsheetVersion.EXCEL97);
}
* Moved from TestHSSFWorkbook#testSetRepeatingRowsAndColumns().
*/
@Test
- public void setRepeatingRowsAndColumnsBug29747() {
+ public void setRepeatingRowsAndColumnsBug29747() throws IOException {
HSSFWorkbook wb = new HSSFWorkbook();
wb.createSheet();
wb.createSheet();
sheet2.setRepeatingRows(CellRangeAddress.valueOf("1:2"));
NameRecord nameRecord = wb.getWorkbook().getNameRecord(0);
assertEquals(3, nameRecord.getSheetNumber());
+ wb.close();
}
@Test
- public void getSetMargin() {
+ public void getSetMargin() throws IOException {
baseTestGetSetMargin(new double[]{0.75, 0.75, 1.0, 1.0, 0.3, 0.3});
}
* Test the gridset field gets set as expected.
*/
@Test
- public void backupRecord() {
+ public void backupRecord() throws IOException {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet s = wb.createSheet();
GridsetRecord gridsetRec = s.getSheet().getGridsetRecord();
assertTrue(gridsetRec.getGridset());
s.setGridsPrinted(true);
assertFalse(gridsetRec.getGridset());
+ wb.close();
}
/**
*/
@SuppressWarnings("deprecation")
@Test
- public void verticallyCenter() {
+ public void verticallyCenter() throws IOException {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet s = wb.createSheet();
VCenterRecord record = s.getSheet().getPageSettings().getVCenter();
assertTrue(s.getVerticallyCenter(true));
assertTrue(s.getVerticallyCenter(false));
- // wb.write(new FileOutputStream("c:\\test.xls"));
+ wb.close();
}
/**
* Test horizontally centered output.
*/
@Test
- public void horizontallyCenter() {
+ public void horizontallyCenter() throws IOException {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet s = wb.createSheet();
HCenterRecord record = s.getSheet().getPageSettings().getHCenter();
assertFalse(record.getHCenter());
s.setHorizontallyCenter(true);
assertTrue(record.getHCenter());
+ wb.close();
}
* Test WSBboolRecord fields get set in the user model.
*/
@Test
- public void wsBool() {
+ public void wsBool() throws IOException {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet s = wb.createSheet();
WSBoolRecord record =
assertFalse(s.getFitToPage());
assertTrue(s.getRowSumsBelow());
assertTrue(s.getRowSumsRight());
+
+ wb.close();
}
/**
* Setting landscape and portrait stuff on existing sheets
*/
@Test
- public void printSetupLandscapeExisting() {
- HSSFWorkbook workbook = HSSFTestDataSamples.openSampleWorkbook("SimpleWithPageBreaks.xls");
+ public void printSetupLandscapeExisting() throws IOException {
+ HSSFWorkbook wb1 = HSSFTestDataSamples.openSampleWorkbook("SimpleWithPageBreaks.xls");
- assertEquals(3, workbook.getNumberOfSheets());
+ assertEquals(3, wb1.getNumberOfSheets());
- HSSFSheet sheetL = workbook.getSheetAt(0);
- HSSFSheet sheetPM = workbook.getSheetAt(1);
- HSSFSheet sheetLS = workbook.getSheetAt(2);
+ HSSFSheet sheetL = wb1.getSheetAt(0);
+ HSSFSheet sheetPM = wb1.getSheetAt(1);
+ HSSFSheet sheetLS = wb1.getSheetAt(2);
// Check two aspects of the print setup
assertFalse(sheetL.getPrintSetup().getLandscape());
assertEquals(1, sheetLS.getPrintSetup().getCopies());
// Save and re-load, and check still there
- workbook = HSSFTestDataSamples.writeOutAndReadBack(workbook);
+ Workbook wb2 = HSSFTestDataSamples.writeOutAndReadBack(wb1);
+ wb1.close();
+ sheetL = wb1.getSheetAt(0);
+ sheetPM = wb1.getSheetAt(1);
+ sheetLS = wb1.getSheetAt(2);
+
assertTrue(sheetL.getPrintSetup().getLandscape());
assertFalse(sheetPM.getPrintSetup().getLandscape());
assertTrue(sheetLS.getPrintSetup().getLandscape());
assertEquals(1, sheetL.getPrintSetup().getCopies());
assertEquals(3, sheetPM.getPrintSetup().getCopies());
assertEquals(1, sheetLS.getPrintSetup().getCopies());
+
+ wb2.close();
}
@Test
- public void groupRows() {
- HSSFWorkbook workbook = new HSSFWorkbook();
- HSSFSheet s = workbook.createSheet();
+ public void groupRows() throws IOException {
+ HSSFWorkbook wb1 = new HSSFWorkbook();
+ HSSFSheet s = wb1.createSheet();
HSSFRow r1 = s.createRow(0);
HSSFRow r2 = s.createRow(1);
HSSFRow r3 = s.createRow(2);
assertEquals(0, r5.getOutlineLevel());
// Save and re-open
- workbook = HSSFTestDataSamples.writeOutAndReadBack(workbook);
+ HSSFWorkbook wb2 = HSSFTestDataSamples.writeOutAndReadBack(wb1);
+ wb1.close();
- s = workbook.getSheetAt(0);
+ s = wb2.getSheetAt(0);
r1 = s.getRow(0);
r2 = s.getRow(1);
r3 = s.getRow(2);
assertEquals(1, r3.getOutlineLevel());
assertEquals(1, r4.getOutlineLevel());
assertEquals(0, r5.getOutlineLevel());
+ wb2.close();
}
@Test
- public void groupRowsExisting() {
- HSSFWorkbook workbook = HSSFTestDataSamples.openSampleWorkbook("NoGutsRecords.xls");
+ public void groupRowsExisting() throws IOException {
+ HSSFWorkbook wb1 = HSSFTestDataSamples.openSampleWorkbook("NoGutsRecords.xls");
- HSSFSheet s = workbook.getSheetAt(0);
+ HSSFSheet s = wb1.getSheetAt(0);
HSSFRow r1 = s.getRow(0);
HSSFRow r2 = s.getRow(1);
HSSFRow r3 = s.getRow(2);
assertEquals(0, r6.getOutlineLevel());
// Save and re-open
+ HSSFWorkbook wb2 = null;
try {
- workbook = HSSFTestDataSamples.writeOutAndReadBack(workbook);
+ wb2 = HSSFTestDataSamples.writeOutAndReadBack(wb1);
} catch (OutOfMemoryError e) {
fail("Identified bug 39903");
}
- s = workbook.getSheetAt(0);
+ s = wb2.getSheetAt(0);
r1 = s.getRow(0);
r2 = s.getRow(1);
r3 = s.getRow(2);
assertEquals(1, r4.getOutlineLevel());
assertEquals(1, r5.getOutlineLevel());
assertEquals(0, r6.getOutlineLevel());
+
+ wb2.close();
+ wb1.close();
}
@Test
- public void createDrawings() {
+ public void createDrawings() throws IOException {
HSSFWorkbook workbook = new HSSFWorkbook();
HSSFSheet sheet = workbook.createSheet();
HSSFPatriarch p1 = sheet.createDrawingPatriarch();
HSSFPatriarch p2 = sheet.createDrawingPatriarch();
assertSame(p1, p2);
+ workbook.close();
}
@Test
- public void getDrawings() {
+ public void getDrawings() throws IOException {
HSSFWorkbook wb1c = HSSFTestDataSamples.openSampleWorkbook("WithChart.xls");
HSSFWorkbook wb2c = HSSFTestDataSamples.openSampleWorkbook("WithTwoCharts.xls");
assertFalse(wb2c.getSheetAt(0).getDrawingPatriarch().containsChart());
assertTrue(wb2c.getSheetAt(1).getDrawingPatriarch().containsChart());
assertTrue(wb2c.getSheetAt(2).getDrawingPatriarch().containsChart());
+ wb2c.close();
+ wb1c.close();
}
/**
* Test that the ProtectRecord is included when creating or cloning a sheet
*/
@Test
- public void cloneWithProtect() {
+ public void cloneWithProtect() throws IOException {
String passwordA = "secrect";
int expectedHashA = -6810;
String passwordB = "admin";
assertEquals(expectedHashB, hssfSheet.getPassword());
// but the cloned sheet's password should remain unchanged
assertEquals(expectedHashA, sheet2.getSheet().getProtectionBlock().getPasswordHash());
+ workbook.close();
}
@Test
- public void protectSheetA() {
+ public void protectSheetA() throws IOException {
int expectedHash = (short)0xfef1;
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet s = wb.createSheet();
assertTrue("object protection should be on",pb.isObjectProtected());
assertTrue("scenario protection should be on",pb.isScenarioProtected());
assertEquals("well known value for top secret hash should be "+Integer.toHexString(expectedHash).substring(4), expectedHash, pb.getPasswordHash());
+ wb.close();
}
/**
* (which should be before {@link DimensionsRecord}).
*/
@Test
- public void protectSheetRecordOrder_bug47363a() {
+ public void protectSheetRecordOrder_bug47363a() throws IOException {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet s = wb.createSheet();
s.protectSheet("secret");
confirmRecordClass(recs, nRecs-8, ObjectProtectRecord.class);
confirmRecordClass(recs, nRecs-7, ScenarioProtectRecord.class);
confirmRecordClass(recs, nRecs-6, PasswordRecord.class);
+
+ wb.close();
}
private static void confirmRecordClass(Record[] recs, int index, Class<? extends Record> cls) {
* There should be no problem with adding data validations after sheet protection
*/
@Test
- public void dvProtectionOrder_bug47363b() {
+ public void dvProtectionOrder_bug47363b() throws IOException {
HSSFWorkbook workbook = new HSSFWorkbook();
HSSFSheet sheet = workbook.createSheet("Sheet1");
sheet.protectSheet("secret");
if (expMsg.equals(e.getMessage())) {
fail("Identified bug 47363b");
}
+ workbook.close();
throw e;
}
RecordCollector rc;
int nRecsWithoutProtection = rc.getRecords().length;
assertEquals(4, nRecsWithProtection - nRecsWithoutProtection);
+
+ workbook.close();
}
@Test
- public void zoom() {
+ public void zoom() throws IOException {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet();
assertEquals(-1, sheet.getSheet().findFirstRecordLocBySid(SCLRecord.sid));
} catch (IllegalArgumentException e) {
assertEquals("Denominator must be greater than 0 and less than 65536", e.getMessage());
}
+
+ wb.close();
}
* Make sure the excel file loads work
*/
@Test
- public void pageBreakFiles() {
- HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("SimpleWithPageBreaks.xls");
+ public void pageBreakFiles() throws IOException {
+ HSSFWorkbook wb1 = HSSFTestDataSamples.openSampleWorkbook("SimpleWithPageBreaks.xls");
- HSSFSheet sheet = wb.getSheetAt(0);
+ HSSFSheet sheet = wb1.getSheetAt(0);
assertNotNull(sheet);
assertEquals("1 row page break", 1, sheet.getRowBreaks().length);
assertEquals("row breaks number", 2, sheet.getRowBreaks().length);
assertEquals("column breaks number", 2, sheet.getColumnBreaks().length);
- wb = HSSFTestDataSamples.writeOutAndReadBack(wb);
- sheet = wb.getSheetAt(0);
+ HSSFWorkbook wb2 = HSSFTestDataSamples.writeOutAndReadBack(wb1);
+ wb1.close();
+ sheet = wb2.getSheetAt(0);
assertTrue("No row page break", sheet.isRowBroken(22));
assertTrue("No column page break", sheet.isColumnBroken((short)4));
assertEquals("row breaks number", 2, sheet.getRowBreaks().length);
assertEquals("column breaks number", 2, sheet.getColumnBreaks().length);
+
+ wb2.close();
}
@Test
- public void dbcsName () {
+ public void dbcsName () throws IOException {
HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("DBCSSheetName.xls");
wb.getSheetAt(1);
assertEquals ("DBCS Sheet Name 2", wb.getSheetName(1),"\u090f\u0915" );
assertEquals("DBCS Sheet Name 1", wb.getSheetName(0),"\u091c\u093e");
+ wb.close();
}
/**
* of the sheet when it is first opened.
*/
@Test
- public void topRow() {
+ public void topRow() throws IOException {
HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("SimpleWithPageBreaks.xls");
HSSFSheet sheet = wb.getSheetAt(0);
sheet.showInPane(toprow,leftcol);
assertEquals("HSSFSheet.getTopRow()", toprow, sheet.getTopRow());
assertEquals("HSSFSheet.getLeftCol()", leftcol, sheet.getLeftCol());
+
+ wb.close();
}
@Test
- public void addEmptyRow() {
+ public void addEmptyRow() throws IOException {
//try to add 5 empty rows to a new sheet
- HSSFWorkbook workbook = new HSSFWorkbook();
- HSSFSheet sheet = workbook.createSheet();
+ HSSFWorkbook wb1 = new HSSFWorkbook();
+ HSSFSheet sheet = wb1.createSheet();
for (int i = 0; i < 5; i++) {
sheet.createRow(i);
}
- workbook = HSSFTestDataSamples.writeOutAndReadBack(workbook);
+ HSSFTestDataSamples.writeOutAndReadBack(wb1).close();
+ wb1.close();
//try adding empty rows in an existing worksheet
- workbook = HSSFTestDataSamples.openSampleWorkbook("Simple.xls");
+ HSSFWorkbook wb2 = HSSFTestDataSamples.openSampleWorkbook("Simple.xls");
- sheet = workbook.getSheetAt(0);
+ sheet = wb2.getSheetAt(0);
for (int i = 3; i < 10; i++) sheet.createRow(i);
- workbook = HSSFTestDataSamples.writeOutAndReadBack(workbook);
+ HSSFTestDataSamples.writeOutAndReadBack(wb2).close();
+ wb2.close();
}
@SuppressWarnings("deprecation")
@Test
- public void autoSizeColumn() {
- HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("43902.xls");
+ public void autoSizeColumn() throws IOException {
+ HSSFWorkbook wb1 = HSSFTestDataSamples.openSampleWorkbook("43902.xls");
String sheetName = "my sheet";
- HSSFSheet sheet = wb.getSheet(sheetName);
+ HSSFSheet sheet = wb1.getSheet(sheetName);
// Can't use literal numbers for column sizes, as
// will come out with different values on different
sheet.addMergedRegion(new CellRangeAddress(1,1,0,1));
assertNotNull(sheet.getMergedRegionAt(0));
sheet.autoSizeColumn((short)0);
- HSSFWorkbook wb2 = HSSFTestDataSamples.writeOutAndReadBack(wb);
+ HSSFWorkbook wb2 = HSSFTestDataSamples.writeOutAndReadBack(wb1);
// check that the autoSized column width has ignored the 2nd row
// because it is included in a merged region (Excel like behavior)
HSSFSheet sheet3 = wb3.getSheet(sheetName);
assertTrue(sheet3.getColumnWidth(0) >= minWithRow1And2);
assertTrue(sheet3.getColumnWidth(0) <= maxWithRow1And2);
+
+ wb3.close();
+ wb2.close();
+ wb1.close();
}
@Test
- public void testNoMergedRegionsIsEmptyList() {
+ public void testNoMergedRegionsIsEmptyList() throws IOException {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet s = wb.createSheet("Sheet1");
assertTrue(s.getMergedRegions().isEmpty());
+ wb.close();
}
@Test
- public void autoSizeDate() throws Exception {
+ public void autoSizeDate() throws IOException {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet s = wb.createSheet("Sheet1");
HSSFRow r = s.createRow(0);
assertTrue("Date column too small: " + s.getColumnWidth(0), s.getColumnWidth(0) > 4750);
assertTrue("Date column too small: " + s.getColumnWidth(1), s.getColumnWidth(1) > 4750);
assertTrue("Date column too big: " + s.getColumnWidth(0), s.getColumnWidth(0) < 6500);
- assertTrue("Date column too big: " + s.getColumnWidth(0), s.getColumnWidth(0) < 6500);
+ assertTrue("Date column too big: " + s.getColumnWidth(0), s.getColumnWidth(0) < 6500);
+
+ wb.close();
}
/**
* Setting ForceFormulaRecalculation on sheets
*/
@Test
- public void forceRecalculation() throws Exception {
- HSSFWorkbook workbook = HSSFTestDataSamples.openSampleWorkbook("UncalcedRecord.xls");
+ public void forceRecalculation() throws IOException {
+ HSSFWorkbook wb1 = HSSFTestDataSamples.openSampleWorkbook("UncalcedRecord.xls");
- HSSFSheet sheet = workbook.getSheetAt(0);
- HSSFSheet sheet2 = workbook.getSheetAt(0);
+ HSSFSheet sheet = wb1.getSheetAt(0);
+ HSSFSheet sheet2 = wb1.getSheetAt(0);
HSSFRow row = sheet.getRow(0);
row.createCell(0).setCellValue(5);
row.createCell(1).setCellValue(8);
assertFalse(sheet2.getForceFormulaRecalculation());
// Save and manually verify that on column C we have 0, value in template
- File tempFile = TempFile.createTempFile("uncalced_err", ".xls" );
- FileOutputStream fout = new FileOutputStream( tempFile );
- workbook.write( fout );
- fout.close();
+ HSSFTestDataSamples.writeOutAndReadBack(wb1).close();
sheet.setForceFormulaRecalculation(true);
assertTrue(sheet.getForceFormulaRecalculation());
// Save and manually verify that on column C we have now 13, calculated value
- tempFile = TempFile.createTempFile("uncalced_succ", ".xls");
- tempFile.delete();
- fout = new FileOutputStream( tempFile );
- workbook.write( fout );
- fout.close();
-
// Try it can be opened
- HSSFWorkbook wb2 = new HSSFWorkbook(new FileInputStream(tempFile));
+ HSSFWorkbook wb2 = HSSFTestDataSamples.writeOutAndReadBack(wb1);
+ wb1.close();
// And check correct sheet settings found
sheet = wb2.getSheetAt(0);
// Now turn if back off again
sheet.setForceFormulaRecalculation(false);
- fout = new FileOutputStream( tempFile );
- wb2.write( fout );
- fout.close();
- wb2 = new HSSFWorkbook(new FileInputStream(tempFile));
+ HSSFWorkbook wb3 = HSSFTestDataSamples.writeOutAndReadBack(wb2);
+ wb2.close();
- assertFalse(wb2.getSheetAt(0).getForceFormulaRecalculation());
- assertFalse(wb2.getSheetAt(1).getForceFormulaRecalculation());
- assertFalse(wb2.getSheetAt(2).getForceFormulaRecalculation());
+ assertFalse(wb3.getSheetAt(0).getForceFormulaRecalculation());
+ assertFalse(wb3.getSheetAt(1).getForceFormulaRecalculation());
+ assertFalse(wb3.getSheetAt(2).getForceFormulaRecalculation());
// Now add a new sheet, and check things work
// with old ones unset, new one set
- HSSFSheet s4 = wb2.createSheet();
+ HSSFSheet s4 = wb3.createSheet();
s4.setForceFormulaRecalculation(true);
assertFalse(sheet.getForceFormulaRecalculation());
assertFalse(sheet2.getForceFormulaRecalculation());
assertTrue(s4.getForceFormulaRecalculation());
- fout = new FileOutputStream( tempFile );
- wb2.write( fout );
- fout.close();
-
- HSSFWorkbook wb3 = new HSSFWorkbook(new FileInputStream(tempFile));
- assertFalse(wb3.getSheetAt(0).getForceFormulaRecalculation());
- assertFalse(wb3.getSheetAt(1).getForceFormulaRecalculation());
- assertFalse(wb3.getSheetAt(2).getForceFormulaRecalculation());
- assertTrue(wb3.getSheetAt(3).getForceFormulaRecalculation());
+ HSSFWorkbook wb4 = HSSFTestDataSamples.writeOutAndReadBack(wb3);
+ wb3.close();
+
+ assertFalse(wb4.getSheetAt(0).getForceFormulaRecalculation());
+ assertFalse(wb4.getSheetAt(1).getForceFormulaRecalculation());
+ assertFalse(wb4.getSheetAt(2).getForceFormulaRecalculation());
+ assertTrue(wb4.getSheetAt(3).getForceFormulaRecalculation());
+ wb4.close();
}
@Test
- public void columnWidthA() {
+ public void columnWidthA() throws IOException {
//check we can correctly read column widths from a reference workbook
- HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("colwidth.xls");
+ HSSFWorkbook wb1 = HSSFTestDataSamples.openSampleWorkbook("colwidth.xls");
//reference values
int[] ref = {365, 548, 731, 914, 1097, 1280, 1462, 1645, 1828, 2011, 2194, 2377, 2560, 2742, 2925, 3108, 3291, 3474, 3657};
- HSSFSheet sh = wb.getSheetAt(0);
+ HSSFSheet sh = wb1.getSheetAt(0);
for (char i = 'A'; i <= 'S'; i++) {
int idx = i - 'A';
int w = sh.getColumnWidth(idx);
}
//the second sheet doesn't have overridden column widths
- sh = wb.getSheetAt(1);
+ sh = wb1.getSheetAt(1);
int def_width = sh.getDefaultColumnWidth();
for (char i = 'A'; i <= 'S'; i++) {
int idx = i - 'A';
//getColumnWidth returns width measured in 1/256th units
assertEquals(def_width*256, w);
}
+ wb1.close();
//test new workbook
- wb = new HSSFWorkbook();
- sh = wb.createSheet();
+ HSSFWorkbook wb2 = new HSSFWorkbook();
+ sh = wb2.createSheet();
sh.setDefaultColumnWidth(10);
assertEquals(10, sh.getDefaultColumnWidth());
assertEquals(256*10, sh.getColumnWidth(0));
}
//serialize and read again
- wb = HSSFTestDataSamples.writeOutAndReadBack(wb);
+ HSSFWorkbook wb3 = HSSFTestDataSamples.writeOutAndReadBack(wb2);
+ wb2.close();
- sh = wb.getSheetAt(0);
+ sh = wb3.getSheetAt(0);
assertEquals(10, sh.getDefaultColumnWidth());
//columns A-C have default width
assertEquals(256*10, sh.getColumnWidth(0));
// check for 16-bit signed/unsigned error:
sh.setColumnWidth(0, 40000);
assertEquals(40000, sh.getColumnWidth(0));
+ wb3.close();
}
@Test
- public void defaultColumnWidth() {
- HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook( "12843-1.xls" );
- HSSFSheet sheet = wb.getSheetAt( 7 );
+ public void defaultColumnWidth() throws IOException {
+ HSSFWorkbook wb1 = HSSFTestDataSamples.openSampleWorkbook( "12843-1.xls" );
+ HSSFSheet sheet = wb1.getSheetAt( 7 );
// shall not be NPE
assertEquals(8, sheet.getDefaultColumnWidth());
assertEquals(8*256, sheet.getColumnWidth(0));
assertEquals(0xFF, sheet.getDefaultRowHeight());
+
+ wb1.close();
- wb = HSSFTestDataSamples.openSampleWorkbook( "34775.xls" );
+ HSSFWorkbook wb2 = HSSFTestDataSamples.openSampleWorkbook( "34775.xls" );
// second and third sheets miss DefaultColWidthRecord
for(int i = 1; i <= 2; i++){
- int dw = wb.getSheetAt( i ).getDefaultColumnWidth();
+ int dw = wb2.getSheetAt( i ).getDefaultColumnWidth();
assertEquals(8, dw);
- int cw = wb.getSheetAt( i ).getColumnWidth(0);
+ int cw = wb2.getSheetAt( i ).getColumnWidth(0);
assertEquals(8*256, cw);
assertEquals(0xFF, sheet.getDefaultRowHeight());
}
+ wb2.close();
}
/**
* Now POI is too.
*/
@Test
- public void missingRowRecords_bug41187() {
+ public void missingRowRecords_bug41187() throws IOException {
HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("ex41187-19267.xls");
HSSFSheet sheet = wb.getSheetAt(0);
HSSFRow row = sheet.getRow(0);
- if(row == null) {
- fail("Identified bug 41187 a");
- }
- if (row.getHeight() == 0) {
- fail("Identified bug 41187 b");
- }
+ assertNotNull("Identified bug 41187 a", row);
+
+ assertNotEquals("Identified bug 41187 b", (short)0, row.getHeight());
+
assertEquals("Hi Excel!", row.getCell(0).getRichStringCellValue().getString());
// check row height for 'default' flag
assertEquals((short)0xFF, row.getHeight());
- HSSFTestDataSamples.writeOutAndReadBack(wb);
+ HSSFTestDataSamples.writeOutAndReadBack(wb).close();
+
+ wb.close();
}
/**
* See bug #45720.
*/
@Test
- public void cloneSheetWithDrawings() {
+ public void cloneSheetWithDrawings() throws IOException {
HSSFWorkbook wb1 = HSSFTestDataSamples.openSampleWorkbook("45720.xls");
HSSFSheet sheet1 = wb1.getSheetAt(0);
wb1.cloneSheet(0);
HSSFWorkbook wb2 = HSSFTestDataSamples.writeOutAndReadBack(wb1);
+ wb1.close();
+
wb2.getWorkbook().findDrawingGroup();
DrawingManager2 dm2 = wb2.getWorkbook().getDrawingManager();
assertEquals(dg_id_1 + 1, dg_id_2);
//TODO: check shapeId in the cloned sheet
+ wb2.close();
}
/**
* 31 chars.
*/
@Test
- public void longSheetNames() {
+ public void longSheetNames() throws IOException {
HSSFWorkbook wb = new HSSFWorkbook();
final String SAME_PREFIX = "A123456789B123456789C123456789"; // 30 chars
assertEquals("The workbook already contains a sheet of this name", e.getMessage());
}
wb.createSheet(SAME_PREFIX + "Exxxx"); // OK - differs in the 31st char
+ wb.close();
}
/**
* Tests that we can read existing column styles
*/
@Test
- public void readColumnStyles() {
+ public void readColumnStyles() throws IOException {
HSSFWorkbook wbNone = HSSFTestDataSamples.openSampleWorkbook("ColumnStyleNone.xls");
HSSFWorkbook wbSimple = HSSFTestDataSamples.openSampleWorkbook("ColumnStyle1dp.xls");
HSSFWorkbook wbComplex = HSSFTestDataSamples.openSampleWorkbook("ColumnStyle1dpColoured.xls");
assertEquals(10, cs.getFont(wbComplex).getColor());
assertFalse(cs.getFont(wbComplex).getItalic());
assertEquals(HSSFFont.BOLDWEIGHT_BOLD, cs.getFont(wbComplex).getBoldweight());
+
+ wbComplex.close();
+ wbSimple.close();
+ wbNone.close();
}
/**
* Tests the arabic setting
*/
@Test
- public void arabic() {
+ public void arabic() throws IOException {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet s = wb.createSheet();
assertFalse(s.isRightToLeft());
s.setRightToLeft(true);
assertTrue(s.isRightToLeft());
+ wb.close();
}
@Test
- public void autoFilter(){
- HSSFWorkbook wb = new HSSFWorkbook();
- HSSFSheet sh = wb.createSheet();
- InternalWorkbook iwb = wb.getWorkbook();
+ public void autoFilter() throws IOException {
+ HSSFWorkbook wb1 = new HSSFWorkbook();
+ HSSFSheet sh = wb1.createSheet();
+ InternalWorkbook iwb = wb1.getWorkbook();
InternalSheet ish = sh.getSheet();
assertNull( iwb.getSpecificBuiltinRecord(NameRecord.BUILTIN_FILTER_DB, 1) );
assertNull( ish.findFirstRecordBySid(ObjRecord.sid) ); // ObjRecord will appear after serializetion
- wb = HSSFTestDataSamples.writeOutAndReadBack(wb);
- sh = wb.getSheetAt(0);
+ HSSFWorkbook wb2 = HSSFTestDataSamples.writeOutAndReadBack(wb1);
+ wb1.close();
+ sh = wb2.getSheetAt(0);
ish = sh.getSheet();
ObjRecord objRecord = (ObjRecord)ish.findFirstRecordBySid(ObjRecord.sid);
List<SubRecord> subRecords = objRecord.getSubRecords();
assertTrue(subRecords.get(0) instanceof CommonObjectDataSubRecord );
assertTrue(subRecords.get(1) instanceof FtCblsSubRecord ); // must be present, see Bug 51481
assertTrue(subRecords.get(2) instanceof LbsDataSubRecord );
+ wb2.close();
}
@Test
- public void getSetColumnHiddenShort() {
+ public void getSetColumnHiddenShort() throws IOException {
Workbook workbook = new HSSFWorkbook();
Sheet sheet = workbook.createSheet("Sheet 1");
sheet.setColumnHidden((short)2, true);
assertTrue(sheet.isColumnHidden((short)2));
+ workbook.close();
}
@Test
- public void columnWidthShort() {
- HSSFWorkbook wb = new HSSFWorkbook();
- Sheet sheet = wb.createSheet();
+ public void columnWidthShort() throws IOException {
+ HSSFWorkbook wb1 = new HSSFWorkbook();
+ Sheet sheet = wb1.createSheet();
//default column width measured in characters
sheet.setDefaultColumnWidth((short)10);
}
//serialize and read again
- wb = HSSFTestDataSamples.writeOutAndReadBack(wb);
+ HSSFWorkbook wb2 = HSSFTestDataSamples.writeOutAndReadBack(wb1);
+ wb1.close();
- sheet = wb.getSheetAt(0);
+ sheet = wb2.getSheetAt(0);
assertEquals(20, sheet.getDefaultColumnWidth());
//columns A-C have default width
assertEquals(256*20, sheet.getColumnWidth((short)0));
assertEquals(w, sheet.getColumnWidth((short)i));
}
assertEquals(40000, sheet.getColumnWidth((short)10));
+
+ wb2.close();
}
@Test
- public void showInPane() {
+ public void showInPane() throws IOException {
Workbook wb = new HSSFWorkbook();
Sheet sheet = wb.createSheet();
sheet.showInPane(2, 3);
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Maximum row number is 65535");
sheet.showInPane(Integer.MAX_VALUE, 3);
+ wb.close();
}
@Test
- public void drawingRecords() {
+ public void drawingRecords() throws IOException {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet();
sheet.dumpDrawingRecords(false);
sheet.dumpDrawingRecords(true);*/
assertNull(sheet.getDrawingEscherAggregate());
+ wb.close();
}
@Test
- public void bug55723b() {
+ public void bug55723b() throws IOException {
HSSFWorkbook wb = new HSSFWorkbook();
Sheet sheet = wb.createSheet();
// stored with a special name
NameRecord record = wb.getWorkbook().getSpecificBuiltinRecord(NameRecord.BUILTIN_FILTER_DB, 1);
assertNotNull(record);
+ wb.close();
}
}
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
-import java.io.FileOutputStream;
import java.io.IOException;
import org.apache.poi.hssf.usermodel.HSSFSheet;
}
@Test
- public final void find() {
+ public final void find() throws IOException {
Workbook book = _testDataProvider.createWorkbook();
Sheet sheet = book.createSheet();
assertNull(sheet.getCellComment(0, 0));
Cell cell = row.createCell(0);
assertNull(sheet.getCellComment(0, 0));
assertNull(cell.getCellComment());
+ book.close();
}
@Test
- public final void create() {
+ public final void create() throws IOException {
String cellText = "Hello, World";
String commentText = "We can set comments in POI";
String commentAuthor = "Apache Software Foundation";
int cellRow = 3;
int cellColumn = 1;
- Workbook wb = _testDataProvider.createWorkbook();
- CreationHelper factory = wb.getCreationHelper();
+ Workbook wb1 = _testDataProvider.createWorkbook();
+ CreationHelper factory = wb1.getCreationHelper();
- Sheet sheet = wb.createSheet();
+ Sheet sheet = wb1.createSheet();
assertNull(sheet.getCellComment(cellRow, cellColumn));
Cell cell = sheet.createRow(cellRow).createCell(cellColumn);
assertEquals(cellRow, comment.getRow());
assertEquals(cellColumn, comment.getColumn());
- wb = _testDataProvider.writeOutAndReadBack(wb);
- sheet = wb.getSheetAt(0);
+ Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+ wb1.close();
+
+ sheet = wb2.getSheetAt(0);
cell = sheet.getRow(cellRow).getCell(cellColumn);
comment = cell.getCellComment();
comment.setString(factory.createRichTextString("New Comment Text"));
comment.setVisible(false);
- wb = _testDataProvider.writeOutAndReadBack(wb);
+ Workbook wb3 = _testDataProvider.writeOutAndReadBack(wb2);
+ wb2.close();
- sheet = wb.getSheetAt(0);
+ sheet = wb3.getSheetAt(0);
cell = sheet.getRow(cellRow).getCell(cellColumn);
comment = cell.getCellComment();
assertEquals(cellRow, comment.getRow());
assertEquals(cellColumn, comment.getColumn());
assertFalse(comment.isVisible());
+
+ wb3.close();
}
/**
* test that we can read cell comments from an existing workbook.
*/
@Test
- public final void readComments() {
+ public final void readComments() throws IOException {
Workbook wb = _testDataProvider.openSampleWorkbook("SimpleWithComments." + _testDataProvider.getStandardFileNameExtension());
assertEquals(rownum, comment.getRow());
assertEquals(cell.getColumnIndex(), comment.getColumn());
}
+
+ wb.close();
}
/**
* test that we can modify existing cell comments
*/
@Test
- public final void modifyComments() {
+ public final void modifyComments() throws IOException {
- Workbook wb = _testDataProvider.openSampleWorkbook("SimpleWithComments." + _testDataProvider.getStandardFileNameExtension());
- CreationHelper factory = wb.getCreationHelper();
+ Workbook wb1 = _testDataProvider.openSampleWorkbook("SimpleWithComments." + _testDataProvider.getStandardFileNameExtension());
+ CreationHelper factory = wb1.getCreationHelper();
- Sheet sheet = wb.getSheetAt(0);
+ Sheet sheet = wb1.getSheetAt(0);
Cell cell;
Row row;
comment.setString(factory.createRichTextString("Modified comment at row " + rownum));
}
- wb = _testDataProvider.writeOutAndReadBack(wb);
- sheet = wb.getSheetAt(0);
+ Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+ wb1.close();
+ sheet = wb2.getSheetAt(0);
for (int rownum = 0; rownum < 3; rownum++) {
row = sheet.getRow(rownum);
assertEquals("Mofified[" + rownum + "] by Yegor", comment.getAuthor());
assertEquals("Modified comment at row " + rownum, comment.getString().getString());
}
+
+ wb2.close();
}
@Test
- public final void deleteComments() {
- Workbook wb = _testDataProvider.openSampleWorkbook("SimpleWithComments." + _testDataProvider.getStandardFileNameExtension());
- Sheet sheet = wb.getSheetAt(0);
+ public final void deleteComments() throws IOException {
+ Workbook wb1 = _testDataProvider.openSampleWorkbook("SimpleWithComments." + _testDataProvider.getStandardFileNameExtension());
+ Sheet sheet = wb1.getSheetAt(0);
// Zap from rows 1 and 3
assertNotNull(sheet.getRow(0).getCell(1).getCellComment());
assertNull(sheet.getRow(2).getCell(1).getCellComment());
// Save and re-load
- wb = _testDataProvider.writeOutAndReadBack(wb);
- sheet = wb.getSheetAt(0);
+ Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+ wb1.close();
+ sheet = wb2.getSheetAt(0);
// Check
assertNull(sheet.getRow(0).getCell(1).getCellComment());
assertNotNull(sheet.getRow(1).getCell(1).getCellComment());
assertNull(sheet.getRow(2).getCell(1).getCellComment());
+
+ wb2.close();
}
/**
* code from the quick guide
*/
@Test
- public void quickGuide(){
- Workbook wb = _testDataProvider.createWorkbook();
+ public void quickGuide() throws IOException {
+ Workbook wb1 = _testDataProvider.createWorkbook();
- CreationHelper factory = wb.getCreationHelper();
+ CreationHelper factory = wb1.getCreationHelper();
- Sheet sheet = wb.createSheet();
+ Sheet sheet = wb1.createSheet();
Cell cell = sheet.createRow(3).createCell(5);
cell.setCellValue("F4");
//assign the comment to the cell
cell.setCellComment(comment);
- wb = _testDataProvider.writeOutAndReadBack(wb);
- sheet = wb.getSheetAt(0);
+ Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+ wb1.close();
+ sheet = wb2.getSheetAt(0);
cell = sheet.getRow(3).getCell(5);
comment = cell.getCellComment();
assertNotNull(comment);
assertEquals("Apache POI", comment.getAuthor());
assertEquals(3, comment.getRow());
assertEquals(5, comment.getColumn());
+
+ wb2.close();
}
@Test
assertEquals( 3, anchor.getRow2());
assertEquals(16*EMU_PER_PIXEL, anchor.getDy2());
}
+
+ wb.close();
}
}
\r
package org.apache.poi.ss.usermodel;\r
\r
-import junit.framework.TestCase;\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertFalse;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertNull;\r
+import static org.junit.Assert.assertTrue;\r
+import static org.junit.Assert.fail;\r
+\r
+import java.io.IOException;\r
\r
import org.apache.poi.hssf.usermodel.HSSFConditionalFormatting;\r
import org.apache.poi.hssf.usermodel.HSSFConditionalFormattingRule;\r
import org.apache.poi.ss.usermodel.ConditionalFormattingThreshold.RangeType;\r
import org.apache.poi.ss.usermodel.IconMultiStateFormatting.IconSet;\r
import org.apache.poi.ss.util.CellRangeAddress;\r
+import org.junit.Test;\r
\r
/**\r
* Base tests for Conditional Formatting, for both HSSF and XSSF\r
*/\r
-public abstract class BaseTestConditionalFormatting extends TestCase {\r
+public abstract class BaseTestConditionalFormatting {\r
private final ITestDataProvider _testDataProvider;\r
\r
public BaseTestConditionalFormatting(ITestDataProvider testDataProvider){\r
\r
protected abstract void assertColour(String hexExpected, Color actual);\r
\r
- public void testBasic() {\r
+ @Test\r
+ public void testBasic() throws IOException {\r
Workbook wb = _testDataProvider.createWorkbook();\r
Sheet sh = wb.createSheet();\r
SheetConditionalFormatting sheetCF = sh.getSheetConditionalFormatting();\r
} catch (IllegalArgumentException e) {\r
assertTrue(e.getMessage().startsWith("Number of rules must not exceed 3"));\r
}\r
+ wb.close();\r
}\r
\r
/**\r
* Test format conditions based on a boolean formula\r
*/\r
+ @Test\r
@SuppressWarnings("deprecation")\r
- public void testBooleanFormulaConditions() {\r
+ public void testBooleanFormulaConditions() throws IOException {\r
Workbook wb = _testDataProvider.createWorkbook();\r
Sheet sh = wb.createSheet();\r
SheetConditionalFormatting sheetCF = sh.getSheetConditionalFormatting();\r
CellRangeAddress[] ranges2 = sheetCF.getConditionalFormattingAt(formatIndex2).getFormattingRanges();\r
assertEquals(1, ranges2.length);\r
assertEquals("B1:B3", ranges2[0].formatAsString());\r
+ wb.close();\r
}\r
\r
+ @Test\r
@SuppressWarnings("deprecation")\r
- public void testSingleFormulaConditions() {\r
+ public void testSingleFormulaConditions() throws IOException {\r
Workbook wb = _testDataProvider.createWorkbook();\r
Sheet sh = wb.createSheet();\r
SheetConditionalFormatting sheetCF = sh.getSheetConditionalFormatting();\r
assertEquals("0", rule9.getFormula1());\r
assertEquals("5", rule9.getFormula2());\r
assertEquals(ComparisonOperator.NOT_BETWEEN, rule9.getComparisonOperation());\r
+ \r
+ wb.close();\r
}\r
\r
+ @Test\r
@SuppressWarnings("deprecation")\r
- public void testCopy() {\r
+ public void testCopy() throws IOException {\r
Workbook wb = _testDataProvider.createWorkbook();\r
Sheet sheet1 = wb.createSheet();\r
Sheet sheet2 = wb.createSheet();\r
assertEquals("15", sheet2cf.getRule(1).getFormula1());\r
assertEquals(ComparisonOperator.NOT_EQUAL, sheet2cf.getRule(1).getComparisonOperation());\r
assertEquals(ConditionalFormattingRule.CONDITION_TYPE_CELL_VALUE_IS, sheet2cf.getRule(1).getConditionType());\r
+ \r
+ wb.close();\r
}\r
\r
- public void testRemove() {\r
+ @Test\r
+ public void testRemove() throws IOException {\r
Workbook wb = _testDataProvider.createWorkbook();\r
Sheet sheet1 = wb.createSheet();\r
SheetConditionalFormatting sheetCF = sheet1.getSheetConditionalFormatting();\r
} catch (IllegalArgumentException e) {\r
assertTrue(e.getMessage().startsWith("Specified CF index 0 is outside the allowable range"));\r
}\r
+ \r
+ wb.close();\r
}\r
\r
- public void testCreateCF() {\r
+ @Test\r
+ public void testCreateCF() throws IOException {\r
Workbook workbook = _testDataProvider.createWorkbook();\r
Sheet sheet = workbook.createSheet();\r
String formula = "7";\r
rule2 = cf.getRule(1);\r
assertEquals("2",rule2.getFormula2());\r
assertEquals("1",rule2.getFormula1());\r
+ \r
+ workbook.close();\r
}\r
\r
- public void testClone() {\r
+ @Test\r
+ public void testClone() throws IOException {\r
\r
Workbook wb = _testDataProvider.createWorkbook();\r
Sheet sheet = wb.createSheet();\r
\r
try {\r
wb.cloneSheet(0);\r
+ assertEquals(2, wb.getNumberOfSheets());\r
} catch (RuntimeException e) {\r
if (e.getMessage().indexOf("needs to define a clone method") > 0) {\r
fail("Indentified bug 45682");\r
}\r
throw e;\r
+ } finally {\r
+ wb.close();\r
}\r
- assertEquals(2, wb.getNumberOfSheets());\r
}\r
\r
- public void testShiftRows() {\r
+ @Test\r
+ public void testShiftRows() throws IOException {\r
Workbook wb = _testDataProvider.createWorkbook();\r
Sheet sheet = wb.createSheet();\r
\r
cf2 = sheetCF.getConditionalFormattingAt(1);\r
assertEquals("SUM(A10:A21)", cf2.getRule(0).getFormula1());\r
assertEquals("1+SUM(#REF!)", cf2.getRule(0).getFormula2());\r
+\r
+ wb.close();\r
}\r
\r
- protected void testRead(String filename){\r
+ protected void testRead(String filename) throws IOException {\r
Workbook wb = _testDataProvider.openSampleWorkbook(filename);\r
Sheet sh = wb.getSheet("CF");\r
SheetConditionalFormatting sheetCF = sh.getSheetConditionalFormatting();\r
assertEquals(ComparisonOperator.BETWEEN, rule5.getComparisonOperation());\r
assertEquals("\"A\"", rule5.getFormula1());\r
assertEquals("\"AAA\"", rule5.getFormula2());\r
+ \r
+ wb.close();\r
}\r
\r
- public void testReadOffice2007(String filename) {\r
+ public void testReadOffice2007(String filename) throws IOException {\r
Workbook wb = _testDataProvider.openSampleWorkbook(filename);\r
Sheet s = wb.getSheet("CF");\r
ConditionalFormatting cf = null;\r
\r
// Mixed icons - Column U\r
// TODO Support EXT formattings\r
+ \r
+ wb.close();\r
}\r
\r
private void assertDataBar(ConditionalFormatting cf, String color) {\r
}\r
}\r
\r
- public void testCreateFontFormatting() {\r
+ @Test\r
+ public void testCreateFontFormatting() throws IOException {\r
Workbook workbook = _testDataProvider.createWorkbook();\r
Sheet sheet = workbook.createSheet();\r
\r
assertEquals(FontFormatting.U_DOUBLE, r1fp.getUnderlineType());\r
assertEquals(IndexedColors.BLUE.index, r1fp.getFontColorIndex());\r
\r
+ workbook.close();\r
}\r
\r
- public void testCreatePatternFormatting() {\r
+ @Test\r
+ public void testCreatePatternFormatting() throws IOException {\r
Workbook workbook = _testDataProvider.createWorkbook();\r
Sheet sheet = workbook.createSheet();\r
\r
assertEquals(IndexedColors.RED.index, r1fp.getFillBackgroundColor());\r
assertEquals(IndexedColors.BLUE.index, r1fp.getFillForegroundColor());\r
assertEquals(PatternFormatting.BRICKS, r1fp.getFillPattern());\r
+ \r
+ workbook.close();\r
}\r
\r
- public void testCreateBorderFormatting() {\r
+ @Test\r
+ public void testCreateBorderFormatting() throws IOException {\r
Workbook workbook = _testDataProvider.createWorkbook();\r
Sheet sheet = workbook.createSheet();\r
\r
assertEquals(BorderFormatting.BORDER_THICK, r1fp.getBorderTop());\r
assertEquals(BorderFormatting.BORDER_THIN, r1fp.getBorderLeft());\r
assertEquals(BorderFormatting.BORDER_HAIR, r1fp.getBorderRight());\r
+ \r
+ workbook.close();\r
}\r
\r
- public void testCreateIconFormatting() {\r
- Workbook workbook = _testDataProvider.createWorkbook();\r
- Sheet sheet = workbook.createSheet();\r
+ @Test\r
+ public void testCreateIconFormatting() throws IOException {\r
+ Workbook wb1 = _testDataProvider.createWorkbook();\r
+ Sheet sheet = wb1.createSheet();\r
\r
SheetConditionalFormatting sheetCF = sheet.getSheetConditionalFormatting();\r
ConditionalFormattingRule rule1 = \r
\r
CellRangeAddress [] regions = { CellRangeAddress.valueOf("A1:A5") };\r
sheetCF.addConditionalFormatting(regions, rule1);\r
- \r
+\r
// Save, re-load and re-check\r
- workbook = _testDataProvider.writeOutAndReadBack(workbook);\r
+ Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);\r
+ wb1.close();\r
+ sheet = wb2.getSheetAt(0);\r
sheetCF = sheet.getSheetConditionalFormatting();\r
assertEquals(1, sheetCF.getNumConditionalFormattings());\r
\r
assertEquals(RangeType.PERCENT,iconFmt.getThresholds()[2].getRangeType());\r
assertEquals(RangeType.MAX, iconFmt.getThresholds()[3].getRangeType());\r
assertEquals(null, iconFmt.getThresholds()[0].getValue());\r
- assertEquals(10d, iconFmt.getThresholds()[1].getValue());\r
- assertEquals(75d, iconFmt.getThresholds()[2].getValue());\r
+ assertEquals(10d, iconFmt.getThresholds()[1].getValue(), 0);\r
+ assertEquals(75d, iconFmt.getThresholds()[2].getValue(), 0);\r
assertEquals(null, iconFmt.getThresholds()[3].getValue());\r
+ \r
+ wb2.close();\r
}\r
\r
- public void testCreateColorScaleFormatting() {\r
- Workbook workbook = _testDataProvider.createWorkbook();\r
- Sheet sheet = workbook.createSheet();\r
+ @Test\r
+ public void testCreateColorScaleFormatting() throws IOException {\r
+ Workbook wb1 = _testDataProvider.createWorkbook();\r
+ Sheet sheet = wb1.createSheet();\r
\r
SheetConditionalFormatting sheetCF = sheet.getSheetConditionalFormatting();\r
ConditionalFormattingRule rule1 = \r
sheetCF.addConditionalFormatting(regions, rule1);\r
\r
// Save, re-load and re-check\r
- workbook = _testDataProvider.writeOutAndReadBack(workbook);\r
+ Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);\r
+ wb1.close();\r
+ sheet = wb2.getSheetAt(0);\r
sheetCF = sheet.getSheetConditionalFormatting();\r
assertEquals(1, sheetCF.getNumConditionalFormattings());\r
\r
assertEquals(RangeType.NUMBER, clrFmt.getThresholds()[1].getRangeType());\r
assertEquals(RangeType.MAX, clrFmt.getThresholds()[2].getRangeType());\r
assertEquals(null, clrFmt.getThresholds()[0].getValue());\r
- assertEquals(10d, clrFmt.getThresholds()[1].getValue());\r
+ assertEquals(10d, clrFmt.getThresholds()[1].getValue(), 0);\r
assertEquals(null, clrFmt.getThresholds()[2].getValue());\r
+ \r
+ wb2.close();\r
}\r
\r
- public void testCreateDataBarFormatting() {\r
- Workbook workbook = _testDataProvider.createWorkbook();\r
- Sheet sheet = workbook.createSheet();\r
+ @Test\r
+ public void testCreateDataBarFormatting() throws IOException {\r
+ Workbook wb1 = _testDataProvider.createWorkbook();\r
+ Sheet sheet = wb1.createSheet();\r
\r
String colorHex = "FFFFEB84";\r
- ExtendedColor color = workbook.getCreationHelper().createExtendedColor();\r
+ ExtendedColor color = wb1.getCreationHelper().createExtendedColor();\r
color.setARGBHex(colorHex);\r
SheetConditionalFormatting sheetCF = sheet.getSheetConditionalFormatting();\r
ConditionalFormattingRule rule1 = \r
sheetCF.addConditionalFormatting(regions, rule1);\r
\r
// Save, re-load and re-check\r
- workbook = _testDataProvider.writeOutAndReadBack(workbook);\r
+ Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);\r
+ wb1.close();\r
+ sheet = wb2.getSheetAt(0);\r
sheetCF = sheet.getSheetConditionalFormatting();\r
assertEquals(1, sheetCF.getNumConditionalFormattings());\r
\r
assertEquals(RangeType.MAX, dbFmt.getMaxThreshold().getRangeType());\r
assertEquals(null, dbFmt.getMinThreshold().getValue());\r
assertEquals(null, dbFmt.getMaxThreshold().getValue());\r
+ \r
+ wb2.close();\r
}\r
\r
- public void testBug55380() {\r
+ @Test\r
+ public void testBug55380() throws IOException {\r
Workbook wb = _testDataProvider.createWorkbook();\r
Sheet sheet = wb.createSheet();\r
CellRangeAddress[] ranges = new CellRangeAddress[] {\r
CellRangeAddress.valueOf("C9:D30"), CellRangeAddress.valueOf("C7:C31")\r
};\r
ConditionalFormattingRule rule = sheet.getSheetConditionalFormatting().createConditionalFormattingRule("$A$1>0");\r
- sheet.getSheetConditionalFormatting().addConditionalFormatting(ranges, rule); \r
+ sheet.getSheetConditionalFormatting().addConditionalFormatting(ranges, rule);\r
+ wb.close();\r
}\r
-}\r
+}
\ No newline at end of file
package org.apache.poi.ss.usermodel;
-import junit.framework.AssertionFailedError;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
import org.apache.poi.ss.ITestDataProvider;
+import org.junit.Test;
/**
* Common superclass for testing implementatiosn of{@link FormulaEvaluator}
*
* @author Yegor Kozlov
*/
-public abstract class BaseTestFormulaEvaluator extends TestCase {
+public abstract class BaseTestFormulaEvaluator {
protected final ITestDataProvider _testDataProvider;
_testDataProvider = testDataProvider;
}
- public void testSimpleArithmetic() {
+ @Test
+ public void testSimpleArithmetic() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
Sheet s = wb.createSheet();
Row r = s.createRow(0);
assertEquals(6.0, c1.getNumericCellValue(), 0.0001);
assertEquals(5.0, c2.getNumericCellValue(), 0.0001);
+
+ wb.close();
}
- public void testSumCount() {
+ @Test
+ public void testSumCount() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
Sheet s = wb.createSheet();
Row r = s.createRow(0);
assertEquals(17.5, c2.getNumericCellValue(), 0.0001);
assertEquals(1, c3.getNumericCellValue(), 0.0001);
assertEquals(4, c4.getNumericCellValue(), 0.0001);
+
+ wb.close();
}
- public void baseTestSharedFormulas(String sampleFile){
+ public void baseTestSharedFormulas(String sampleFile) throws IOException {
Workbook wb = _testDataProvider.openSampleWorkbook(sampleFile);
Sheet sheet = wb.getSheetAt(0);
cell = sheet.getRow(4).getCell(0);
assertEquals("B5", cell.getCellFormula());
assertEquals("UniqueDocumentNumberID", evaluator.evaluate(cell).getStringValue());
+
+ wb.close();
}
/**
* Test creation / evaluation of formulas with sheet-level names
*/
- public void testSheetLevelFormulas(){
+ @Test
+ public void testSheetLevelFormulas() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
Row row;
assertEquals(5.0, evaluator.evaluate(sh2.getRow(0).getCell(1)).getNumberValue(), 0.0);
assertEquals(15.0, evaluator.evaluate(sh2.getRow(0).getCell(2)).getNumberValue(), 0.0);
+
+ wb.close();
}
- public void testFullColumnRefs() {
+ @Test
+ public void testFullColumnRefs() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
Sheet sheet = wb.createSheet("Sheet1");
Row row = sheet.createRow(0);
FormulaEvaluator fe = wb.getCreationHelper().createFormulaEvaluator();
assertEquals(26.0, fe.evaluate(cell0).getNumberValue(), 0.0);
assertEquals(56.0, fe.evaluate(cell1).getNumberValue(), 0.0);
+
+ wb.close();
}
- public void testRepeatedEvaluation() {
+ @Test
+ public void testRepeatedEvaluation() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
FormulaEvaluator fe = wb.getCreationHelper().createFormulaEvaluator();
Sheet sheet = wb.createSheet("Sheet1");
fe.clearAllCachedResultValues();
cellValue = fe.evaluate(c);
assertEquals(40455.0, cellValue.getNumberValue(), 0.0);
+
+ wb.close();
}
private static void setValue(Sheet sheet, int rowIndex, int colIndex, double value) {
* {@link FormulaEvaluator#evaluate(org.apache.poi.ss.usermodel.Cell)} should behave the same whether the cell
* is <code>null</code> or blank.
*/
- public void testEvaluateBlank() {
+ @Test
+ public void testEvaluateBlank() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
FormulaEvaluator fe = wb.getCreationHelper().createFormulaEvaluator();
assertNull(fe.evaluate(null));
Sheet sheet = wb.createSheet("Sheet1");
Cell cell = sheet.createRow(0).createCell(0);
assertNull(fe.evaluate(cell));
+ wb.close();
}
/**
* Test for bug due to attempt to convert a cached formula error result to a boolean
*/
- public void testUpdateCachedFormulaResultFromErrorToNumber_bug46479() {
+ @Test
+ public void testUpdateCachedFormulaResultFromErrorToNumber_bug46479() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
Sheet sheet = wb.createSheet("Sheet1");
fe.evaluateInCell(cellB1);
} catch (IllegalStateException e) {
if (e.getMessage().equals("Cannot get a numeric value from a error formula cell")) {
- throw new AssertionFailedError("Identified bug 46479a");
+ fail("Identified bug 46479a");
}
}
assertEquals(3.5, cellB1.getNumericCellValue(), 0.0);
+
+ wb.close();
}
-
- public void testRounding_bug51339() {
+ @Test
+ public void testRounding_bug51339() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
Sheet sheet = wb.createSheet("Sheet1");
Row row = sheet.createRow(0);
assertEquals(2162.62, fe.evaluateInCell(cellB1).getNumericCellValue(), 0.0);
assertEquals(2162.62, fe.evaluateInCell(cellC1).getNumericCellValue(), 0.0);
assertEquals(2162.61, fe.evaluateInCell(cellD1).getNumericCellValue(), 0.0);
+
+ wb.close();
}
}
\ No newline at end of file
}
@Test
- public void createRow() {
+ public void createRow() throws IOException {
Workbook workbook = _testDataProvider.createWorkbook();
Sheet sheet = workbook.createSheet();
assertEquals(0, sheet.getPhysicalNumberOfRows());
Row row2_ovrewritten_ref = it2.next();
assertSame(row2_ovrewritten, row2_ovrewritten_ref);
assertEquals(100.0, row2_ovrewritten_ref.getCell(0).getNumericCellValue(), 0.0);
+
+ workbook.close();
}
- @Test
- public void createRowBeforeFirstRow() {
+ @Test(expected=IllegalArgumentException.class)
+ public void createRowBeforeFirstRow() throws IOException {
final Workbook workbook = _testDataProvider.createWorkbook();
final Sheet sh = workbook.createSheet();
sh.createRow(0);
try {
+ // Negative rows not allowed
sh.createRow(-1);
- fail("Negative rows not allowed");
- } catch (final IllegalArgumentException e) {
- // expected
+ } finally {
+ workbook.close();
}
}
- protected void createRowAfterLastRow(SpreadsheetVersion version) {
+ protected void createRowAfterLastRow(SpreadsheetVersion version) throws IOException {
final Workbook workbook = _testDataProvider.createWorkbook();
final Sheet sh = workbook.createSheet();
sh.createRow(version.getLastRowIndex());
try {
+ // Row number must be between 0 and last row
sh.createRow(version.getLastRowIndex() + 1);
- fail("Row number must be between 0 and " + version.getLastColumnIndex());
- } catch (final IllegalArgumentException e) {
- // expected
+ } finally {
+ workbook.close();
}
}
@Test
- public void removeRow() {
+ public void removeRow() throws IOException {
Workbook workbook = _testDataProvider.createWorkbook();
Sheet sheet1 = workbook.createSheet();
assertEquals(0, sheet1.getPhysicalNumberOfRows());
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Specified row does not belong to this sheet");
sheet2.removeRow(row3);
+
+ workbook.close();
}
@Test
- public void cloneSheet() {
+ public void cloneSheet() throws IOException {
Workbook workbook = _testDataProvider.createWorkbook();
CreationHelper factory = workbook.getCreationHelper();
Sheet sheet = workbook.createSheet("Test Clone");
}
assertEquals(clonedRow.getCell(0).getRichStringCellValue().getString(), "clone_test");
assertEquals(clonedRow.getCell(1).getCellFormula(), "SIN(1)");
+
+ workbook.close();
}
/** tests that the sheet name for multiple clones of the same sheet is unique
* BUG 37416
*/
@Test
- public void cloneSheetMultipleTimes() {
+ public void cloneSheetMultipleTimes() throws IOException {
Workbook workbook = _testDataProvider.createWorkbook();
CreationHelper factory = workbook.getCreationHelper();
Sheet sheet = workbook.createSheet("Test Clone");
workbook.createSheet("abc ( 123)");
workbook.cloneSheet(0);
assertEquals("abc (124)", workbook.getSheetName(1));
+
+ workbook.close();
}
/**
* Setting landscape and portrait stuff on new sheets
*/
@Test
- public void printSetupLandscapeNew() {
- Workbook workbook = _testDataProvider.createWorkbook();
- Sheet sheetL = workbook.createSheet("LandscapeS");
- Sheet sheetP = workbook.createSheet("LandscapeP");
+ public void printSetupLandscapeNew() throws IOException {
+ Workbook wb1 = _testDataProvider.createWorkbook();
+ Sheet sheetL = wb1.createSheet("LandscapeS");
+ Sheet sheetP = wb1.createSheet("LandscapeP");
// Check two aspects of the print setup
assertFalse(sheetL.getPrintSetup().getLandscape());
assertEquals(3, sheetP.getPrintSetup().getCopies());
// Save and re-load, and check still there
- workbook = _testDataProvider.writeOutAndReadBack(workbook);
- sheetL = workbook.getSheet("LandscapeS");
- sheetP = workbook.getSheet("LandscapeP");
+ Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+ wb1.close();
+ sheetL = wb2.getSheet("LandscapeS");
+ sheetP = wb2.getSheet("LandscapeP");
assertTrue(sheetL.getPrintSetup().getLandscape());
assertFalse(sheetP.getPrintSetup().getLandscape());
assertEquals(1, sheetL.getPrintSetup().getCopies());
assertEquals(3, sheetP.getPrintSetup().getCopies());
+ wb2.close();
}
/**
*
*/
@Test
- public void addMerged() {
+ public void addMerged() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
Sheet sheet = wb.createSheet();
assertEquals(0, sheet.getNumMergedRegions());
assertEquals("Maximum row number is " + ssVersion.getLastRowIndex(), e.getMessage());
}
assertEquals(1, sheet.getNumMergedRegions());
+
+ wb.close();
}
/**
*
*/
@Test
- public void removeMerged() {
+ public void removeMerged() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
Sheet sheet = wb.createSheet();
CellRangeAddress region = new CellRangeAddress(0, 1, 0, 1);
assertTrue("there isn't more than one merged region in there", 1 <= sheet.getNumMergedRegions());
region = sheet.getMergedRegion(0);
assertEquals("the merged row to doesnt match the one we put in ", 4, region.getLastRow());
+
+ wb.close();
}
@Test
- public void shiftMerged() {
+ public void shiftMerged() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
CreationHelper factory = wb.getCreationHelper();
Sheet sheet = wb.createSheet();
region = sheet.getMergedRegion(0);
assertEquals("Merged region not moved over to row 2", 2, region.getFirstRow());
+
+ wb.close();
}
/**
* Tests the display of gridlines, formulas, and rowcolheadings.
- * @author Shawn Laubach (slaubach at apache dot org)
*/
@Test
- public void displayOptions() {
- Workbook wb = _testDataProvider.createWorkbook();
- Sheet sheet = wb.createSheet();
+ public void displayOptions() throws IOException {
+ Workbook wb1 = _testDataProvider.createWorkbook();
+ Sheet sheet = wb1.createSheet();
assertEquals(sheet.isDisplayGridlines(), true);
assertEquals(sheet.isDisplayRowColHeadings(), true);
sheet.setDisplayFormulas(true);
sheet.setDisplayZeros(false);
- wb = _testDataProvider.writeOutAndReadBack(wb);
- sheet = wb.getSheetAt(0);
+ Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+ wb1.close();
+ sheet = wb2.getSheetAt(0);
assertEquals(sheet.isDisplayGridlines(), false);
assertEquals(sheet.isDisplayRowColHeadings(), false);
assertEquals(sheet.isDisplayFormulas(), true);
assertEquals(sheet.isDisplayZeros(), false);
+
+ wb2.close();
}
@Test
- public void columnWidth() {
- Workbook wb = _testDataProvider.createWorkbook();
- Sheet sheet = wb.createSheet();
+ public void columnWidth() throws IOException {
+ Workbook wb1 = _testDataProvider.createWorkbook();
+ Sheet sheet = wb1.createSheet();
//default column width measured in characters
sheet.setDefaultColumnWidth(10);
}
//serialize and read again
- wb = _testDataProvider.writeOutAndReadBack(wb);
+ Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+ wb1.close();
- sheet = wb.getSheetAt(0);
+ sheet = wb2.getSheetAt(0);
assertEquals(20, sheet.getDefaultColumnWidth());
//columns A-C have default width
assertEquals(256*20, sheet.getColumnWidth(0));
assertEquals(w, sheet.getColumnWidth(i));
}
assertEquals(40000, sheet.getColumnWidth(10));
+
+ wb2.close();
}
@Test
- public void defaultRowHeight() {
+ public void defaultRowHeight() throws IOException {
Workbook workbook = _testDataProvider.createWorkbook();
Sheet sheet = workbook.createSheet();
sheet.setDefaultRowHeightInPoints(15);
sheet.setDefaultRowHeightInPoints(17.5f);
assertEquals(17.5f, sheet.getDefaultRowHeightInPoints(), 0F);
assertEquals((short)(17.5f*20), sheet.getDefaultRowHeight());
+
+ workbook.close();
}
/** cell with formula becomes null on cloning a sheet*/
@Test
- public void bug35084() {
+ public void bug35084() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
Sheet s = wb.createSheet("Sheet1");
Row r = s.createRow(0);
assertEquals("double", r.getCell(0).getNumericCellValue(), 1, 0); // sanity check
assertNotNull(r.getCell(1));
assertEquals("formula", r.getCell(1).getCellFormula(), "A1*2");
+ wb.close();
}
/** test that new default column styles get applied */
@Test
- public void defaultColumnStyle() {
+ public void defaultColumnStyle() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
CellStyle style = wb.createCellStyle();
Sheet sheet = wb.createSheet();
CellStyle style2 = cell.getCellStyle();
assertNotNull(style2);
assertEquals("style should match", style.getIndex(), style2.getIndex());
+ wb.close();
}
@Test
- public void outlineProperties() {
- Workbook wb = _testDataProvider.createWorkbook();
+ public void outlineProperties() throws IOException {
+ Workbook wb1 = _testDataProvider.createWorkbook();
- Sheet sheet = wb.createSheet();
+ Sheet sheet = wb1.createSheet();
//TODO defaults are different in HSSF and XSSF
//assertTrue(sheet.getRowSumsBelow());
assertTrue(sheet.getRowSumsBelow());
assertTrue(sheet.getRowSumsRight());
- wb = _testDataProvider.writeOutAndReadBack(wb);
- sheet = wb.getSheetAt(0);
+ Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+ wb1.close();
+ sheet = wb2.getSheetAt(0);
assertTrue(sheet.getRowSumsBelow());
assertTrue(sheet.getRowSumsRight());
+ wb2.close();
}
/**
* Test basic display properties
*/
@Test
- public void sheetProperties() {
+ public void sheetProperties() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
Sheet sheet = wb.createSheet();
assertTrue(sheet.getFitToPage());
sheet.setFitToPage(false);
assertFalse(sheet.getFitToPage());
+
+ wb.close();
}
- public void baseTestGetSetMargin(double[] defaultMargins) {
+ public void baseTestGetSetMargin(double[] defaultMargins) throws IOException {
double marginLeft = defaultMargins[0];
double marginRight = defaultMargins[1];
double marginTop = defaultMargins[2];
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Unknown margin constant: 65");
sheet.setMargin((short) 65, 15);
+
+ workbook.close();
}
@Test
- public void rowBreaks() {
+ public void rowBreaks() throws IOException {
Workbook workbook = _testDataProvider.createWorkbook();
Sheet sheet = workbook.createSheet();
//Sheet#getRowBreaks() returns an empty array if no row breaks are defined
assertFalse(sheet.isRowBroken(1));
assertFalse(sheet.isRowBroken(15));
+
+ workbook.close();
}
@Test
- public void columnBreaks() {
+ public void columnBreaks() throws IOException {
Workbook workbook = _testDataProvider.createWorkbook();
Sheet sheet = workbook.createSheet();
assertNotNull(sheet.getColumnBreaks());
assertFalse(sheet.isColumnBroken(11));
assertFalse(sheet.isColumnBroken(12));
+ workbook.close();
}
@Test
- public void getFirstLastRowNum() {
+ public void getFirstLastRowNum() throws IOException {
Workbook workbook = _testDataProvider.createWorkbook();
Sheet sheet = workbook.createSheet("Sheet 1");
sheet.createRow(9);
sheet.createRow(1);
assertEquals(0, sheet.getFirstRowNum());
assertEquals(9, sheet.getLastRowNum());
+ workbook.close();
}
@Test
- public void getFooter() {
+ public void getFooter() throws IOException {
Workbook workbook = _testDataProvider.createWorkbook();
Sheet sheet = workbook.createSheet("Sheet 1");
assertNotNull(sheet.getFooter());
sheet.getFooter().setCenter("test center footer");
assertEquals("test center footer", sheet.getFooter().getCenter());
+ workbook.close();
}
@Test
- public void getSetColumnHidden() {
+ public void getSetColumnHidden() throws IOException {
Workbook workbook = _testDataProvider.createWorkbook();
Sheet sheet = workbook.createSheet("Sheet 1");
sheet.setColumnHidden(2, true);
assertTrue(sheet.isColumnHidden(2));
+ workbook.close();
}
@Test
- public void protectSheet() {
+ public void protectSheet() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
Sheet sheet = wb.createSheet();
assertFalse(sheet.getProtect());
assertTrue(sheet.getProtect());
sheet.protectSheet(null);
assertFalse(sheet.getProtect());
-
+ wb.close();
}
@Test
- public void createFreezePane() {
+ public void createFreezePane() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
// create a workbook
Sheet sheet = wb.createSheet();
sheet.createFreezePane(0, 0);
// If both colSplit and rowSplit are zero then the existing freeze pane is removed
assertNull(sheet.getPaneInformation());
+
+ wb.close();
}
@Test
- public void getRepeatingRowsAndColumns() {
+ public void getRepeatingRowsAndColumns() throws IOException {
Workbook wb = _testDataProvider.openSampleWorkbook(
"RepeatingRowsCols."
+ _testDataProvider.getStandardFileNameExtension());
checkRepeatingRowsAndColumns(wb.getSheetAt(1), "1:1", null);
checkRepeatingRowsAndColumns(wb.getSheetAt(2), null, "A:A");
checkRepeatingRowsAndColumns(wb.getSheetAt(3), "2:3", "A:B");
+ wb.close();
}
@Test
- public void setRepeatingRowsAndColumnsBug47294(){
+ public void setRepeatingRowsAndColumnsBug47294() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
Sheet sheet1 = wb.createSheet();
sheet1.setRepeatingRows(CellRangeAddress.valueOf("1:4"));
Sheet sheet2 = wb.createSheet("My' Sheet");
sheet2.setRepeatingRows(CellRangeAddress.valueOf("1:4"));
assertEquals("1:4", sheet2.getRepeatingRows().formatAsString());
+ wb.close();
}
@Test
- public void setRepeatingRowsAndColumns() {
- Workbook wb = _testDataProvider.createWorkbook();
- Sheet sheet1 = wb.createSheet("Sheet1");
- Sheet sheet2 = wb.createSheet("Sheet2");
- Sheet sheet3 = wb.createSheet("Sheet3");
+ public void setRepeatingRowsAndColumns() throws IOException {
+ Workbook wb1 = _testDataProvider.createWorkbook();
+ Sheet sheet1 = wb1.createSheet("Sheet1");
+ Sheet sheet2 = wb1.createSheet("Sheet2");
+ Sheet sheet3 = wb1.createSheet("Sheet3");
checkRepeatingRowsAndColumns(sheet1, null, null);
checkRepeatingRowsAndColumns(sheet3, "1:4", "A:A");
// write out, read back, and test refrain...
- wb = _testDataProvider.writeOutAndReadBack(wb);
- sheet1 = wb.getSheetAt(0);
- sheet2 = wb.getSheetAt(1);
- sheet3 = wb.getSheetAt(2);
+ Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+ wb1.close();
+ sheet1 = wb2.getSheetAt(0);
+ sheet2 = wb2.getSheetAt(1);
+ sheet3 = wb2.getSheetAt(2);
checkRepeatingRowsAndColumns(sheet1, "4:5", null);
checkRepeatingRowsAndColumns(sheet2, null, "A:C");
sheet3.setRepeatingColumns(null);
checkRepeatingRowsAndColumns(sheet3, null, null);
+ wb2.close();
}
private void checkRepeatingRowsAndColumns(
}
@Test
- public void baseZoom() {
+ public void baseZoom() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
Sheet sheet = wb.createSheet();
// here we can only verify that setting some zoom values works, range-checking is different between the implementations
sheet.setZoom(3,4);
+ wb.close();
}
@Test
- public void baseShowInPane() {
+ public void baseShowInPane() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
Sheet sheet = wb.createSheet();
sheet.showInPane(2, 3);
+ wb.close();
}
@Test
- public void bug55723(){
+ public void bug55723() throws IOException {
Workbook wb = _testDataProvider.createWorkbook();
Sheet sheet = wb.createSheet();
filter = sheet.setAutoFilter(range);
assertNotNull(filter);
// there seems to be currently no generic way to check the setting...
+ wb.close();
}
@Test
}
@Test
- public void showInPaneManyRowsBug55248() {
- Workbook workbook = _testDataProvider.createWorkbook();
- Sheet sheet = workbook.createSheet("Sheet 1");
+ public void showInPaneManyRowsBug55248() throws IOException {
+ Workbook wb1 = _testDataProvider.createWorkbook();
+ Sheet sheet = wb1.createSheet("Sheet 1");
sheet.showInPane(0, 0);
int i = 0;
sheet.showInPane(i, i);
- Workbook wb = _testDataProvider.writeOutAndReadBack(workbook);
- checkRowCount(wb);
+ Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+ checkRowCount(wb2);
+
+ wb2.close();
+ wb1.close();
}
private void checkRowCount(Workbook wb) {
projects / poi.git / commitdiff