]> source.dussan.org Git - poi.git/commitdiff
close resources in junit tests
authorAndreas Beeker <kiwiwings@apache.org>
Sun, 20 Sep 2015 12:02:40 +0000 (12:02 +0000)
committerAndreas Beeker <kiwiwings@apache.org>
Sun, 20 Sep 2015 12:02:40 +0000 (12:02 +0000)
git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@1704124 13f79535-47bb-0310-9956-ffa450edef68

src/ooxml/testcases/org/apache/poi/xssf/streaming/TestSXSSFCell.java
src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFBugs.java
src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFCell.java
src/testcases/org/apache/poi/hssf/usermodel/TestBugs.java
src/testcases/org/apache/poi/ss/usermodel/BaseTestBugzillaIssues.java
src/testcases/org/apache/poi/ss/usermodel/BaseTestCell.java

index 9daf0ccb1aafe3dd41ada859df0890b8fe6312b7..f3181fd5b344130b9c4c6c34547e955c9569a7d8 100644 (file)
@@ -76,6 +76,8 @@ public class TestSXSSFCell extends BaseTestXCell {
             String t = c.getAttributeText(new QName("http://www.w3.org/XML/1998/namespace", "space"));
             c.dispose();
             assertEquals("expected xml:spaces=\"preserve\" \"" + str + "\"", "preserve", t);
+            xwb.close();
+            swb.close();
         }
     }
 }
index c7a5486cc820e97a6bfe73921cb2b4d7b46f3723..326f8b18708b6eb8ffd685efb1fdab37deca3454 100644 (file)
@@ -114,7 +114,7 @@ public final class TestXSSFBugs extends BaseTestBugzillaIssues {
      * open resulting file in Excel to check results!
      */
     @Test
-    public void bug15375_2() {
+    public void bug15375_2() throws Exception {
         bug15375(1000);
     }
 
@@ -2786,7 +2786,7 @@ public final class TestXSSFBugs extends BaseTestBugzillaIssues {
     }
 
     @Test
-    public void test55406() {
+    public void test55406() throws Exception {
         Workbook wb = XSSFTestDataSamples.openSampleWorkbook("55406_Conditional_formatting_sample.xlsx");
         Sheet sheet = wb.getSheetAt(0);
         Cell cellA1 = sheet.getRow(0).getCell(0);
@@ -2809,5 +2809,7 @@ public final class TestXSSFBugs extends BaseTestBugzillaIssues {
         assertEquals(64, cond.getConditionalFormattingAt(1).getRule(0).getPatternFormatting().getFillForegroundColor()); 
         assertEquals("ISEVEN(ROW())", cond.getConditionalFormattingAt(1).getRule(0).getFormula1());
         assertNull(((XSSFColor)cond.getConditionalFormattingAt(1).getRule(0).getPatternFormatting().getFillForegroundColorColor()).getARGBHex()); 
+        
+        wb.close();
     }
 }
index c8a237d51d373080f511df583089cb21b6681d84..e1deb4d89fb8c8a2ef0c69c75d14cc0809f60c4b 100644 (file)
@@ -57,23 +57,25 @@ public final class TestXSSFCell extends BaseTestXCell {
      * Shared String Table
      */
     @Test
-    public void test47026_1() {
-        Workbook source = _testDataProvider.openSampleWorkbook("47026.xlsm");
-        Sheet sheet = source.getSheetAt(0);
+    public void test47026_1() throws Exception {
+        Workbook wb = _testDataProvider.openSampleWorkbook("47026.xlsm");
+        Sheet sheet = wb.getSheetAt(0);
         Row row = sheet.getRow(0);
         Cell cell = row.getCell(0);
         cell.setCellType(Cell.CELL_TYPE_STRING);
         cell.setCellValue("456");
+        wb.close();
     }
 
     @Test
-    public void test47026_2() {
-        Workbook source = _testDataProvider.openSampleWorkbook("47026.xlsm");
-        Sheet sheet = source.getSheetAt(0);
+    public void test47026_2() throws Exception {
+        Workbook wb = _testDataProvider.openSampleWorkbook("47026.xlsm");
+        Sheet sheet = wb.getSheetAt(0);
         Row row = sheet.getRow(0);
         Cell cell = row.getCell(0);
         cell.setCellFormula(null);
         cell.setCellValue("456");
+        wb.close();
     }
 
     /**
@@ -84,7 +86,7 @@ public final class TestXSSFCell extends BaseTestXCell {
      * instead of using the shared string table. See bug 47206
      */
     @Test
-    public void testInlineString() {
+    public void testInlineString() throws Exception {
         XSSFWorkbook wb = (XSSFWorkbook)_testDataProvider.openSampleWorkbook("xlsx-jdbc.xlsx");
         XSSFSheet sheet = wb.getSheetAt(0);
         XSSFRow row = sheet.getRow(1);
@@ -103,13 +105,14 @@ public final class TestXSSFCell extends BaseTestXCell {
         assertEquals(STCellType.INT_INLINE_STR, cell_2.getCTCell().getT().intValue());
         assertTrue(cell_2.getCTCell().isSetIs());
         assertEquals("bar", row.getCell(2).getStringCellValue());
+        wb.close();
     }
 
     /**
      *  Bug 47278 -  xsi:nil attribute for <t> tag caused Excel 2007 to fail to open workbook
      */
     @Test
-    public void test47278() {
+    public void test47278() throws Exception {
         XSSFWorkbook wb = (XSSFWorkbook)_testDataProvider.createWorkbook();
         Sheet sheet = wb.createSheet();
         Row row = sheet.createRow(0);
@@ -129,6 +132,7 @@ public final class TestXSSFCell extends BaseTestXCell {
         cell_1.setCellValue((String)null);
         assertEquals(0, sst.getCount());
         assertEquals(Cell.CELL_TYPE_BLANK, cell_1.getCellType());
+        wb.close();
     }
 
     @Test
@@ -174,7 +178,7 @@ public final class TestXSSFCell extends BaseTestXCell {
      * Bug 47889: problems when calling XSSFCell.getStringCellValue() on a workbook created in Gnumeric
      */
     @Test
-    public void test47889() {
+    public void test47889() throws Exception {
         XSSFWorkbook wb = (XSSFWorkbook)_testDataProvider.openSampleWorkbook("47889.xlsx");
         XSSFSheet sh = wb.getSheetAt(0);
 
@@ -197,12 +201,13 @@ public final class TestXSSFCell extends BaseTestXCell {
         //Gnumeric produces spreadsheets without styles
         //make sure we return null for that instead of throwing OutOfBounds
         assertEquals(null, cell.getCellStyle());
+        wb.close();
     }
 
     @Test
-    public void testMissingRAttribute() {
-        XSSFWorkbook wb = new XSSFWorkbook();
-        XSSFSheet sheet = wb.createSheet();
+    public void testMissingRAttribute() throws Exception {
+        XSSFWorkbook wb1 = new XSSFWorkbook();
+        XSSFSheet sheet = wb1.createSheet();
         XSSFRow row = sheet.createRow(0);
         XSSFCell a1 = row.createCell(0);
         a1.setCellValue("A1");
@@ -220,9 +225,12 @@ public final class TestXSSFCell extends BaseTestXCell {
 
         assertCellsWithMissingR(row);
 
-        XSSFWorkbook wbNew = (XSSFWorkbook)_testDataProvider.writeOutAndReadBack(wb);
-        row = wbNew.getSheetAt(0).getRow(0);
+        XSSFWorkbook wb2 = (XSSFWorkbook)_testDataProvider.writeOutAndReadBack(wb1);
+        row = wb2.getSheetAt(0).getRow(0);
         assertCellsWithMissingR(row);
+        
+        wb2.close();
+        wb1.close();
     }
 
     private void assertCellsWithMissingR(XSSFRow row){
@@ -252,7 +260,7 @@ public final class TestXSSFCell extends BaseTestXCell {
     }
 
     @Test
-    public void testMissingRAttributeBug54288() {
+    public void testMissingRAttributeBug54288() throws Exception {
         // workbook with cells missing the R attribute
         XSSFWorkbook wb = (XSSFWorkbook)_testDataProvider.openSampleWorkbook("54288.xlsx");
         // same workbook re-saved in Excel 2010, the R attribute is updated for every cell with the right value.
@@ -290,32 +298,34 @@ public final class TestXSSFCell extends BaseTestXCell {
 
             }
         }
+        wbRef.close();
+        wb.close();
     }
     
     @Test
     public void test56170() throws IOException {
-        final Workbook wb = XSSFTestDataSamples.openSampleWorkbook("56170.xlsx");
-        final XSSFSheet sheet = (XSSFSheet) wb.getSheetAt(0);
+        final Workbook wb1 = XSSFTestDataSamples.openSampleWorkbook("56170.xlsx");
+        final XSSFSheet sheet = (XSSFSheet) wb1.getSheetAt(0);
 
-        Workbook wbRead = XSSFTestDataSamples.writeOutAndReadBack(wb);
+        Workbook wb2 = XSSFTestDataSamples.writeOutAndReadBack(wb1);
         Cell cell;
         
         // add some contents to table so that the table will need expansion
         Row row = sheet.getRow(0);
-        wbRead = XSSFTestDataSamples.writeOutAndReadBack(wb);
+        Workbook wb3 = XSSFTestDataSamples.writeOutAndReadBack(wb2);
         cell = row.createCell(0);
-        wbRead = XSSFTestDataSamples.writeOutAndReadBack(wb);
+        Workbook wb4 = XSSFTestDataSamples.writeOutAndReadBack(wb3);
         cell.setCellValue("demo1");
-        wbRead = XSSFTestDataSamples.writeOutAndReadBack(wb);
+        Workbook wb5 = XSSFTestDataSamples.writeOutAndReadBack(wb4);
         cell = row.createCell(1);
-        wbRead = XSSFTestDataSamples.writeOutAndReadBack(wb);
+        Workbook wb6 = XSSFTestDataSamples.writeOutAndReadBack(wb5);
         cell.setCellValue("demo2");
-        wbRead = XSSFTestDataSamples.writeOutAndReadBack(wb);
+        Workbook wb7 = XSSFTestDataSamples.writeOutAndReadBack(wb6);
         cell = row.createCell(2);
-        wbRead = XSSFTestDataSamples.writeOutAndReadBack(wb);
+        Workbook wb8 = XSSFTestDataSamples.writeOutAndReadBack(wb7);
         cell.setCellValue("demo3");
 
-        wbRead = XSSFTestDataSamples.writeOutAndReadBack(wb);
+        Workbook wb9 = XSSFTestDataSamples.writeOutAndReadBack(wb8);
         
         row = sheet.getRow(1);
         cell = row.createCell(0);
@@ -325,7 +335,7 @@ public final class TestXSSFCell extends BaseTestXCell {
         cell = row.createCell(2);
         cell.setCellValue("demo3");
 
-        wbRead = XSSFTestDataSamples.writeOutAndReadBack(wb);
+        Workbook wb10 = XSSFTestDataSamples.writeOutAndReadBack(wb9);
         
         // expand table
         XSSFTable table = sheet.getTables().get(0);
@@ -333,12 +343,20 @@ public final class TestXSSFCell extends BaseTestXCell {
         final CellReference endRef = table.getEndCellReference();
         table.getCTTable().setRef(new CellRangeAddress(startRef.getRow(), 1, startRef.getCol(), endRef.getCol()).formatAsString());
 
-        wbRead = XSSFTestDataSamples.writeOutAndReadBack(wb);
-        assertNotNull(wbRead);
-
-        /*FileOutputStream stream = new FileOutputStream("c:\\temp\\output.xlsx");
-        workbook.write(stream);
-        stream.close();*/
+        Workbook wb11 = XSSFTestDataSamples.writeOutAndReadBack(wb10);
+        assertNotNull(wb11);
+
+        wb11.close();
+        wb10.close();
+        wb9.close();
+        wb8.close();
+        wb7.close();
+        wb6.close();
+        wb5.close();
+        wb4.close();
+        wb3.close();
+        wb2.close();
+        wb1.close();
     }
     
     @Test
@@ -426,7 +444,7 @@ public final class TestXSSFCell extends BaseTestXCell {
     }
 
     @Test
-    public void testEncodingbeloAscii(){
+    public void testEncodingbeloAscii() throws Exception {
         StringBuffer sb = new StringBuffer();
         // test all possible characters
         for(int i = 0; i < Character.MAX_VALUE; i++) {
@@ -467,6 +485,13 @@ public final class TestXSSFCell extends BaseTestXCell {
                assertEquals(cell.getStringCellValue(), sCell.getStringCellValue());
                
                pos += SpreadsheetVersion.EXCEL97.getMaxTextLength();
+               
+               swbBack.close();
+               xwbBack.close();
+               wbBack.close();
+               swb.close();
+               xwb.close();
+               wb.close();
         }
     }
 }
index 92661f8aeeb574efb46f5faaf9f7c069e0b03efc..3b753bc8a8936fcbff1fa9d338fdaed29254228a 100644 (file)
@@ -29,10 +29,8 @@ import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Calendar;
@@ -76,7 +74,6 @@ import org.apache.poi.ss.usermodel.Sheet;
 import org.apache.poi.ss.usermodel.Workbook;
 import org.apache.poi.ss.util.CellRangeAddress;
 import org.apache.poi.util.LocaleUtil;
-import org.apache.poi.util.TempFile;
 import org.junit.Ignore;
 import org.junit.Test;
 
@@ -86,9 +83,6 @@ import org.junit.Test;
  *
  * <b>YK: If a bug can be tested in terms of common ss interfaces,
  *  define the test in the base class {@link BaseTestBugzillaIssues}</b>
- *
- * @author Avik Sengupta
- * @author Yegor Kozlov
  */
 public final class TestBugs extends BaseTestBugzillaIssues {
 
@@ -104,67 +98,48 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         return HSSFITestDataProvider.instance.writeOutAndReadBack(original);
     }
 
-    @SuppressWarnings("unused")
-    private static void writeTestOutputFileForViewing(HSSFWorkbook wb, String simpleFileName) {
-        if (true) { // set to false to output test files
-            return;
-        }
-        System.setProperty("poi.keep.tmp.files", "true");
-        File file;
-        try {
-            file = TempFile.createTempFile(simpleFileName + "#", ".xls");
-            OutputStream out = new FileOutputStream(file);
-            try {
-               wb.write(out);
-            } finally {
-               out.close();
-            }
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-        if (!file.exists()) {
-            throw new RuntimeException("File was not written");
-        }
-        System.out.println("Open file '" + file.getAbsolutePath() + "' in Excel");
-    }
-
     /** Test reading AND writing a complicated workbook
      *Test opening resulting sheet in excel*/
     @Test
-    public void bug15228() {
+    public void bug15228() throws Exception {
         HSSFWorkbook wb = openSample("15228.xls");
         HSSFSheet s = wb.getSheetAt(0);
         HSSFRow r = s.createRow(0);
         HSSFCell c = r.createCell(0);
         c.setCellValue(10);
-        writeTestOutputFileForViewing(wb, "test15228");
+        writeOutAndReadBack(wb).close();
+        wb.close();
     }
 
     @Test
-    public void bug13796() {
+    public void bug13796() throws Exception {
         HSSFWorkbook wb = openSample("13796.xls");
         HSSFSheet s = wb.getSheetAt(0);
         HSSFRow r = s.createRow(0);
         HSSFCell c = r.createCell(0);
         c.setCellValue(10);
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        wb.close();
     }
 
     /** test reading of a formula with a name and a cell ref in one
      **/
     @Test
-    public void bug14460() {
+    public void bug14460() throws Exception {
         HSSFWorkbook wb = openSample("14460.xls");
         wb.getSheetAt(0);
+        wb.close();
     }
 
     @Test
-    public void bug14330() {
-        HSSFWorkbook wb = openSample("14330-1.xls");
-        wb.getSheetAt(0);
+    public void bug14330() throws Exception {
+        HSSFWorkbook wb1 = openSample("14330-1.xls");
+        wb1.getSheetAt(0);
+        wb1.close();
 
-        wb = openSample("14330-2.xls");
-        wb.getSheetAt(0);
+        HSSFWorkbook wb2 = openSample("14330-2.xls");
+        wb2.getSheetAt(0);
+        wb2.close();
     }
 
     private static void setCellText(HSSFCell cell, String text) {
@@ -174,7 +149,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
     /** test rewriting a file with large number of unique strings
      *open resulting file in Excel to check results!*/
     @Test
-    public void bug15375() {
+    public void bug15375() throws Exception {
         HSSFWorkbook wb = openSample("15375.xls");
         HSSFSheet sheet = wb.getSheetAt(0);
 
@@ -195,24 +170,26 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         oCell = oRow.getCell(5);
         setCellText(oCell, "0.3");
 
-        writeTestOutputFileForViewing(wb, "test15375");
+        writeOutAndReadBack(wb).close();
+        wb.close();
     }
     /**
      * test writing a file with large number of unique strings,
      * open resulting file in Excel to check results!
      */
     @Test
-    public void bug15375_2() {
+    public void bug15375_2() throws Exception {
         bug15375(6000);
     }
 
     /**Double byte strings*/
     @Test
-    public void bug15556() {
+    public void bug15556() throws Exception {
         HSSFWorkbook wb = openSample("15556.xls");
         HSSFSheet sheet = wb.getSheetAt(0);
         HSSFRow row = sheet.getRow(45);
         assertNotNull("Read row fine!" , row);
+        wb.close();
     }
 
     /**Double byte strings */
@@ -261,7 +238,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
     }
 
     @Test
-    public void bug24215() {
+    public void bug24215() throws Exception {
         HSSFWorkbook wb = openSample("24215.xls");
 
         for (int sheetIndex = 0; sheetIndex < wb.getNumberOfSheets();sheetIndex++) {
@@ -277,6 +254,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
                 }
             }
         }
+        wb.close();
     }
 
     /**Tests read and write of Unicode strings in formula results
@@ -284,7 +262,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      * The file contains THAI unicode characters.
      */
     @Test
-    public void bugUnicodeStringFormulaRead() {
+    public void bugUnicodeStringFormulaRead() throws Exception {
 
         HSSFWorkbook w = openSample("25695.xls");
 
@@ -318,6 +296,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         confirmSameCellText(d1, d2);
 
         HSSFWorkbook rw = writeOutAndReadBack(w);
+        w.close();
 
         HSSFCell ra1 = rw.getSheetAt(0).getRow(0).getCell(0);
         HSSFCell ra2 = rw.getSheetAt(0).getRow(0).getCell(1);
@@ -337,6 +316,8 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         confirmSameCellText(b1, rb2);
         confirmSameCellText(c1, rc2);
         confirmSameCellText(d1, rd2);
+        
+        rw.close();
     }
 
     private static void confirmSameCellText(HSSFCell a, HSSFCell b) {
@@ -367,7 +348,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
 
     /**names and macros */
     @Test
-    public void bug27852() {
+    public void bug27852() throws Exception {
         HSSFWorkbook wb = openSample("27852.xls");
 
         for(int i = 0 ; i < wb.getNumberOfNames(); i++){
@@ -378,6 +359,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
           }
           name.getRefersToFormula();
         }
+        wb.close();
     }
 
     @Test
@@ -396,43 +378,47 @@ public final class TestBugs extends BaseTestBugzillaIssues {
 
     /** Error when reading then writing ArrayValues in NameRecord's*/
     @Test
-    public void bug37630() {
+    public void bug37630() throws Exception {
         HSSFWorkbook wb = openSample("37630.xls");
         writeOutAndReadBack(wb);
+        wb.close();
     }
 
     /**
      * Bug 25183: org.apache.poi.hssf.usermodel.HSSFSheet.setPropertiesFromSheet
      */
     @Test
-    public void bug25183() {
+    public void bug25183() throws Exception {
         HSSFWorkbook wb = openSample("25183.xls");
         writeOutAndReadBack(wb);
+        wb.close();
     }
 
     /**
      * Bug 26100: 128-character message in IF statement cell causes HSSFWorkbook open failure
      */
     @Test
-    public void bug26100() {
+    public void bug26100() throws Exception {
         HSSFWorkbook wb = openSample("26100.xls");
         writeOutAndReadBack(wb);
+        wb.close();
     }
 
     /**
      * Bug 27933: Unable to use a template (xls) file containing a wmf graphic
      */
     @Test
-    public void bug27933() {
+    public void bug27933() throws Exception {
         HSSFWorkbook wb = openSample("27933.xls");
         writeOutAndReadBack(wb);
+        wb.close();
     }
 
     /**
      * Bug 29206:      NPE on HSSFSheet.getRow for blank rows
      */
     @Test
-    public void bug29206() {
+    public void bug29206() throws Exception {
         //the first check with blank workbook
         HSSFWorkbook wb = openSample("Simple.xls");
         HSSFSheet sheet = wb.createSheet();
@@ -442,22 +428,24 @@ public final class TestBugs extends BaseTestBugzillaIssues {
                 row.getCell(0);
             }
         }
+        wb.close();
     }
 
     /**
      * Bug 29675: POI 2.5 final corrupts output when starting workbook has a graphic
      */
     @Test
-    public void bug29675() {
+    public void bug29675() throws Exception {
         HSSFWorkbook wb = openSample("29675.xls");
         writeOutAndReadBack(wb);
+        wb.close();
     }
 
     /**
      * Bug 29942: Importing Excel files that have been created by Open Office on Linux
      */
     @Test
-    public void bug29942() {
+    public void bug29942() throws Exception {
         HSSFWorkbook wb = openSample("29942.xls");
 
         HSSFSheet sheet = wb.getSheetAt(0);
@@ -472,7 +460,8 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         }
         assertEquals(85, count); //should read 85 rows
 
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        wb.close();
     }
 
     /**
@@ -480,39 +469,44 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *  Unable to construct record instance
      */
     @Test
-    public void bug29982() {
+    public void bug29982() throws Exception {
         HSSFWorkbook wb = openSample("29982.xls");
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        wb.close();
     }
 
     /**
      * Bug 30540: HSSFSheet.setRowBreak throws NullPointerException
      */
     @Test
-    public void bug30540() {
+    public void bug30540() throws Exception {
         HSSFWorkbook wb = openSample("30540.xls");
 
         HSSFSheet s = wb.getSheetAt(0);
         s.setRowBreak(1);
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        
+        wb.close();
     }
 
     /**
      * Bug 31749: {Need help urgently}[This is critical] workbook.write() corrupts the file......?
      */
     @Test
-    public void bug31749() {
+    public void bug31749() throws Exception {
         HSSFWorkbook wb = openSample("31749.xls");
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        wb.close();
     }
 
     /**
      * Bug 31979: {urgent help needed .....}poi library does not support form objects properly.
      */
     @Test
-    public void bug31979() {
+    public void bug31979() throws Exception {
         HSSFWorkbook wb = openSample("31979.xls");
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        wb.close();
     }
 
     /**
@@ -520,42 +514,47 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *  when HSSFWorkbook is created from file
      */
     @Test
-    public void bug35564() {
+    public void bug35564() throws Exception {
         HSSFWorkbook wb = openSample("35564.xls");
 
         HSSFSheet sheet = wb.getSheetAt( 0 );
         assertEquals(false, sheet.isGridsPrinted());
         assertEquals(false, sheet.getProtect());
 
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        
+        wb.close();
     }
 
     /**
      * Bug 35565: HSSFCell.java: NullPtrExc in getColumnBreaks() when HSSFWorkbook is created from file
      */
     @Test
-    public void bug35565() {
+    public void bug35565() throws Exception {
         HSSFWorkbook wb = openSample("35565.xls");
 
         HSSFSheet sheet = wb.getSheetAt( 0 );
         assertNotNull(sheet);
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        
+        wb.close();
     }
 
     /**
      * Bug 37376: Cannot open the saved Excel file if checkbox controls exceed certain limit
      */
     @Test
-    public void bug37376() {
+    public void bug37376() throws Exception {
         HSSFWorkbook wb = openSample("37376.xls");
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        wb.close();
     }
 
     /**
      * Bug 40285:      CellIterator Skips First Column
      */
     @Test
-    public void bug40285() {
+    public void bug40285() throws Exception {
         HSSFWorkbook wb = openSample("40285.xls");
 
         HSSFSheet sheet = wb.getSheetAt( 0 );
@@ -569,6 +568,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
                 assertEquals(cellNum, cell.getColumnIndex());
             }
         }
+        wb.close();
     }
 
     /**
@@ -582,10 +582,10 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      * 4. Get a NullPointerException
      */
     @Test
-    public void bug38266() {
+    public void bug38266() throws Exception {
         String[] files = {"Simple.xls", "SimpleMultiCell.xls", "duprich1.xls"};
-        for (int i = 0; i < files.length; i++) {
-            HSSFWorkbook wb = openSample(files[i]);
+        for (String file : files) {
+            HSSFWorkbook wb = openSample(file);
 
             HSSFSheet sheet = wb.getSheetAt( 0 );
             int[] breaks = sheet.getRowBreaks();
@@ -595,54 +595,59 @@ public final class TestBugs extends BaseTestBugzillaIssues {
             for (int j = 1; j <= 3; j++) {
                 sheet.setRowBreak(j*20);
             }
+            wb.close();
         }
     }
 
     @Test
-    public void bug40738() {
+    public void bug40738() throws Exception {
         HSSFWorkbook wb = openSample("SimpleWithAutofilter.xls");
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        wb.close();
     }
 
     /**
      * Bug 44200: Sheet not cloneable when Note added to excel cell
      */
     @Test
-    public void bug44200() {
+    public void bug44200() throws Exception {
         HSSFWorkbook wb = openSample("44200.xls");
-
         wb.cloneSheet(0);
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        wb.close();
     }
 
     /**
      * Bug 44201: Sheet not cloneable when validation added to excel cell
      */
     @Test
-    public void bug44201() {
+    public void bug44201() throws Exception {
         HSSFWorkbook wb = openSample("44201.xls");
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        wb.close();
     }
 
     /**
      * Bug 37684  : Unhandled Continue Record Error
      */
     @Test
-    public void bug37684 () {
-        HSSFWorkbook wb = openSample("37684-1.xls");
-        writeOutAndReadBack(wb);
-
-        wb = openSample("37684-2.xls");
-        writeOutAndReadBack(wb);
+    public void bug37684() throws Exception {
+        HSSFWorkbook wb1 = openSample("37684-1.xls");
+        writeOutAndReadBack(wb1).close();
+        wb1.close();
+        HSSFWorkbook wb2 = openSample("37684-2.xls");
+        writeOutAndReadBack(wb2).close();
+        wb2.close();
     }
 
     /**
      * Bug 41139: Constructing HSSFWorkbook is failed,threw threw ArrayIndexOutOfBoundsException for creating UnknownRecord
      */
     @Test
-    public void bug41139() {
+    public void bug41139() throws Exception {
         HSSFWorkbook wb = openSample("41139.xls");
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        wb.close();
     }
 
     /**
@@ -650,11 +655,13 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *  Unknown Ptg in Formula: 0x1a (26)
      */
     @Test
-    public void bug41546() {
-        HSSFWorkbook wb = openSample("41546.xls");
-        assertEquals(1, wb.getNumberOfSheets());
-        wb = writeOutAndReadBack(wb);
-        assertEquals(1, wb.getNumberOfSheets());
+    public void bug41546() throws Exception {
+        HSSFWorkbook wb1 = openSample("41546.xls");
+        assertEquals(1, wb1.getNumberOfSheets());
+        HSSFWorkbook wb2 = writeOutAndReadBack(wb1);
+        assertEquals(1, wb2.getNumberOfSheets());
+        wb2.close();
+        wb1.close();
     }
 
     /**
@@ -662,9 +669,10 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *  when reading the BOFRecord
      */
     @Test
-    public void bug42564() {
+    public void bug42564() throws Exception {
         HSSFWorkbook wb = openSample("ex42564-21435.xls");
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        wb.close();
     }
 
     /**
@@ -673,9 +681,10 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *  issue.
      */
     @Test
-    public void bug42564Alt() {
+    public void bug42564Alt() throws Exception {
         HSSFWorkbook wb = openSample("ex42564-21503.xls");
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        wb.close();
     }
 
     /**
@@ -683,11 +692,12 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *     =CHOOSE(2,A2,A3,A4)
      */
     @Test
-    public void bug42618() {
-        HSSFWorkbook wb = openSample("SimpleWithChoose.xls");
-        wb = writeOutAndReadBack(wb);
+    public void bug42618() throws Exception {
+        HSSFWorkbook wb1 = openSample("SimpleWithChoose.xls");
+        HSSFWorkbook wb2 = writeOutAndReadBack(wb1);
+        wb1.close();
         // Check we detect the string properly too
-        HSSFSheet s = wb.getSheetAt(0);
+        HSSFSheet s = wb2.getSheetAt(0);
 
         // Textual value
         HSSFRow r1 = s.getRow(0);
@@ -707,22 +717,19 @@ public final class TestBugs extends BaseTestBugzillaIssues {
                 fail("identified bug 44306");
             }
         }
+        wb2.close();
     }
 
     /**
      * Something up with the FileSharingRecord
      */
     @Test
-    public void bug43251() {
-
+    public void bug43251() throws Exception {
         // Used to blow up with an IllegalArgumentException
         //  when creating a FileSharingRecord
-        try {
-            HSSFWorkbook wb = openSample("43251.xls");
-            assertEquals(1, wb.getNumberOfSheets());
-        } catch (IllegalArgumentException e) {
-            fail("identified bug 43251");
-        }
+        HSSFWorkbook wb = openSample("43251.xls");
+        assertEquals(1, wb.getNumberOfSheets());
+        wb.close();
     }
 
     /**
@@ -730,18 +737,12 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *  StyleRecords, which is against the spec
      */
     @Test
-    public void bug44471() {
-
+    public void bug44471() throws Exception {
         // Used to blow up with an ArrayIndexOutOfBounds
         //  when creating a StyleRecord
-        HSSFWorkbook wb;
-        //try {
-        wb = openSample("OddStyleRecord.xls");
-        //} catch (ArrayIndexOutOfBoundsException e) {
-        //    throw new AssertionFailedError("Identified bug 44471");
-        //}
-
+        HSSFWorkbook wb = openSample("OddStyleRecord.xls");
         assertEquals(1, wb.getNumberOfSheets());
+        wb.close();
     }
 
     /**
@@ -749,19 +750,20 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *  grief on the FileSharingRecord
      */
     @Test
-    public void bug44536() {
-
+    public void bug44536() throws Exception {
         // Used to blow up with an IllegalArgumentException
         //  when creating a FileSharingRecord
-        HSSFWorkbook wb = openSample("ReadOnlyRecommended.xls");
+        HSSFWorkbook wb1 = openSample("ReadOnlyRecommended.xls");
 
         // Check read only advised
-        assertEquals(3, wb.getNumberOfSheets());
-        assertTrue(wb.isWriteProtected());
+        assertEquals(3, wb1.getNumberOfSheets());
+        assertTrue(wb1.isWriteProtected());
+        wb1.close();
 
         // But also check that another wb isn't
-        wb = openSample("SimpleWithChoose.xls");
-        assertFalse(wb.isWriteProtected());
+        HSSFWorkbook wb2 = openSample("SimpleWithChoose.xls");
+        assertFalse(wb2.isWriteProtected());
+        wb2.close();
     }
 
     /**
@@ -769,20 +771,14 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *  probably due to dropdowns
      */
     @Test
-    public void bug44593() {
-
+    public void bug44593() throws Exception {
         // Used to blow up with an IllegalArgumentException
         //  when creating a DVRecord
         // Now won't, but no idea if this means we have
         //  rubbish in the DVRecord or not...
-        HSSFWorkbook wb;
-        //try {
-        wb = openSample("44593.xls");
-        //} catch (IllegalArgumentException e) {
-        //    throw new AssertionFailedError("Identified bug 44593");
-        //}
-
+        HSSFWorkbook wb = openSample("44593.xls");
         assertEquals(2, wb.getNumberOfSheets());
+        wb.close();
     }
 
     /**
@@ -790,17 +786,11 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *  length string, but that's now properly handled
      */
     @Test
-    public void bug44643() {
-
+    public void bug44643() throws Exception {
         // Used to blow up with an IllegalArgumentException
-        HSSFWorkbook wb;
-        //try {
-        wb = openSample("44643.xls");
-        //} catch (IllegalArgumentException e) {
-        //    throw new AssertionFailedError("identified bug 44643");
-        //}
-
+        HSSFWorkbook wb = openSample("44643.xls");
         assertEquals(1, wb.getNumberOfSheets());
+        wb.close();
     }
 
     /**
@@ -808,8 +798,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *  iterator, but we can't replicate that
      */
     @Test
-    public void bug44693() {
-
+    public void bug44693() throws Exception {
         HSSFWorkbook wb = openSample("44693.xls");
         HSSFSheet s = wb.getSheetAt(0);
 
@@ -826,17 +815,19 @@ public final class TestBugs extends BaseTestBugzillaIssues {
             rowsSeen++;
         }
         assertEquals(713, rowsSeen);
+        wb.close();
     }
 
     /**
      * Bug 28774: Excel will crash when opening xls-files with images.
      */
     @Test
-    public void bug28774() {
+    public void bug28774() throws Exception {
         HSSFWorkbook wb = openSample("28774.xls");
         assertTrue("no errors reading sample xls", true);
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();;
         assertTrue("no errors writing sample xls", true);
+        wb.close();
     }
 
     /**
@@ -844,11 +835,12 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *  works just fine...
      */
     @Test
-    public void bug44891() {
+    public void bug44891() throws Exception {
         HSSFWorkbook wb = openSample("44891.xls");
         assertTrue("no errors reading sample xls", true);
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
         assertTrue("no errors writing sample xls", true);
+        wb.close();
     }
 
     /**
@@ -857,27 +849,30 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      * Works fine with poi-3.1-beta1.
      */
     @Test
-    public void bug44235() {
+    public void bug44235() throws Exception {
         HSSFWorkbook wb = openSample("44235.xls");
         assertTrue("no errors reading sample xls", true);
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
         assertTrue("no errors writing sample xls", true);
+        wb.close();
     }
 
     @Test
-    public void bug36947() {
+    public void bug36947() throws Exception {
         HSSFWorkbook wb = openSample("36947.xls");
         assertTrue("no errors reading sample xls", true);
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
         assertTrue("no errors writing sample xls", true);
+        wb.close();
     }
 
     @Test
-    public void bug39634() {
+    public void bug39634() throws Exception {
         HSSFWorkbook wb = openSample("39634.xls");
         assertTrue("no errors reading sample xls", true);
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
         assertTrue("no errors writing sample xls", true);
+        wb.close();
     }
 
     /**
@@ -885,8 +880,8 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *  HSSFObjectData
      * @throws Exception
      */
-    @Test
-    public void bug44840() {
+    @Test(expected=FileNotFoundException.class)
+    public void bug44840() throws Exception {
         HSSFWorkbook wb = openSample("WithCheckBoxes.xls");
 
         // Take a look at the embedded objects
@@ -913,11 +908,8 @@ public final class TestBugs extends BaseTestBugzillaIssues {
 
         try {
             obj.getDirectory();
-            fail();
-        } catch(FileNotFoundException e) {
-            // expected during successful test
-        } catch (IOException e) {
-            throw new RuntimeException(e);
+        } finally {
+            wb.close();
         }
     }
 
@@ -927,17 +919,17 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *  used for printing stuff.
      */
     @Test
-    public void bug30978() {
-        HSSFWorkbook wb = openSample("30978-alt.xls");
-        assertEquals(1, wb.getNumberOfNames());
-        assertEquals(3, wb.getNumberOfSheets());
+    public void bug30978() throws Exception {
+        HSSFWorkbook wb1 = openSample("30978-alt.xls");
+        assertEquals(1, wb1.getNumberOfNames());
+        assertEquals(3, wb1.getNumberOfSheets());
 
         // Check all names fit within range, and use
         //  DeletedArea3DPtg
-        InternalWorkbook w = wb.getWorkbook();
+        InternalWorkbook w = wb1.getWorkbook();
         for(int i=0; i<w.getNumNames(); i++) {
             NameRecord r = w.getNameRecord(i);
-            assertTrue(r.getSheetNumber() <= wb.getNumberOfSheets());
+            assertTrue(r.getSheetNumber() <= wb1.getNumberOfSheets());
 
             Ptg[] nd = r.getNameDefinition();
             assertEquals(1, nd.length);
@@ -946,16 +938,16 @@ public final class TestBugs extends BaseTestBugzillaIssues {
 
 
         // Delete the 2nd sheet
-        wb.removeSheetAt(1);
+        wb1.removeSheetAt(1);
 
 
         // Re-check
-        assertEquals(1, wb.getNumberOfNames());
-        assertEquals(2, wb.getNumberOfSheets());
+        assertEquals(1, wb1.getNumberOfNames());
+        assertEquals(2, wb1.getNumberOfSheets());
 
         for(int i=0; i<w.getNumNames(); i++) {
             NameRecord r = w.getNameRecord(i);
-            assertTrue(r.getSheetNumber() <= wb.getNumberOfSheets());
+            assertTrue(r.getSheetNumber() <= wb1.getNumberOfSheets());
 
             Ptg[] nd = r.getNameDefinition();
             assertEquals(1, nd.length);
@@ -964,20 +956,22 @@ public final class TestBugs extends BaseTestBugzillaIssues {
 
 
         // Save and re-load
-        wb = writeOutAndReadBack(wb);
-        w = wb.getWorkbook();
+        HSSFWorkbook wb2 = writeOutAndReadBack(wb1);
+        wb1.close();
+        w = wb2.getWorkbook();
 
-        assertEquals(1, wb.getNumberOfNames());
-        assertEquals(2, wb.getNumberOfSheets());
+        assertEquals(1, wb2.getNumberOfNames());
+        assertEquals(2, wb2.getNumberOfSheets());
 
         for(int i=0; i<w.getNumNames(); i++) {
             NameRecord r = w.getNameRecord(i);
-            assertTrue(r.getSheetNumber() <= wb.getNumberOfSheets());
+            assertTrue(r.getSheetNumber() <= wb2.getNumberOfSheets());
 
             Ptg[] nd = r.getNameDefinition();
             assertEquals(1, nd.length);
             assertTrue(nd[0] instanceof DeletedArea3DPtg);
         }
+        wb2.close();
     }
 
     /**
@@ -1073,9 +1067,9 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *  containing a zip code, eg ="70164"
      */
     @Test
-    public void bugZipCodeFormulas() {
-        HSSFWorkbook wb = new HSSFWorkbook();
-        HSSFSheet s = wb.createSheet();
+    public void bugZipCodeFormulas() throws Exception {
+        HSSFWorkbook wb1 = new HSSFWorkbook();
+        HSSFSheet s = wb1.createSheet();
         s.createRow(0);
         HSSFCell c1 = s.getRow(0).createCell(0);
         HSSFCell c2 = s.getRow(0).createCell(1);
@@ -1108,7 +1102,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
 
 
         // Now evaluate, they should all be changed
-        HSSFFormulaEvaluator eval = new HSSFFormulaEvaluator(wb);
+        HSSFFormulaEvaluator eval = new HSSFFormulaEvaluator(wb1);
         eval.evaluateFormulaCell(c1);
         eval.evaluateFormulaCell(c2);
         eval.evaluateFormulaCell(c3);
@@ -1121,8 +1115,9 @@ public final class TestBugs extends BaseTestBugzillaIssues {
 
 
         // Write and read
-        HSSFWorkbook nwb = writeOutAndReadBack(wb);
-        HSSFSheet ns = nwb.getSheetAt(0);
+        HSSFWorkbook wb2 = writeOutAndReadBack(wb1);
+        wb1.close();
+        HSSFSheet ns = wb2.getSheetAt(0);
         HSSFCell nc1 = ns.getRow(0).getCell(0);
         HSSFCell nc2 = ns.getRow(0).getCell(1);
         HSSFCell nc3 = ns.getRow(0).getCell(2);
@@ -1154,6 +1149,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
             }
         }
         assertEquals(3, cvrs.length);
+        wb2.close();
     }
 
     private static void confirmCachedValue(double expectedValue, HSSFCell cell) {
@@ -1180,11 +1176,11 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *  Expected ExpPtg to be converted from Shared to Non-Shared...
      */
     @Ignore
-    public void test43623() {
-        HSSFWorkbook wb = openSample("43623.xls");
-        assertEquals(1, wb.getNumberOfSheets());
+    public void test43623() throws Exception {
+        HSSFWorkbook wb1 = openSample("43623.xls");
+        assertEquals(1, wb1.getNumberOfSheets());
 
-        HSSFSheet s1 = wb.getSheetAt(0);
+        HSSFSheet s1 = wb1.getSheetAt(0);
 
         HSSFCell c1 = s1.getRow(0).getCell(2);
         HSSFCell c2 = s1.getRow(1).getCell(2);
@@ -1196,8 +1192,9 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         assertEquals("{=sin(B1:B9){9,1)[2][0]", c3.getCellFormula());
 
         // Save and re-open, ensure it still works
-        HSSFWorkbook nwb = writeOutAndReadBack(wb);
-        HSSFSheet ns1 = nwb.getSheetAt(0);
+        HSSFWorkbook wb2 = writeOutAndReadBack(wb1);
+        wb1.close();
+        HSSFSheet ns1 = wb2.getSheetAt(0);
         HSSFCell nc1 = ns1.getRow(0).getCell(2);
         HSSFCell nc2 = ns1.getRow(1).getCell(2);
         HSSFCell nc3 = ns1.getRow(2).getCell(2);
@@ -1205,6 +1202,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         assertEquals("{=sin(B1:B9){9,1)[0][0]", nc1.getCellFormula());
         assertEquals("{=sin(B1:B9){9,1)[1][0]", nc2.getCellFormula());
         assertEquals("{=sin(B1:B9){9,1)[2][0]", nc3.getCellFormula());
+        wb2.close();
     }
 
     /**
@@ -1264,7 +1262,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      * Data Tables - ptg 0x2
      */
     @Test
-    public void bug44958() {
+    public void bug44958() throws Exception {
         HSSFWorkbook wb = openSample("44958.xls");
         HSSFSheet s;
         HSSFRow r;
@@ -1290,16 +1288,18 @@ public final class TestBugs extends BaseTestBugzillaIssues {
 
         // TODO - check the formula once tables and
         //  arrays are properly supported
+        wb.close();
     }
 
     /**
      * 45322: HSSFSheet.autoSizeColumn fails when style.getDataFormat() returns -1
      */
     @Test
-    public void bug45322() {
+    public void bug45322() throws Exception {
         HSSFWorkbook wb = openSample("44958.xls");
         HSSFSheet sh = wb.getSheetAt(0);
         for(short i=0; i < 30; i++) sh.autoSizeColumn(i);
+        wb.close();
      }
 
     /**
@@ -1307,48 +1307,52 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *  with diagrams on. Don't any more
      */
     @Test
-    public void bug45414() {
-        HSSFWorkbook wb = openSample("WithThreeCharts.xls");
-        wb.getSheetAt(0).setForceFormulaRecalculation(true);
-        wb.getSheetAt(1).setForceFormulaRecalculation(false);
-        wb.getSheetAt(2).setForceFormulaRecalculation(true);
+    public void bug45414() throws Exception {
+        HSSFWorkbook wb1 = openSample("WithThreeCharts.xls");
+        wb1.getSheetAt(0).setForceFormulaRecalculation(true);
+        wb1.getSheetAt(1).setForceFormulaRecalculation(false);
+        wb1.getSheetAt(2).setForceFormulaRecalculation(true);
 
         // Write out and back in again
         // This used to break
-        HSSFWorkbook nwb = writeOutAndReadBack(wb);
+        HSSFWorkbook wb2 = writeOutAndReadBack(wb1);
+        wb1.close();
 
         // Check now set as it should be
-        assertTrue(nwb.getSheetAt(0).getForceFormulaRecalculation());
-        assertFalse(nwb.getSheetAt(1).getForceFormulaRecalculation());
-        assertTrue(nwb.getSheetAt(2).getForceFormulaRecalculation());
+        assertTrue(wb2.getSheetAt(0).getForceFormulaRecalculation());
+        assertFalse(wb2.getSheetAt(1).getForceFormulaRecalculation());
+        assertTrue(wb2.getSheetAt(2).getForceFormulaRecalculation());
+        wb2.close();
     }
 
     /**
      * Very hidden sheets not displaying as such
      */
     @Test
-    public void bug45761() {
-        HSSFWorkbook wb = openSample("45761.xls");
-        assertEquals(3, wb.getNumberOfSheets());
+    public void bug45761() throws Exception {
+        HSSFWorkbook wb1 = openSample("45761.xls");
+        assertEquals(3, wb1.getNumberOfSheets());
 
-        assertFalse(wb.isSheetHidden(0));
-        assertFalse(wb.isSheetVeryHidden(0));
-        assertTrue(wb.isSheetHidden(1));
-        assertFalse(wb.isSheetVeryHidden(1));
-        assertFalse(wb.isSheetHidden(2));
-        assertTrue(wb.isSheetVeryHidden(2));
+        assertFalse(wb1.isSheetHidden(0));
+        assertFalse(wb1.isSheetVeryHidden(0));
+        assertTrue(wb1.isSheetHidden(1));
+        assertFalse(wb1.isSheetVeryHidden(1));
+        assertFalse(wb1.isSheetHidden(2));
+        assertTrue(wb1.isSheetVeryHidden(2));
 
         // Change 0 to be very hidden, and re-load
-        wb.setSheetHidden(0, Workbook.SHEET_STATE_VERY_HIDDEN);
+        wb1.setSheetHidden(0, Workbook.SHEET_STATE_VERY_HIDDEN);
 
-        HSSFWorkbook nwb = writeOutAndReadBack(wb);
+        HSSFWorkbook wb2 = writeOutAndReadBack(wb1);
+        wb1.close();
 
-        assertFalse(nwb.isSheetHidden(0));
-        assertTrue(nwb.isSheetVeryHidden(0));
-        assertTrue(nwb.isSheetHidden(1));
-        assertFalse(nwb.isSheetVeryHidden(1));
-        assertFalse(nwb.isSheetHidden(2));
-        assertTrue(nwb.isSheetVeryHidden(2));
+        assertFalse(wb2.isSheetHidden(0));
+        assertTrue(wb2.isSheetVeryHidden(0));
+        assertTrue(wb2.isSheetHidden(1));
+        assertFalse(wb2.isSheetVeryHidden(1));
+        assertFalse(wb2.isSheetHidden(2));
+        assertTrue(wb2.isSheetVeryHidden(2));
+        wb2.close();
     }
 
     /**
@@ -1357,7 +1361,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      * POI now supports header / footer text lengths beyond 256 bytes.
      */
     @Test
-    public void bug45777() {
+    public void bug45777() throws Exception {
         HSSFWorkbook wb = new HSSFWorkbook();
         HSSFSheet s = wb.createSheet();
 
@@ -1377,52 +1381,49 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         // Try on headers
         s.getHeader().setCenter(s248);
         assertEquals(254, s.getHeader().getRawText().length());
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
 
         s.getHeader().setCenter(s251);
         assertEquals(257, s.getHeader().getRawText().length());
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
 
-        try {
-            s.getHeader().setCenter(s250); // 256 bytes required
-            s.getHeader().setCenter(s251); // 257 bytes required
-        } catch(IllegalArgumentException e) {
-            fail("Identified bug 47244b - header can be more than 256 bytes");
-        }
+        // header can be more than 256 bytes
+        s.getHeader().setCenter(s250); // 256 bytes required
+        s.getHeader().setCenter(s251); // 257 bytes required
 
         // Now try on footers
         s.getFooter().setCenter(s248);
         assertEquals(254, s.getFooter().getRawText().length());
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
 
         s.getFooter().setCenter(s251);
         assertEquals(257, s.getFooter().getRawText().length());
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
 
-        try {
-            s.getFooter().setCenter(s250); // 256 bytes required
-            s.getFooter().setCenter(s251); // 257 bytes required
-        } catch(IllegalArgumentException e) {
-            fail("Identified bug 47244b - footer can be more than 256 bytes");
-        }
+        // footer can be more than 256 bytes
+        s.getFooter().setCenter(s250); // 256 bytes required
+        s.getFooter().setCenter(s251); // 257 bytes required
+        
+        wb.close();
     }
 
     /**
      * Charts with long titles
      */
     @Test
-    public void bug45784() {
+    public void bug45784() throws Exception {
         // This used to break
         HSSFWorkbook wb = openSample("45784.xls");
         assertEquals(1, wb.getNumberOfSheets());
-        wb = HSSFTestDataSamples.writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        wb.close();
     }
 
    /**
      * Cell background colours
      */
     @Test
-    public void bug45492() {
+    public void bug45492() throws Exception {
         HSSFWorkbook wb = openSample("45492.xls");
         HSSFSheet s = wb.getSheetAt(0);
         HSSFRow r = s.getRow(0);
@@ -1453,17 +1454,19 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         assertEquals(11, green.getCellStyle().getFillForegroundColor());
         assertEquals(64, green.getCellStyle().getFillBackgroundColor());
         assertEquals("0:FFFF:0", p.getColor(11).getHexString());
+        wb.close();
     }
 
     /**
      * ContinueRecord after EOF
      */
     @Test
-    public void bug46137() {
+    public void bug46137() throws Exception {
         // This used to break
         HSSFWorkbook wb = openSample("46137.xls");
         assertEquals(7, wb.getNumberOfSheets());
-        wb = HSSFTestDataSamples.writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        wb.close();
     }
 
     /**
@@ -1471,9 +1474,10 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      * block[ 44 ] already removed from org.apache.poi.poifs.storage.BlockListImpl.remove
      */
     @Test
-    public void bug45290() {
+    public void bug45290() throws Exception {
         HSSFWorkbook wb = openSample("45290.xls");
         assertEquals(1, wb.getNumberOfSheets());
+        wb.close();
     }
 
     /**
@@ -1481,7 +1485,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *  =MY_VBA_FUNCTION("lskdjflsk")
      */
     @Test
-    public void bug30070() {
+    public void bug30070() throws Exception {
         HSSFWorkbook wb = openSample("30070.xls"); //contains custom VBA function 'Commission'
         HSSFSheet sh = wb.getSheetAt(0);
         HSSFCell cell = sh.getRow(0).getCell(1);
@@ -1495,7 +1499,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
 
         HSSFName name = wb.getNameAt(idx);
         assertEquals("Commission(Sheet0!$A$1)", name.getRefersToFormula());
-
+        wb.close();
     }
 
     /**
@@ -1514,13 +1518,14 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *
      */
     @Test
-    public void bug27364() {
+    public void bug27364() throws Exception {
         HSSFWorkbook wb = openSample("27364.xls");
         HSSFSheet sheet = wb.getSheetAt(0);
 
         assertEquals("[link_sub.xls]Sheet1!$A$1", sheet.getRow(0).getCell(0).getCellFormula());
         assertEquals("[link_sub.xls]Sheet1!$A$2", sheet.getRow(1).getCell(0).getCellFormula());
         assertEquals("[link_sub.xls]Sheet1!$A$3", sheet.getRow(2).getCell(0).getCellFormula());
+        wb.close();
     }
 
     /**
@@ -1528,18 +1533,19 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      * HSSFCell.getCellFormula() fails with references to external workbooks
      */
     @Test
-    public void bug31661() {
+    public void bug31661() throws Exception {
         HSSFWorkbook wb = openSample("31661.xls");
         HSSFSheet sheet = wb.getSheetAt(0);
         HSSFCell cell = sheet.getRow(11).getCell(10); //K11
         assertEquals("+'[GM Budget.xls]8085.4450'!$B$2", cell.getCellFormula());
+        wb.close();
     }
 
     /**
      * Incorrect handling of non-ISO 8859-1 characters in Windows ANSII Code Page 1252
      */
     @Test
-    public void bug27394() {
+    public void bug27394() throws Exception {
         HSSFWorkbook wb = openSample("27394.xls");
         assertEquals("\u0161\u017E", wb.getSheetName(0));
         assertEquals("\u0161\u017E\u010D\u0148\u0159", wb.getSheetName(1));
@@ -1547,6 +1553,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
 
         assertEquals("\u0161\u017E", sheet.getRow(0).getCell(0).getStringCellValue());
         assertEquals("\u0161\u017E\u010D\u0148\u0159", sheet.getRow(1).getCell(0).getStringCellValue());
+        wb.close();
     }
 
     /**
@@ -1572,7 +1579,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         out.close();
         int size3 = out.size();
         assertEquals(size2, size3);
-
+        wb.close();
     }
 
     /**
@@ -1612,10 +1619,11 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      *  non-unicode data for a name record
      */
     @Test
-    public void bug47034() {
+    public void bug47034() throws Exception {
         HSSFWorkbook wb = openSample("47034.xls");
         assertEquals(893, wb.getNumberOfNames());
         assertEquals("Matthew\\Matthew11_1\\Matthew2331_1\\Matthew2351_1\\Matthew2361_1___lab", wb.getNameName(300));
+        wb.close();
     }
 
     /**
@@ -1623,7 +1631,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      * The test file was created in OpenOffice 3.0 as Excel does not allow cell text longer than 32,767 characters
      */
     @Test
-    public void bug46368() {
+    public void bug46368() throws Exception {
         HSSFWorkbook wb = openSample("46368.xls");
        HSSFSheet s = wb.getSheetAt(0);
         HSSFCell cell1 = s.getRow(0).getCell(0);
@@ -1631,13 +1639,14 @@ public final class TestBugs extends BaseTestBugzillaIssues {
 
         HSSFCell cell2 = s.getRow(2).getCell(0);
         assertEquals(32766, cell2.getStringCellValue().length());
+        wb.close();
     }
 
     /**
      * Short records on certain sheets with charts in them
      */
     @Test
-    public void bug48180() {
+    public void bug48180() throws Exception {
         HSSFWorkbook wb = openSample("48180.xls");
 
        HSSFSheet s = wb.getSheetAt(0);
@@ -1646,6 +1655,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
 
         HSSFCell cell2 = s.getRow(0).getCell(1);
         assertEquals(1.0, cell2.getNumericCellValue(), 0.0);
+        wb.close();
     }
 
     /**
@@ -1675,12 +1685,12 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      */
     @Test
     public void bug47847() throws Exception {
-       HSSFWorkbook wb = openSample("47847.xls");
-       assertEquals(3, wb.getNumberOfSheets());
+       HSSFWorkbook wb1 = openSample("47847.xls");
+       assertEquals(3, wb1.getNumberOfSheets());
 
        // Find the SST record
-       UnicodeString withExt = wb.getWorkbook().getSSTString(0);
-       UnicodeString withoutExt = wb.getWorkbook().getSSTString(31);
+       UnicodeString withExt = wb1.getWorkbook().getSSTString(0);
+       UnicodeString withoutExt = wb1.getWorkbook().getSSTString(31);
 
        assertEquals("O:Alloc:Qty", withExt.getString());
        assertTrue((withExt.getOptionFlags() & 0x0004) == 0x0004);
@@ -1692,18 +1702,20 @@ public final class TestBugs extends BaseTestBugzillaIssues {
 
 
        // Write out and re-read
-       wb = writeOutAndReadBack(wb);
-       assertEquals(3, wb.getNumberOfSheets());
+       HSSFWorkbook wb2 = writeOutAndReadBack(wb1);
+       wb1.close();
+       assertEquals(3, wb2.getNumberOfSheets());
 
        // Check it's the same now
-       withExt = wb.getWorkbook().getSSTString(0);
-       withoutExt = wb.getWorkbook().getSSTString(31);
+       withExt = wb2.getWorkbook().getSSTString(0);
+       withoutExt = wb2.getWorkbook().getSSTString(31);
 
        assertEquals("O:Alloc:Qty", withExt.getString());
        assertTrue((withExt.getOptionFlags() & 0x0004) == 0x0004);
 
        assertEquals("RT", withoutExt.getString());
        assertTrue((withoutExt.getOptionFlags() & 0x0004) == 0x0000);
+       wb2.close();
     }
 
     /**
@@ -1712,15 +1724,17 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      */
     @Test
     public void bug49096() throws Exception {
-       HSSFWorkbook wb = openSample("49096.xls");
-       assertEquals(1, wb.getNumberOfSheets());
+       HSSFWorkbook wb1 = openSample("49096.xls");
+       assertEquals(1, wb1.getNumberOfSheets());
 
-       assertNotNull(wb.getSheetAt(0));
-       wb.cloneSheet(0);
-       assertEquals(2, wb.getNumberOfSheets());
+       assertNotNull(wb1.getSheetAt(0));
+       wb1.cloneSheet(0);
+       assertEquals(2, wb1.getNumberOfSheets());
 
-       wb = writeOutAndReadBack(wb);
-       assertEquals(2, wb.getNumberOfSheets());
+       HSSFWorkbook wb2 = writeOutAndReadBack(wb1);
+       wb1.close();
+       assertEquals(2, wb2.getNumberOfSheets());
+       wb2.close();
     }
 
     /**
@@ -1789,10 +1803,10 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      */
     @Test
     public void bug45970() throws Exception {
-       HSSFWorkbook wb = openSample("FormulaRefs.xls");
-       assertEquals(3, wb.getNumberOfSheets());
+       HSSFWorkbook wb1 = openSample("FormulaRefs.xls");
+       assertEquals(3, wb1.getNumberOfSheets());
 
-       HSSFSheet s = wb.getSheetAt(0);
+       HSSFSheet s = wb1.getSheetAt(0);
        HSSFRow row;
 
        row = s.getRow(0);
@@ -1831,8 +1845,9 @@ public final class TestBugs extends BaseTestBugzillaIssues {
 
 
        // Re-test
-       wb = writeOutAndReadBack(wb);
-       s = wb.getSheetAt(0);
+       HSSFWorkbook wb2 = writeOutAndReadBack(wb1);
+       wb1.close();
+       s = wb2.getSheetAt(0);
 
        row = s.getRow(0);
        assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(1).getCellType());
@@ -1863,6 +1878,8 @@ public final class TestBugs extends BaseTestBugzillaIssues {
        assertEquals(Cell.CELL_TYPE_FORMULA, row.getCell(1).getCellType());
        assertEquals("'[$http://example.com/FormulaRefs.xls]Sheet1'!B1", row.getCell(1).getCellFormula());
        assertEquals(234.0, row.getCell(1).getNumericCellValue(), 0);*/
+       
+       wb2.close();
     }
 
     /**
@@ -1870,8 +1887,8 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      */
     @Test
     public void bug49185() throws Exception {
-      HSSFWorkbook wb = openSample("49185.xls");
-      Name name = wb.getName("foobarName");
+      HSSFWorkbook wb1 = openSample("49185.xls");
+      Name name = wb1.getName("foobarName");
       assertEquals("This is a comment", name.getComment());
 
       // Rename the name, comment comes with it
@@ -1879,8 +1896,9 @@ public final class TestBugs extends BaseTestBugzillaIssues {
       assertEquals("This is a comment", name.getComment());
 
       // Save and re-check
-      wb = writeOutAndReadBack(wb);
-      name = wb.getName("ChangedName");
+      HSSFWorkbook wb2 = writeOutAndReadBack(wb1);
+      wb1.close();
+      name = wb2.getName("ChangedName");
       assertEquals("This is a comment", name.getComment());
 
       // Now try to change it
@@ -1888,9 +1906,11 @@ public final class TestBugs extends BaseTestBugzillaIssues {
       assertEquals("Changed Comment", name.getComment());
 
       // Save and re-check
-      wb = writeOutAndReadBack(wb);
-      name = wb.getName("ChangedName");
+      HSSFWorkbook wb3 = writeOutAndReadBack(wb2);
+      wb2.close();
+      name = wb3.getName("ChangedName");
       assertEquals("Changed Comment", name.getComment());
+      wb3.close();
     }
 
     /**
@@ -1898,8 +1918,8 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      */
     @Test
     public void bug49524() throws Exception {
-       HSSFWorkbook wb = openSample("49524.xls");
-       Sheet s = wb.getSheetAt(0);
+       HSSFWorkbook wb1 = openSample("49524.xls");
+       Sheet s = wb1.getSheetAt(0);
        Row r = s.getRow(0);
        Cell rotated = r.getCell(0);
        Cell normal = r.getCell(1);
@@ -1909,7 +1929,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
        assertEquals(0xff, rotated.getCellStyle().getRotation());
 
        // Add a new style, also rotated
-       CellStyle cs = wb.createCellStyle();
+       CellStyle cs = wb1.createCellStyle();
        cs.setRotation((short)0xff);
        Cell nc = r.createCell(2);
        nc.setCellValue("New Rotated Text");
@@ -1917,10 +1937,11 @@ public final class TestBugs extends BaseTestBugzillaIssues {
        assertEquals(0xff, nc.getCellStyle().getRotation());
 
        // Write out and read back
-       wb = writeOutAndReadBack(wb);
+       HSSFWorkbook wb2 = writeOutAndReadBack(wb1);
+       wb1.close();
 
        // Re-check
-       s = wb.getSheetAt(0);
+       s = wb2.getSheetAt(0);
        r = s.getRow(0);
        rotated = r.getCell(0);
        normal = r.getCell(1);
@@ -1929,6 +1950,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
        assertEquals(0, normal.getCellStyle().getRotation());
        assertEquals(0xff, rotated.getCellStyle().getRotation());
        assertEquals(0xff, nc.getCellStyle().getRotation());
+       wb2.close();
     }
 
     /**
@@ -1959,6 +1981,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
 
        // Write out and read back
        HSSFWorkbook wb2 = writeOutAndReadBack(wb1);
+       wb1.close();
 
        // Re-check
        assertEquals("Testing", wb2.getCellStyleAt((short)21).getUserStyleName());
@@ -1969,7 +1992,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
     }
 
     @Test
-    public void bug49751() {
+    public void bug49751() throws Exception {
         HSSFWorkbook wb = openSample("49751.xls");
         short numCellStyles = wb.getNumCellStyles();
         List<String> namedStyles = Arrays.asList(
@@ -1990,6 +2013,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
             }
         }
         assertTrue(namedStyles.containsAll(collecteddStyles));
+        wb.close();
     }
 
     /**
@@ -1998,9 +2022,9 @@ public final class TestBugs extends BaseTestBugzillaIssues {
     @Test
     public void bug49931() throws Exception {
        HSSFWorkbook wb = openSample("49931.xls");
-
        assertEquals(1, wb.getNumberOfSheets());
        assertEquals("Foo", wb.getSheetAt(0).getRow(0).getCell(0).getRichStringCellValue().toString());
+       wb.close();
     }
 
     /**
@@ -2012,14 +2036,15 @@ public final class TestBugs extends BaseTestBugzillaIssues {
        HSSFSheet sh = wb.getSheetAt(0);
        HSSFFooter f = sh.getFooter();
 
-       // Will show as the centre, as that is what excel does
-       //  with an invalid footer lacking left/right/centre details
+       // Will show as the center, as that is what excel does
+       //  with an invalid footer lacking left/right/center details
        assertEquals("Left text should be empty", "", f.getLeft());
        assertEquals("Right text should be empty", "", f.getRight());
        assertEquals(
              "Center text should contain the illegal value",
              "BlahBlah blah blah  ", f.getCenter()
        );
+       wb.close();
     }
 
     /**
@@ -2028,13 +2053,15 @@ public final class TestBugs extends BaseTestBugzillaIssues {
     @Test
     public void bug50020() throws Exception {
        HSSFWorkbook wb = openSample("50020.xls");
-       writeOutAndReadBack(wb);
+       writeOutAndReadBack(wb).close();
+       wb.close();
     }
 
     @Test
     public void bug50426() throws Exception {
        HSSFWorkbook wb = openSample("50426.xls");
-       writeOutAndReadBack(wb);
+       writeOutAndReadBack(wb).close();
+       wb.close();
     }
 
     /**
@@ -2126,6 +2153,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
        assertEquals("16", df.formatCellValue(r18.getCell(1)));
        assertEquals("35", df.formatCellValue(r18.getCell(2)));
        assertEquals("123", df.formatCellValue(r18.getCell(3)));
+       wb.close();
     }
 
     /**
@@ -2138,8 +2166,8 @@ public final class TestBugs extends BaseTestBugzillaIssues {
     public void bug50833() throws Exception {
        Biff8EncryptionKey.setCurrentUserPassword(null);
 
-       HSSFWorkbook wb = openSample("50833.xls");
-       HSSFSheet s = wb.getSheetAt(0);
+       HSSFWorkbook wb1 = openSample("50833.xls");
+       HSSFSheet s = wb1.getSheetAt(0);
        assertEquals("Sheet1", s.getSheetName());
        assertEquals(false, s.getProtect());
 
@@ -2152,8 +2180,9 @@ public final class TestBugs extends BaseTestBugzillaIssues {
        assertEquals("Robert Lawrence:\ntest comment", cmt.getString().getString());
 
        // Reload
-       wb = writeOutAndReadBack(wb);
-       s = wb.getSheetAt(0);
+       HSSFWorkbook wb2 = writeOutAndReadBack(wb1);
+       wb1.close();
+       s = wb2.getSheetAt(0);
        c = s.getRow(0).getCell(0);
 
        // Re-check the comment
@@ -2163,15 +2192,18 @@ public final class TestBugs extends BaseTestBugzillaIssues {
        assertEquals("Robert Lawrence:\ntest comment", cmt.getString().getString());
 
        // TODO Identify what excel doesn't like, and check for that
+       wb2.close();
     }
 
     @Test
     public void bug50779() throws Exception {
-       HSSFWorkbook wb1 = openSample("50779_1.xls");
-       writeOutAndReadBack(wb1);
+        HSSFWorkbook wb1 = openSample("50779_1.xls");
+        writeOutAndReadBack(wb1).close();
+        wb1.close();
 
         HSSFWorkbook wb2 = openSample("50779_2.xls");
-        writeOutAndReadBack(wb2);
+        writeOutAndReadBack(wb2).close();
+        wb2.close();
     }
 
     /**
@@ -2182,6 +2214,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
     public void bug50939() throws Exception {
        HSSFWorkbook wb = openSample("50939.xls");
        assertEquals(2, wb.getNumberOfSheets());
+       wb.close();
     }
 
     @Test
@@ -2189,6 +2222,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
        HSSFWorkbook wb = openSample("49219.xls");
        assertEquals(1, wb.getNumberOfSheets());
        assertEquals("DGATE", wb.getSheetAt(0).getRow(1).getCell(0).getStringCellValue());
+       wb.close();
     }
 
     @Test
@@ -2220,7 +2254,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
            assertEquals("SECOND(A1)", s.getRow(7).getCell(0).getCellFormula());
            assertEquals(54.0,         s.getRow(7).getCell(0).getNumericCellValue(), 0);
     
-           // Re-evaulate and check
+           // Re-evaluate and check
            HSSFFormulaEvaluator.evaluateAllFormulaCells(wb);
            assertEquals("HOUR(A1)",   s.getRow(5).getCell(0).getCellFormula());
            assertEquals(11.0,         s.getRow(5).getCell(0).getNumericCellValue(), 0);
@@ -2240,6 +2274,8 @@ public final class TestBugs extends BaseTestBugzillaIssues {
            assertEquals(39.0+14.0+1,  s.getRow(6).getCell(0).getNumericCellValue(), 0);
            assertEquals("SECOND(A1)", s.getRow(7).getCell(0).getCellFormula());
            assertEquals(54.0+24.0-60, s.getRow(7).getCell(0).getNumericCellValue(), 0);
+           
+           wb.close();
         } finally {
             LocaleUtil.setUserTimeZone(userTimeZone);
         }
@@ -2252,10 +2288,12 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      */
     @Test
     public void bug51143() throws Exception {
-       HSSFWorkbook wb = openSample("51143.xls");
-       assertEquals(1, wb.getNumberOfSheets());
-       wb = writeOutAndReadBack(wb);
-       assertEquals(1, wb.getNumberOfSheets());
+       HSSFWorkbook wb1 = openSample("51143.xls");
+       assertEquals(1, wb1.getNumberOfSheets());
+       HSSFWorkbook wb2 = writeOutAndReadBack(wb1);
+       wb1.close();
+       assertEquals(1, wb2.getNumberOfSheets());
+       wb2.close();
     }
 
     /**
@@ -2311,9 +2349,10 @@ public final class TestBugs extends BaseTestBugzillaIssues {
     }
 
     @Test
-    public void bug51670() {
+    public void bug51670() throws Exception {
         HSSFWorkbook wb = openSample("51670.xls");
-        writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        wb.close();
     }
 
     /**
@@ -2322,7 +2361,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      * DISABLED - We currently get the formula wrong, and mis-evaluate
      */
     @Ignore
-    public void test48703() {
+    public void test48703() throws Exception {
         HSSFWorkbook wb = openSample("48703.xls");
         assertEquals(3, wb.getNumberOfSheets());
 
@@ -2338,6 +2377,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         HSSFFormulaEvaluator eval = new HSSFFormulaEvaluator(wb);
         eval.evaluateFormulaCell(c);
         assertEquals(4.0, c.getNumericCellValue(), 0);
+        wb.close();
     }
 
     /**
@@ -2350,26 +2390,29 @@ public final class TestBugs extends BaseTestBugzillaIssues {
     }
 
     @Test
-    public void bug49896() {
+    public void bug49896() throws Exception {
         HSSFWorkbook wb = openSample("49896.xls");
         HSSFCell  cell = wb.getSheetAt(0).getRow(1).getCell(1);
         String PATH_SEPARATOR = System.getProperty("file.separator");
         assertEquals("VLOOKUP(A2,'[C:Documents and Settings" + PATH_SEPARATOR+"Yegor"+PATH_SEPARATOR
                 +"My Documents"+PATH_SEPARATOR+"csco.xls]Sheet1'!$A$2:$B$3,2,FALSE)",
                 cell.getCellFormula());
+        wb.close();
      }
 
     @Test
     public void bug49529() throws Exception {
         // user code reported in Bugzilla #49529
-        HSSFWorkbook workbook = openSample("49529.xls");
-        workbook.getSheetAt(0).createDrawingPatriarch();
+        HSSFWorkbook wb = openSample("49529.xls");
+        wb.getSheetAt(0).createDrawingPatriarch();
         // prior to the fix the line below failed with
         // java.lang.IllegalStateException: EOF - next record not available
-        workbook.cloneSheet(0);
+        wb.cloneSheet(0);
 
         // make sure we are still readable
-        writeOutAndReadBack(workbook);
+        writeOutAndReadBack(wb).close();
+        
+        wb.close();
     }
 
     /**
@@ -2395,13 +2438,14 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         assertEquals("evaluating c1", 30.0, eval.evaluate(c1).getNumberValue(), 0.001);
         assertEquals("evaluating d1", 30.0, eval.evaluate(d1).getNumberValue(), 0.001);
         assertEquals("evaluating e1", 30.0, eval.evaluate(e1).getNumberValue(), 0.001);
+        wb.close();
     }
 
     @Test
-    public void bug51675(){
+    public void bug51675() throws Exception {
         final List<Short> list = new ArrayList<Short>();
-        HSSFWorkbook workbook = openSample("51675.xls");
-        HSSFSheet sh = workbook.getSheetAt(0);
+        HSSFWorkbook wb = openSample("51675.xls");
+        HSSFSheet sh = wb.getSheetAt(0);
         InternalSheet ish = HSSFTestHelper.getSheetForTest(sh);
         PageSettingsBlock psb = (PageSettingsBlock) ish.getRecords().get(13);
         psb.visitContainedRecords(new RecordAggregate.RecordVisitor() {
@@ -2412,6 +2456,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         });
         assertTrue(list.get(list.size()-1).intValue() == UnknownRecord.BITMAP_00E9);
         assertTrue(list.get(list.size()-2).intValue() == UnknownRecord.HEADER_FOOTER_089C);
+        wb.close();
     }
 
     @Test
@@ -2453,8 +2498,8 @@ public final class TestBugs extends BaseTestBugzillaIssues {
     }
 
     @Test
-    public void bug46250(){
-        Workbook wb = openSample("46250.xls");
+    public void bug46250() throws Exception {
+        HSSFWorkbook wb = openSample("46250.xls");
         Sheet sh = wb.getSheet("Template");
         Sheet cSh = wb.cloneSheet(wb.getSheetIndex(sh));
 
@@ -2464,12 +2509,14 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         tb.setString(new HSSFRichTextString("POI test"));
         tb.setAnchor(new HSSFClientAnchor(0,0,0,0,(short)0,0,(short)10,10));
 
-        wb = writeOutAndReadBack((HSSFWorkbook) wb);
+        writeOutAndReadBack(wb).close();
+        
+        wb.close();
     }
 
     @Test
-    public void bug53404(){
-        Workbook wb = openSample("53404.xls");
+    public void bug53404() throws Exception {
+        HSSFWorkbook wb = openSample("53404.xls");
         Sheet sheet = wb.getSheet("test-sheet");
         int rowCount = sheet.getLastRowNum() + 1;
         int newRows = 5;
@@ -2485,46 +2532,48 @@ public final class TestBugs extends BaseTestBugzillaIssues {
             row.createCell(6).setCellValue("added cells.");
         }
 
-        wb = writeOutAndReadBack((HSSFWorkbook) wb);
+        writeOutAndReadBack(wb).close();
+        
+        wb.close();
     }
 
     @Test
-    public void bug54016() {
+    public void bug54016() throws Exception {
         // This used to break
         HSSFWorkbook wb = openSample("54016.xls");
-        wb = HSSFTestDataSamples.writeOutAndReadBack(wb);
+        writeOutAndReadBack(wb).close();
+        wb.close();
     }
 
     /** Row style information is 12 not 16 bits */
     @Test
-    public void bug49237() {
+    public void bug49237() throws Exception {
         HSSFWorkbook wb = openSample("49237.xls");
         HSSFSheet sheet = wb.getSheetAt(0);
         HSSFRow row = sheet.getRow(0);
         HSSFCellStyle rstyle = row.getRowStyle();
         assertEquals(rstyle.getBorderBottom(), CellStyle.BORDER_DOUBLE);
+        wb.close();
     }
 
-    @Test
+    /** POI doesn't currently support the RC4 CryptoAPI encryption header structure */
+    @Test(expected=EncryptedDocumentException.class)
     public void bug35897() throws Exception {
         // password is abc
         try {
             Biff8EncryptionKey.setCurrentUserPassword("abc");
-            openSample("xor-encryption-abc.xls");
+            openSample("xor-encryption-abc.xls").close();
         } finally {
             Biff8EncryptionKey.setCurrentUserPassword(null);
         }
 
         // One using the only-recently-documented encryption header type 4,
         //  and the RC4 CryptoAPI encryption header structure
-        try {
-            openSample("35897-type4.xls");
-            fail("POI doesn't currently support the RC4 CryptoAPI encryption header structure");
-        } catch (EncryptedDocumentException e) {}
+        openSample("35897-type4.xls").close();
     }
 
     @Test
-    public void bug56450() {
+    public void bug56450() throws Exception {
         HSSFWorkbook wb = openSample("56450.xls");
         HSSFSheet sheet = wb.getSheetAt(0);
         int comments = 0;
@@ -2537,13 +2586,14 @@ public final class TestBugs extends BaseTestBugzillaIssues {
             }
         }
         assertEquals(0, comments);
+        wb.close();
     }
 
     /**
      * Files initially created with Excel 2010 can have >3 CF rules
      */
     @Test
-    public void bug56482() {
+    public void bug56482() throws Exception {
         HSSFWorkbook wb = openSample("56482.xls");
         assertEquals(1, wb.getNumberOfSheets());
 
@@ -2551,16 +2601,18 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         HSSFSheetConditionalFormatting cf = sheet.getSheetConditionalFormatting();
 
         assertEquals(5, cf.getNumConditionalFormattings());
+        wb.close();
     }
 
     @Test
     public void bug56325() throws IOException {
         HSSFWorkbook wb1;
+        POIFSFileSystem fs;
 
         File file = HSSFTestDataSamples.getSampleFile("56325.xls");
         InputStream stream = new FileInputStream(file);
         try {
-            POIFSFileSystem fs = new POIFSFileSystem(stream);
+            fs = new POIFSFileSystem(stream);
             wb1 = new HSSFWorkbook(fs);
         } finally {
             stream.close();
@@ -2570,15 +2622,16 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         wb1.removeSheetAt(0);
         assertEquals(2, wb1.getNumberOfSheets());
 
-        HSSFWorkbook wb2 = HSSFTestDataSamples.writeOutAndReadBack(wb1);
+        HSSFWorkbook wb2 = writeOutAndReadBack(wb1);
         wb1.close();
+        fs.close();
         assertEquals(2, wb2.getNumberOfSheets());
         wb2.removeSheetAt(0);
         assertEquals(1, wb2.getNumberOfSheets());
         wb2.removeSheetAt(0);
         assertEquals(0, wb2.getNumberOfSheets());
 
-        HSSFWorkbook wb3 = HSSFTestDataSamples.writeOutAndReadBack(wb2);
+        HSSFWorkbook wb3 = writeOutAndReadBack(wb2);
         wb2.close();
         
         assertEquals(0, wb3.getNumberOfSheets());
@@ -2587,29 +2640,24 @@ public final class TestBugs extends BaseTestBugzillaIssues {
 
     @Test
     public void bug56325a() throws IOException {
-        HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("56325a.xls");
+        HSSFWorkbook wb1 = HSSFTestDataSamples.openSampleWorkbook("56325a.xls");
 
-        HSSFSheet sheet = wb.cloneSheet(2);
-        wb.setSheetName(3, "Clone 1");
+        HSSFSheet sheet = wb1.cloneSheet(2);
+        wb1.setSheetName(3, "Clone 1");
         sheet.setRepeatingRows(CellRangeAddress.valueOf("2:3"));
-        wb.setPrintArea(3, "$A$4:$C$10");
+        wb1.setPrintArea(3, "$A$4:$C$10");
 
-        sheet = wb.cloneSheet(2);
-        wb.setSheetName(4, "Clone 2");
+        sheet = wb1.cloneSheet(2);
+        wb1.setSheetName(4, "Clone 2");
         sheet.setRepeatingRows(CellRangeAddress.valueOf("2:3"));
-        wb.setPrintArea(4, "$A$4:$C$10");
+        wb1.setPrintArea(4, "$A$4:$C$10");
 
-        wb.removeSheetAt(2);
+        wb1.removeSheetAt(2);
 
-        Workbook wbBack = HSSFTestDataSamples.writeOutAndReadBack(wb);
-        assertEquals(4, wbBack.getNumberOfSheets());
-        
-//        OutputStream fOut = new FileOutputStream("C:\\temp\\56325a.xls");
-//        try {
-//             wb.write(fOut);
-//        } finally {
-//             fOut.close();
-//        }
+        Workbook wb2 = HSSFTestDataSamples.writeOutAndReadBack(wb1);
+        assertEquals(4, wb2.getNumberOfSheets());
+        wb2.close();
+        wb1.close();
     }
 
     /**
@@ -2652,6 +2700,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
 
         // Try to evaluate everything
         eval.evaluateAll();
+        wb.close();
     }
 
     /**
@@ -2673,8 +2722,9 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         // Switch to newStyle, style is now un-used
         cell.setCellStyle(newStyle);
 
-        // Optimise
+        // Optimize
         HSSFOptimiser.optimiseCellStyles(workbook);
+        workbook.close();
     }
 
     /**
@@ -2687,6 +2737,7 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         assertFormula(wb, s.getRow(2).getCell(0), "(C2:D3 D3:E4)", "4.0");
         assertFormula(wb, s.getRow(6).getCell(0), "Tabelle2!E:E Tabelle2!$A11:$IV11", "5.0");
         assertFormula(wb, s.getRow(8).getCell(0), "Tabelle2!E:F Tabelle2!$A11:$IV12", null);
+        wb.close();
     }
     
     private void assertFormula(Workbook wb, Cell intF, String expectedFormula, String expectedResultOrNull) {
@@ -2707,23 +2758,25 @@ public final class TestBugs extends BaseTestBugzillaIssues {
     }
 
     @Test
-    public void bug42016() {
+    public void bug42016() throws Exception {
         Workbook wb = openSample("42016.xls");
         Sheet s = wb.getSheetAt(0);
         for(int row = 0;row < 7;row++) {
             assertEquals("A$1+B$1", s.getRow(row).getCell(2).getCellFormula());
         }
+        wb.close();
     }
 
     /**
      * Unexpected record type (org.apache.poi.hssf.record.ColumnInfoRecord)
      */
     @Test
-    public void bug53984() {
+    public void bug53984() throws Exception {
         Workbook wb = openSample("53984.xls");
         Sheet s = wb.getSheetAt(0);
         assertEquals("International Communication Services SA", s.getRow(2).getCell(0).getStringCellValue());
         assertEquals("Saudi Arabia-Riyadh", s.getRow(210).getCell(0).getStringCellValue());
+        wb.close();
     }
 
     /**
@@ -2733,9 +2786,9 @@ public final class TestBugs extends BaseTestBugzillaIssues {
      * TODO Fix this so that it works - formulas are ending up as
      *  #REF when being changed
      */
-//    @Test
-    public void bug46670_existing() {
-        HSSFWorkbook wb;
+    @Test
+    @Ignore
+    public void bug46670_existing() throws Exception {
         Sheet s;
         Cell c;
 
@@ -2744,36 +2797,41 @@ public final class TestBugs extends BaseTestBugzillaIssues {
         String refHttp  = "'[9http://www.principlesofeconometrics.com/excel/airline.xls]Sheet1'!$A$2";
 
         // Check we can read them correctly
-        wb = openSample("46670_local.xls");
-        s = wb.getSheetAt(0);
+        HSSFWorkbook wb1 = openSample("46670_local.xls");
+        s = wb1.getSheetAt(0);
         assertEquals(refLocal, s.getRow(0).getCell(0).getCellFormula());
+        wb1.close();
 
-        wb = openSample("46670_http.xls");
-        s = wb.getSheetAt(0);
+        HSSFWorkbook wb2 = openSample("46670_http.xls");
+        s = wb2.getSheetAt(0);
         assertEquals(refHttp, s.getRow(0).getCell(0).getCellFormula());
+        wb2.close();
 
         // Now try to set them to the same values, and ensure that
         //  they end up as they did before, even with a save and re-load
-        wb = openSample("46670_local.xls");
-        s = wb.getSheetAt(0);
+        HSSFWorkbook wb3 = openSample("46670_local.xls");
+        s = wb3.getSheetAt(0);
         c = s.getRow(0).getCell(0);
         c.setCellFormula(refLocal);
         assertEquals(refLocal, c.getCellFormula());
 
-        wb = HSSFTestDataSamples.writeOutAndReadBack(wb);
-        s = wb.getSheetAt(0);
+        HSSFWorkbook wb4 = HSSFTestDataSamples.writeOutAndReadBack(wb3);
+        wb3.close();
+        s = wb4.getSheetAt(0);
         assertEquals(refLocal, s.getRow(0).getCell(0).getCellFormula());
+        wb4.close();
 
-
-        wb = openSample("46670_http.xls");
-        s = wb.getSheetAt(0);
+        HSSFWorkbook wb5 = openSample("46670_http.xls");
+        s = wb5.getSheetAt(0);
         c = s.getRow(0).getCell(0);
         c.setCellFormula(refHttp);
         assertEquals(refHttp, c.getCellFormula());
 
-        wb = HSSFTestDataSamples.writeOutAndReadBack(wb);
-        s = wb.getSheetAt(0);
+        HSSFWorkbook wb6 = HSSFTestDataSamples.writeOutAndReadBack(wb5);
+        wb5.close();
+        s = wb6.getSheetAt(0);
         assertEquals(refHttp, s.getRow(0).getCell(0).getCellFormula());
+        wb6.close();
     }
 
     @Test
@@ -2794,22 +2852,24 @@ public final class TestBugs extends BaseTestBugzillaIssues {
 
     @Test
     public void test53109() throws IOException {
-        HSSFWorkbook wb = openSample("53109.xls");
+        HSSFWorkbook wb1 = openSample("53109.xls");
         
-        Workbook wbBack = HSSFTestDataSamples.writeOutAndReadBack(wb);
-        assertNotNull(wbBack);
+        HSSFWorkbook wb2 = writeOutAndReadBack(wb1);
+        assertNotNull(wb2);
+        wb2.close();
         
-        wb.close();
+        wb1.close();
     }
     
     @Test
     public void test53109a() throws IOException {
-        HSSFWorkbook wb = openSample("com.aida-tour.www_SPO_files_maldives%20august%20october.xls");
+        HSSFWorkbook wb1 = openSample("com.aida-tour.www_SPO_files_maldives%20august%20october.xls");
         
-        Workbook wbBack = HSSFTestDataSamples.writeOutAndReadBack(wb);
-        assertNotNull(wbBack);
+        Workbook wb2 = writeOutAndReadBack(wb1);
+        assertNotNull(wb2);
+        wb2.close();
         
-        wb.close();
+        wb1.close();
     }
     
     @Test
index be36585be632dd906fadd804dc5b9c6794e0651b..fa9f70f66b5336558957118ae18d652f47258ae8 100644 (file)
@@ -53,7 +53,7 @@ public abstract class BaseTestBugzillaIssues {
     protected BaseTestBugzillaIssues(ITestDataProvider testDataProvider) {
         _testDataProvider = testDataProvider;
     }
-    
+
     public static void assertAlmostEquals(double expected, double actual, float factor) {
         double diff = Math.abs(expected - actual);
         double fuzz = expected * factor;
@@ -68,20 +68,23 @@ public abstract class BaseTestBugzillaIssues {
      * Also tests bug 15353 (problems with hyperlinks to Google)
      */
     @Test
-    public final void bug23094() {
-        Workbook wb = _testDataProvider.createWorkbook();
-        Sheet s = wb.createSheet();
+    public final void bug23094() throws Exception {
+        Workbook wb1 = _testDataProvider.createWorkbook();
+        Sheet s = wb1.createSheet();
         Row r = s.createRow(0);
         r.createCell(0).setCellFormula("HYPERLINK(\"http://jakarta.apache.org\",\"Jakarta\")");
         r.createCell(1).setCellFormula("HYPERLINK(\"http://google.com\",\"Google\")");
 
-        wb = _testDataProvider.writeOutAndReadBack(wb);
-        r = wb.getSheetAt(0).getRow(0);
+        Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+        wb1.close();
+        r = wb2.getSheetAt(0).getRow(0);
 
         Cell cell_0 = r.getCell(0);
         assertEquals("HYPERLINK(\"http://jakarta.apache.org\",\"Jakarta\")", cell_0.getCellFormula());
         Cell cell_1 = r.getCell(1);
         assertEquals("HYPERLINK(\"http://google.com\",\"Google\")", cell_1.getCellFormula());
+
+        wb2.close();
     }
 
     /**
@@ -89,10 +92,10 @@ public abstract class BaseTestBugzillaIssues {
      * open resulting file in Excel to check results!
      * @param  num the number of strings to generate
      */
-    public final void bug15375(int num) {
-        Workbook wb = _testDataProvider.createWorkbook();
-        Sheet sheet = wb.createSheet();
-        CreationHelper factory = wb.getCreationHelper();
+    public final void bug15375(int num) throws Exception {
+        Workbook wb1 = _testDataProvider.createWorkbook();
+        Sheet sheet = wb1.createSheet();
+        CreationHelper factory = wb1.getCreationHelper();
 
         String tmp1 = null;
         String tmp2 = null;
@@ -112,7 +115,10 @@ public abstract class BaseTestBugzillaIssues {
             cell = row.createCell(2);
             cell.setCellValue(factory.createRichTextString(tmp3));
         }
-        wb = _testDataProvider.writeOutAndReadBack(wb);
+        Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+        wb1.close();
+
+        sheet = wb2.getSheetAt(0);
         for (int i = 0; i < num; i++) {
             tmp1 = "Test1" + i;
             tmp2 = "Test2" + i;
@@ -124,21 +130,22 @@ public abstract class BaseTestBugzillaIssues {
             assertEquals(tmp2, row.getCell(1).getStringCellValue());
             assertEquals(tmp3, row.getCell(2).getStringCellValue());
         }
+        wb2.close();
     }
 
     /**
      * Merged regions were being removed from the parent in cloned sheets
      */
     @Test
-    public void bug22720() {
-       Workbook workBook = _testDataProvider.createWorkbook();
-       workBook.createSheet("TEST");
-       Sheet template = workBook.getSheetAt(0);
+    public void bug22720() throws Exception {
+       Workbook wb = _testDataProvider.createWorkbook();
+       wb.createSheet("TEST");
+       Sheet template = wb.getSheetAt(0);
 
        template.addMergedRegion(new CellRangeAddress(0, 1, 0, 2));
        template.addMergedRegion(new CellRangeAddress(1, 2, 0, 2));
 
-       Sheet clone = workBook.cloneSheet(0);
+       Sheet clone = wb.cloneSheet(0);
        int originalMerged = template.getNumMergedRegions();
        assertEquals("2 merged regions", 2, originalMerged);
 
@@ -154,14 +161,14 @@ public abstract class BaseTestBugzillaIssues {
             template.getMergedRegion(0);
        }
        //make sure we dont exception
-
+       wb.close();
     }
 
     @Test
-    public final void bug28031() {
-        Workbook wb = _testDataProvider.createWorkbook();
-        Sheet sheet = wb.createSheet();
-        wb.setSheetName(0, "Sheet1");
+    public final void bug28031() throws Exception {
+        Workbook wb1 = _testDataProvider.createWorkbook();
+        Sheet sheet = wb1.createSheet();
+        wb1.setSheetName(0, "Sheet1");
 
         Row row = sheet.createRow(0);
         Cell cell = row.createCell(0);
@@ -170,9 +177,12 @@ public abstract class BaseTestBugzillaIssues {
         cell.setCellFormula(formulaText);
 
         assertEquals(formulaText, cell.getCellFormula());
-        wb = _testDataProvider.writeOutAndReadBack(wb);
-        cell = wb.getSheetAt(0).getRow(0).getCell(0);
+        Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+        wb1.close();
+
+        cell = wb2.getSheetAt(0).getRow(0).getCell(0);
         assertEquals("IF(ROUND(A2*B2*C2,2)>ROUND(B2*D2,2),ROUND(A2*B2*C2,2),ROUND(B2*D2,2))", cell.getCellFormula());
+        wb2.close();
     }
 
     /**
@@ -181,26 +191,28 @@ public abstract class BaseTestBugzillaIssues {
      * {=SUM(IF(FREQUENCY(IF(LEN(V4:V220)>0,MATCH(V4:V220,V4:V220,0),""),IF(LEN(V4:V220)>0,MATCH(V4:V220,V4:V220,0),""))>0,1))}
      */
     @Test
-    public final void bug21334() {
-        Workbook wb = _testDataProvider.createWorkbook();
-        Sheet sh = wb.createSheet();
+    public final void bug21334() throws Exception {
+        Workbook wb1 = _testDataProvider.createWorkbook();
+        Sheet sh = wb1.createSheet();
         Cell cell = sh.createRow(0).createCell(0);
         String formula = "SUM(IF(FREQUENCY(IF(LEN(V4:V220)>0,MATCH(V4:V220,V4:V220,0),\"\"),IF(LEN(V4:V220)>0,MATCH(V4:V220,V4:V220,0),\"\"))>0,1))";
         cell.setCellFormula(formula);
 
-        Workbook wb_sv = _testDataProvider.writeOutAndReadBack(wb);
-        Cell cell_sv = wb_sv.getSheetAt(0).getRow(0).getCell(0);
+        Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+        wb1.close();
+        Cell cell_sv = wb2.getSheetAt(0).getRow(0).getCell(0);
         assertEquals(formula, cell_sv.getCellFormula());
+        wb2.close();
     }
 
     /** another test for the number of unique strings issue
      *test opening the resulting file in Excel*/
     @Test
-    public final void bug22568() {
+    public final void bug22568() throws Exception {
         int r=2000;int c=3;
 
-        Workbook wb = _testDataProvider.createWorkbook();
-        Sheet sheet = wb.createSheet("ExcelTest") ;
+        Workbook wb1 = _testDataProvider.createWorkbook();
+        Sheet sheet = wb1.createSheet("ExcelTest") ;
 
         int col_cnt=0, rw_cnt=0 ;
 
@@ -225,8 +237,9 @@ public abstract class BaseTestBugzillaIssues {
 
         sheet.setDefaultColumnWidth(18) ;
 
-        wb = _testDataProvider.writeOutAndReadBack(wb);
-        sheet = wb.getSheetAt(0);
+        Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+        wb1.close();
+        sheet = wb2.getSheetAt(0);
         rw = sheet.getRow(0);
         //Header row
         for(int j=0; j<col_cnt; j++){
@@ -240,32 +253,36 @@ public abstract class BaseTestBugzillaIssues {
                 assertEquals("Row:" + (i+1) + ",Column:" + (j+1), cell.getStringCellValue());
             }
         }
+        wb2.close();
     }
 
     /**
      * Bug 42448: Can't parse SUMPRODUCT(A!C7:A!C67, B8:B68) / B69
      */
     @Test
-    public final void bug42448(){
+    public final void bug42448() throws Exception {
         Workbook wb = _testDataProvider.createWorkbook();
         Cell cell = wb.createSheet().createRow(0).createCell(0);
         cell.setCellFormula("SUMPRODUCT(A!C7:A!C67, B8:B68) / B69");
         assertTrue("no errors parsing formula", true);
+        wb.close();
     }
 
     @Test
-    public void bug18800() {
-       Workbook book = _testDataProvider.createWorkbook();
-       book.createSheet("TEST");
-       Sheet sheet = book.cloneSheet(0);
-       book.setSheetName(1,"CLONE");
+    public void bug18800() throws Exception {
+       Workbook wb1 = _testDataProvider.createWorkbook();
+       wb1.createSheet("TEST");
+       Sheet sheet = wb1.cloneSheet(0);
+       wb1.setSheetName(1,"CLONE");
        sheet.createRow(0).createCell(0).setCellValue("Test");
 
-       book = _testDataProvider.writeOutAndReadBack(book);
-       sheet = book.getSheet("CLONE");
+       Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+       wb1.close();
+       sheet = wb2.getSheet("CLONE");
        Row row = sheet.getRow(0);
        Cell cell = row.getCell(0);
        assertEquals("Test", cell.getRichStringCellValue().getString());
+       wb2.close();
    }
 
     private static void addNewSheetWithCellsA1toD4(Workbook book, int sheet) {
@@ -283,7 +300,7 @@ public abstract class BaseTestBugzillaIssues {
     }
 
     @Test
-    public void bug43093() {
+    public void bug43093() throws Exception {
         Workbook xlw = _testDataProvider.createWorkbook();
 
         addNewSheetWithCellsA1toD4(xlw, 1);
@@ -300,10 +317,12 @@ public abstract class BaseTestBugzillaIssues {
         double d = eva.evaluate(s2E4).getNumberValue();
 
         assertEquals(d, (311+312+321+322), 0.0000001);
+
+        xlw.close();
     }
 
     @Test
-    public void bug46729_testMaxFunctionArguments(){
+    public void bug46729_testMaxFunctionArguments() throws Exception {
         String[] func = {"COUNT", "AVERAGE", "MAX", "MIN", "OR", "SUBTOTAL", "SKEW"};
 
         SpreadsheetVersion ssVersion = _testDataProvider.getSpreadsheetVersion();
@@ -327,6 +346,7 @@ public abstract class BaseTestBugzillaIssues {
                  assertTrue(e.getMessage().startsWith("Too many arguments to function '"+name+"'"));
             }
         }
+        wb.close();
     }
 
     private static String createFunction(String name, int maxArgs){
@@ -342,7 +362,7 @@ public abstract class BaseTestBugzillaIssues {
     }
 
     @Test
-    public final void bug50681_testAutoSize() {
+    public final void bug50681_testAutoSize() throws Exception {
         Workbook wb = _testDataProvider.createWorkbook();
         BaseTestSheetAutosizeColumn.fixFonts(wb);
         Sheet sheet = wb.createSheet("Sheet1");
@@ -360,12 +380,12 @@ public abstract class BaseTestBugzillaIssues {
 
         // autoSize will fail if required fonts are not installed, skip this test then
         Font font = wb.getFontAt(cell0.getCellStyle().getFontIndex());
-        Assume.assumeTrue("Cannot verify auoSizeColumn() because the necessary Fonts are not installed on this machine: " + font, 
+        Assume.assumeTrue("Cannot verify auoSizeColumn() because the necessary Fonts are not installed on this machine: " + font,
                 SheetUtil.canComputeColumnWidht(font));
-        
+
         assertEquals("Expecting no indentation in this test",
                 0, cell0.getCellStyle().getIndention());
-        assertEquals("Expecting no rotation in this test", 
+        assertEquals("Expecting no rotation in this test",
                 0, cell0.getCellStyle().getRotation());
 
         // check computing size up to a large size
@@ -378,26 +398,27 @@ public abstract class BaseTestBugzillaIssues {
         double widthBeforeCell = SheetUtil.getCellWidth(cell0, 8, null, false);
         double widthBeforeCol = SheetUtil.getColumnWidth(sheet, 0, false);
 
-        String info = widthManual + "/" + widthBeforeCell + "/" + widthBeforeCol + "/" + 
-                        SheetUtil.canComputeColumnWidht(font) + "/" + computeCellWidthFixed(font, "1") + "/" + computeCellWidthFixed(font, "w") + "/" + 
+        String info = widthManual + "/" + widthBeforeCell + "/" + widthBeforeCol + "/" +
+                        SheetUtil.canComputeColumnWidht(font) + "/" + computeCellWidthFixed(font, "1") + "/" + computeCellWidthFixed(font, "w") + "/" +
                         computeCellWidthFixed(font, "1w") + "/" + computeCellWidthFixed(font, "0000") + "/" + computeCellWidthFixed(font, longValue);
         assertTrue("Expected to have cell width > 0 when computing manually, but had " + info, widthManual > 0);
         assertTrue("Expected to have cell width > 0 BEFORE auto-size, but had " + info, widthBeforeCell > 0);
         assertTrue("Expected to have column width > 0 BEFORE auto-size, but had " + info, widthBeforeCol > 0);
 
         sheet.autoSizeColumn(0);
-        
+
         double width = SheetUtil.getColumnWidth(sheet, 0, false);
         assertTrue("Expected to have column width > 0 AFTER auto-size, but had " + width, width > 0);
         width = SheetUtil.getCellWidth(cell0, 8, null, false);
         assertTrue("Expected to have cell width > 0 AFTER auto-size, but had " + width, width > 0);
-        
+
         assertEquals(255*256, sheet.getColumnWidth(0)); // maximum column width is 255 characters
         sheet.setColumnWidth(0, sheet.getColumnWidth(0)); // Bug 506819 reports exception at this point
+        wb.close();
     }
 
     private double computeCellWidthManually(Cell cell0, Font font) {
-        final FontRenderContext fontRenderContext = new FontRenderContext(null, true, true);        
+        final FontRenderContext fontRenderContext = new FontRenderContext(null, true, true);
         RichTextString rt = cell0.getRichStringCellValue();
         String[] lines = rt.getString().split("\\n");
         assertEquals(1, lines.length);
@@ -415,7 +436,7 @@ public abstract class BaseTestBugzillaIssues {
     }
 
     private double computeCellWidthFixed(Font font, String txt) {
-        final FontRenderContext fontRenderContext = new FontRenderContext(null, true, true);        
+        final FontRenderContext fontRenderContext = new FontRenderContext(null, true, true);
         AttributedString str = new AttributedString(txt);
         copyAttributes(font, str, 0, txt.length());
 
@@ -430,7 +451,7 @@ public abstract class BaseTestBugzillaIssues {
         if (font.getItalic() ) str.addAttribute(TextAttribute.POSTURE, TextAttribute.POSTURE_OBLIQUE, startIdx, endIdx);
         if (font.getUnderline() == Font.U_SINGLE ) str.addAttribute(TextAttribute.UNDERLINE, TextAttribute.UNDERLINE_ON, startIdx, endIdx);
     }
-    
+
     /**
      * CreateFreezePane column/row order check
      */
@@ -481,35 +502,38 @@ public abstract class BaseTestBugzillaIssues {
         assertEquals(0,  paneInfo.getHorizontalSplitPosition());
         assertEquals(4 , paneInfo.getVerticalSplitLeftColumn());
         assertEquals(0,  paneInfo.getHorizontalSplitTopRow());
+        wb.close();
     }
 
-    /** 
+    /**
      * Test hyperlinks
      * open resulting file in excel, and check that there is a link to Google
      */
     @Test
-    public void bug15353() {
+    public void bug15353() throws Exception {
         String hyperlinkF = "HYPERLINK(\"http://google.com\",\"Google\")";
-        
-        Workbook wb = _testDataProvider.createWorkbook();
-        Sheet sheet = wb.createSheet("My sheet");
+
+        Workbook wb1 = _testDataProvider.createWorkbook();
+        Sheet sheet = wb1.createSheet("My sheet");
 
         Row row = sheet.createRow(0);
         Cell cell = row.createCell(0);
         cell.setCellFormula(hyperlinkF);
-        
+
         assertEquals(hyperlinkF, cell.getCellFormula());
 
-        wb = _testDataProvider.writeOutAndReadBack(wb);
-        sheet = wb.getSheet("My Sheet");
+        Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+        wb1.close();
+        sheet = wb2.getSheet("My Sheet");
         row = sheet.getRow(0);
         cell = row.getCell(0);
-        
+
         assertEquals(hyperlinkF, cell.getCellFormula());
+        wb2.close();
     }
 
     /**
-     * HLookup and VLookup with optional arguments 
+     * HLookup and VLookup with optional arguments
      */
     @Test
     public void bug51024() throws Exception {
@@ -544,17 +568,19 @@ public abstract class BaseTestBugzillaIssues {
 
         c.setCellFormula("HLOOKUP(\"v A1\", A1:B2, 1, )");
         assertEquals("v A1", eval.evaluate(c).getStringValue());
+
+        wb.close();
     }
-    
+
     @Test
     public void stackoverflow23114397() throws Exception {
         Workbook wb = _testDataProvider.createWorkbook();
         DataFormat format = wb.getCreationHelper().createDataFormat();
-        
+
         // How close the sizing should be, given that not all
         //  systems will have quite the same fonts on them
         float fontAccuracy = 0.22f;
-        
+
         // x%
         CellStyle iPercent = wb.createCellStyle();
         iPercent.setDataFormat(format.getFormat("0%"));
@@ -564,10 +590,10 @@ public abstract class BaseTestBugzillaIssues {
         // x.xx%
         CellStyle d2Percent = wb.createCellStyle();
         d2Percent.setDataFormat(format.getFormat("0.00%"));
-        
+
         Sheet s = wb.createSheet();
         Row r1 = s.createRow(0);
-        
+
         for (int i=0; i<3; i++) {
             r1.createCell(i, Cell.CELL_TYPE_NUMERIC).setCellValue(0);
         }
@@ -588,30 +614,32 @@ public abstract class BaseTestBugzillaIssues {
         for (int i=0; i<12; i++) {
             s.autoSizeColumn(i);
         }
-        
+
         // Check the 0(.00)% ones
         assertAlmostEquals(980, s.getColumnWidth(0), fontAccuracy);
         assertAlmostEquals(1400, s.getColumnWidth(1), fontAccuracy);
         assertAlmostEquals(1700, s.getColumnWidth(2), fontAccuracy);
-        
+
         // Check the 100(.00)% ones
         assertAlmostEquals(1500, s.getColumnWidth(3), fontAccuracy);
         assertAlmostEquals(1950, s.getColumnWidth(4), fontAccuracy);
         assertAlmostEquals(2225, s.getColumnWidth(5), fontAccuracy);
-        
+
         // Check the 12(.34)% ones
         assertAlmostEquals(1225, s.getColumnWidth(6), fontAccuracy);
         assertAlmostEquals(1650, s.getColumnWidth(7), fontAccuracy);
         assertAlmostEquals(1950, s.getColumnWidth(8), fontAccuracy);
-        
+
         // Check the 123(.45)% ones
         assertAlmostEquals(1500, s.getColumnWidth(9), fontAccuracy);
         assertAlmostEquals(1950, s.getColumnWidth(10), fontAccuracy);
         assertAlmostEquals(2225, s.getColumnWidth(11), fontAccuracy);
+
+        wb.close();
     }
 
     /**
-     * =ISNUMBER(SEARCH("AM",A1)) evaluation 
+     * =ISNUMBER(SEARCH("AM",A1)) evaluation
      */
     @Test
     public void stackoverflow26437323() throws Exception {
@@ -619,7 +647,7 @@ public abstract class BaseTestBugzillaIssues {
         Sheet s = wb.createSheet();
         Row r1 = s.createRow(0);
         Row r2 = s.createRow(1);
-        
+
         // A1 is a number
         r1.createCell(0).setCellValue(1.1);
         // B1 is a string, with the wanted text in it
@@ -629,134 +657,137 @@ public abstract class BaseTestBugzillaIssues {
         // D1 is a blank cell
         r1.createCell(3, Cell.CELL_TYPE_BLANK);
         // E1 is null
-        
+
         // A2 will hold our test formulas
         Cell cf = r2.createCell(0, Cell.CELL_TYPE_FORMULA);
-        
-        
+
+
         // First up, check that TRUE and ISLOGICAL both behave
         cf.setCellFormula("TRUE()");
         cf = evaluateCell(wb, cf);
         assertEquals(true, cf.getBooleanCellValue());
-        
+
         cf.setCellFormula("ISLOGICAL(TRUE())");
         cf = evaluateCell(wb, cf);
         assertEquals(true, cf.getBooleanCellValue());
-        
+
         cf.setCellFormula("ISLOGICAL(4)");
         cf = evaluateCell(wb, cf);
         assertEquals(false, cf.getBooleanCellValue());
-        
-        
+
+
         // Now, check ISNUMBER / ISTEXT / ISNONTEXT
         cf.setCellFormula("ISNUMBER(A1)");
         cf = evaluateCell(wb, cf);
         assertEquals(true, cf.getBooleanCellValue());
-        
+
         cf.setCellFormula("ISNUMBER(B1)");
         cf = evaluateCell(wb, cf);
         assertEquals(false, cf.getBooleanCellValue());
-        
+
         cf.setCellFormula("ISNUMBER(C1)");
         cf = evaluateCell(wb, cf);
         assertEquals(false, cf.getBooleanCellValue());
-        
+
         cf.setCellFormula("ISNUMBER(D1)");
         cf = evaluateCell(wb, cf);
         assertEquals(false, cf.getBooleanCellValue());
-        
+
         cf.setCellFormula("ISNUMBER(E1)");
         cf = evaluateCell(wb, cf);
         assertEquals(false, cf.getBooleanCellValue());
 
-        
+
         cf.setCellFormula("ISTEXT(A1)");
         cf = evaluateCell(wb, cf);
         assertEquals(false, cf.getBooleanCellValue());
-        
+
         cf.setCellFormula("ISTEXT(B1)");
         cf = evaluateCell(wb, cf);
         assertEquals(true, cf.getBooleanCellValue());
-        
+
         cf.setCellFormula("ISTEXT(C1)");
         cf = evaluateCell(wb, cf);
         assertEquals(true, cf.getBooleanCellValue());
-        
+
         cf.setCellFormula("ISTEXT(D1)");
         cf = evaluateCell(wb, cf);
         assertEquals(false, cf.getBooleanCellValue());
-        
+
         cf.setCellFormula("ISTEXT(E1)");
         cf = evaluateCell(wb, cf);
         assertEquals(false, cf.getBooleanCellValue());
 
-        
+
         cf.setCellFormula("ISNONTEXT(A1)");
         cf = evaluateCell(wb, cf);
         assertEquals(true, cf.getBooleanCellValue());
-        
+
         cf.setCellFormula("ISNONTEXT(B1)");
         cf = evaluateCell(wb, cf);
         assertEquals(false, cf.getBooleanCellValue());
-        
+
         cf.setCellFormula("ISNONTEXT(C1)");
         cf = evaluateCell(wb, cf);
         assertEquals(false, cf.getBooleanCellValue());
-        
+
         cf.setCellFormula("ISNONTEXT(D1)");
         cf = evaluateCell(wb, cf);
         assertEquals(true, cf.getBooleanCellValue());
-        
+
         cf.setCellFormula("ISNONTEXT(E1)");
         cf = evaluateCell(wb, cf);
         assertEquals(true, cf.getBooleanCellValue()); // Blank and Null the same
 
-        
+
         // Next up, SEARCH on its own
         cf.setCellFormula("SEARCH(\"am\", A1)");
         cf = evaluateCell(wb, cf);
         assertEquals(FormulaError.VALUE.getCode(), cf.getErrorCellValue());
-        
+
         cf.setCellFormula("SEARCH(\"am\", B1)");
         cf = evaluateCell(wb, cf);
         assertEquals(19, (int)cf.getNumericCellValue());
-        
+
         cf.setCellFormula("SEARCH(\"am\", C1)");
         cf = evaluateCell(wb, cf);
         assertEquals(FormulaError.VALUE.getCode(), cf.getErrorCellValue());
-        
+
         cf.setCellFormula("SEARCH(\"am\", D1)");
         cf = evaluateCell(wb, cf);
         assertEquals(FormulaError.VALUE.getCode(), cf.getErrorCellValue());
-        
-        
+
+
         // Finally, bring it all together
         cf.setCellFormula("ISNUMBER(SEARCH(\"am\", A1))");
         cf = evaluateCell(wb, cf);
         assertEquals(false, cf.getBooleanCellValue());
-        
+
         cf.setCellFormula("ISNUMBER(SEARCH(\"am\", B1))");
         cf = evaluateCell(wb, cf);
         assertEquals(true, cf.getBooleanCellValue());
-        
+
         cf.setCellFormula("ISNUMBER(SEARCH(\"am\", C1))");
         cf = evaluateCell(wb, cf);
         assertEquals(false, cf.getBooleanCellValue());
-        
+
         cf.setCellFormula("ISNUMBER(SEARCH(\"am\", D1))");
         cf = evaluateCell(wb, cf);
         assertEquals(false, cf.getBooleanCellValue());
-        
+
         cf.setCellFormula("ISNUMBER(SEARCH(\"am\", E1))");
         cf = evaluateCell(wb, cf);
-        assertEquals(false, cf.getBooleanCellValue());        
+        assertEquals(false, cf.getBooleanCellValue());
+
+        wb.close();
     }
+
     private Cell evaluateCell(Workbook wb, Cell c) {
         Sheet s = c.getSheet();
         wb.getCreationHelper().createFormulaEvaluator().evaluateFormulaCell(c);
         return s.getRow(c.getRowIndex()).getCell(c.getColumnIndex());
     }
-    
+
     /**
      * Should be able to write then read formulas with references
      *  to cells in other files, eg '[refs/airport.xls]Sheet1'!$A$2
@@ -769,110 +800,114 @@ public abstract class BaseTestBugzillaIssues {
     @Ignore("Fix this to evaluate for XSSF, Fix this to work at all for HSSF")
     @Test
     public void bug46670() throws Exception {
-        Workbook wb = _testDataProvider.createWorkbook();
-        Sheet s = wb.createSheet();
+        Workbook wb1 = _testDataProvider.createWorkbook();
+        Sheet s = wb1.createSheet();
         Row r1 = s.createRow(0);
-        
-        
+
+
         // References to try
         String ext = _testDataProvider.getStandardFileNameExtension();
         String refLocal = "'[test."+ext+"]Sheet1'!$A$2";
         String refHttp  = "'[http://example.com/test."+ext+"]Sheet1'!$A$2";
         String otherCellText = "In Another Workbook";
 
-        
+
         // Create the references
         Cell c1 = r1.createCell(0, Cell.CELL_TYPE_FORMULA);
         c1.setCellFormula(refLocal);
-        
+
         Cell c2 = r1.createCell(1, Cell.CELL_TYPE_FORMULA);
         c2.setCellFormula(refHttp);
-        
-        
+
+
         // Check they were set correctly
         assertEquals(refLocal, c1.getCellFormula());
         assertEquals(refHttp,  c2.getCellFormula());
-        
-        
+
+
         // Reload, and ensure they were serialised and read correctly
-        wb = _testDataProvider.writeOutAndReadBack(wb);
-        s = wb.getSheetAt(0);
+        Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+        wb1.close();
+        s = wb2.getSheetAt(0);
         r1 = s.getRow(0);
-        
+
         c1 = r1.getCell(0);
         c2 = r1.getCell(1);
         assertEquals(refLocal, c1.getCellFormula());
         assertEquals(refHttp,  c2.getCellFormula());
 
-        
+
         // Try to evaluate, without giving a way to get at the other file
         try {
-            evaluateCell(wb, c1);
+            evaluateCell(wb2, c1);
             fail("Shouldn't be able to evaluate without the other file");
         } catch (Exception e) {}
         try {
-            evaluateCell(wb, c2);
+            evaluateCell(wb2, c2);
             fail("Shouldn't be able to evaluate without the other file");
         } catch (Exception e) {}
-        
-        
+
+
         // Set up references to the other file
-        Workbook wb2 = _testDataProvider.createWorkbook();
-        wb2.createSheet().createRow(1).createCell(0).setCellValue(otherCellText);
-        
+        Workbook wb3 = _testDataProvider.createWorkbook();
+        wb3.createSheet().createRow(1).createCell(0).setCellValue(otherCellText);
+
         Map<String,FormulaEvaluator> evaluators = new HashMap<String, FormulaEvaluator>();
-        evaluators.put(refLocal, wb2.getCreationHelper().createFormulaEvaluator());
-        evaluators.put(refHttp,  wb2.getCreationHelper().createFormulaEvaluator());
-        
-        FormulaEvaluator evaluator = wb.getCreationHelper().createFormulaEvaluator();
+        evaluators.put(refLocal, wb3.getCreationHelper().createFormulaEvaluator());
+        evaluators.put(refHttp,  wb3.getCreationHelper().createFormulaEvaluator());
+
+        FormulaEvaluator evaluator = wb2.getCreationHelper().createFormulaEvaluator();
         evaluator.setupReferencedWorkbooks(evaluators);
-        
-        
+
+
         // Try to evaluate, with the other file
         evaluator.evaluateFormulaCell(c1);
         evaluator.evaluateFormulaCell(c2);
-        
+
         assertEquals(otherCellText, c1.getStringCellValue());
         assertEquals(otherCellText, c2.getStringCellValue());
+
+        wb3.close();
+        wb2.close();
     }
 
     @Test
     public void test56574OverwriteExistingRow() throws IOException {
         Workbook wb = _testDataProvider.createWorkbook();
         Sheet sheet = wb.createSheet();
-        
+
         { // create the Formula-Cell
             Row row = sheet.createRow(0);
             Cell cell = row.createCell(0);
             cell.setCellFormula("A2");
         }
-        
+
         { // check that it is there now
             Row row = sheet.getRow(0);
-            
+
            /* CTCell[] cArray = ((XSSFRow)row).getCTRow().getCArray();
             assertEquals(1, cArray.length);*/
 
             Cell cell = row.getCell(0);
             assertEquals(Cell.CELL_TYPE_FORMULA, cell.getCellType());
         }
-        
+
         { // overwrite the row
             Row row = sheet.createRow(0);
             assertNotNull(row);
         }
-        
+
         { // creating a row in place of another should remove the existing data,
             // check that the cell is gone now
             Row row = sheet.getRow(0);
-            
+
             /*CTCell[] cArray = ((XSSFRow)row).getCTRow().getCArray();
             assertEquals(0, cArray.length);*/
 
             Cell cell = row.getCell(0);
             assertNull(cell);
         }
-        
+
         // the calculation chain in XSSF is empty in a newly created workbook, so we cannot check if it is correctly updated
         /*assertNull(((XSSFWorkbook)wb).getCalculationChain());
         assertNotNull(((XSSFWorkbook)wb).getCalculationChain().getCTCalcChain());
@@ -884,7 +919,7 @@ public abstract class BaseTestBugzillaIssues {
 
     /**
      * With HSSF, if you create a font, don't change it, and
-     *  create a 2nd, you really do get two fonts that you 
+     *  create a 2nd, you really do get two fonts that you
      *  can alter as and when you want.
      * With XSSF, that wasn't the case, but this verfies
      *  that it now is again
@@ -907,20 +942,19 @@ public abstract class BaseTestBugzillaIssues {
         assertEquals(startingFonts+2, wb.getNumberOfFonts());
         /*Font c =*/ wb.createFont();
         assertEquals(startingFonts+3, wb.getNumberOfFonts());
+        
+        wb.close();
     }
 
     @Test
     public void bug57430() throws Exception {
         Workbook wb = _testDataProvider.createWorkbook();
-        try {
-            wb.createSheet("Sheet1");
+        wb.createSheet("Sheet1");
 
-            Name name1 = wb.createName();
-            name1.setNameName("FMLA");
-            name1.setRefersToFormula("Sheet1!$B$3");
-        } finally {
-            wb.close();
-        }
+        Name name1 = wb.createName();
+        name1.setNameName("FMLA");
+        name1.setRefersToFormula("Sheet1!$B$3");
+        wb.close();
     }
 
     @Test
@@ -947,7 +981,7 @@ public abstract class BaseTestBugzillaIssues {
         } finally {
             out.close();
         }*/
-        
+
         wb.close();
     }
 
@@ -960,7 +994,7 @@ public abstract class BaseTestBugzillaIssues {
         Sheet sheet = wb.createSheet();
         Drawing drawing = sheet.createDrawingPatriarch();
         ClientAnchor anchor = factory.createClientAnchor();
-        
+
         Cell cell0 = sheet.createRow(0).createCell(0);
         cell0.setCellValue("Cell0");
 
@@ -969,7 +1003,7 @@ public abstract class BaseTestBugzillaIssues {
         comment0.setString(str0);
         comment0.setAuthor("Apache POI");
         cell0.setCellComment(comment0);
-        
+
         anchor = factory.createClientAnchor();
         anchor.setCol1(1);
         anchor.setCol2(1);
@@ -1007,13 +1041,6 @@ public abstract class BaseTestBugzillaIssues {
         comment2.setColumn(2);
         comment2.setRow(2);
 
-        /*OutputStream out = new FileOutputStream("C:\\temp\\57973.xlsx");
-        try {
-            wb.write(out);
-        } finally {
-            out.close();
-        }*/
-        
         wb.close();
     }
 
@@ -1023,7 +1050,7 @@ public abstract class BaseTestBugzillaIssues {
      *  kind of value from a Formula cell
      */
     @Test
-    public void bug47815() {
+    public void bug47815() throws Exception {
         Workbook wb = _testDataProvider.createWorkbook();
         Sheet s = wb.createSheet();
         Row r = s.createRow(0);
@@ -1035,7 +1062,7 @@ public abstract class BaseTestBugzillaIssues {
         cs.setCellValue("Testing");
 
         Cell cfn = r.createCell(2, Cell.CELL_TYPE_FORMULA);
-        cfn.setCellFormula("A1");  
+        cfn.setCellFormula("A1");
         Cell cfs = r.createCell(3, Cell.CELL_TYPE_FORMULA);
         cfs.setCellFormula("B1");
 
@@ -1077,33 +1104,35 @@ public abstract class BaseTestBugzillaIssues {
             cfs.getNumericCellValue();
             fail();
         } catch(IllegalStateException e) {}
+        
+        wb.close();
     }
-    
+
     @Test
-    public void test58113() {
+    public void test58113() throws Exception {
         Workbook wb = _testDataProvider.createWorkbook();
         Sheet sheet = wb.createSheet( "Test" );
 
         Row row = sheet.createRow(0);
 
         Cell cell = row.createCell(0);
-        // verify that null-values can be set, this was possible up to 3.11, but broken in 3.12 
+        // verify that null-values can be set, this was possible up to 3.11, but broken in 3.12
         cell.setCellValue((String)null);
         String value = cell.getStringCellValue();
         assertTrue("HSSF will currently return empty string, XSSF/SXSSF will return null, but had: " + value,
                 value == null || value.length() == 0);
-        
+
         cell = row.createCell(1);
-        // also verify that setting formulas to null works  
+        // also verify that setting formulas to null works
         cell.setCellType(Cell.CELL_TYPE_FORMULA);
         cell.setCellValue((String)null);
-        
+
         wb.getCreationHelper().createFormulaEvaluator().evaluateAll();
 
         value = cell.getStringCellValue();
         assertTrue("HSSF will currently return empty string, XSSF/SXSSF will return null, but had: " + value,
                 value == null || value.length() == 0);
-        
+
         // set some value
         cell.setCellType(Cell.CELL_TYPE_STRING);
         cell.setCellValue("somevalue");
@@ -1112,23 +1141,25 @@ public abstract class BaseTestBugzillaIssues {
         assertTrue("can set value afterwards: " + value,
                 value.equals("somevalue"));
 
-        // verify that the null-value is actually set even if there was some value in the cell before  
+        // verify that the null-value is actually set even if there was some value in the cell before
         cell.setCellValue((String)null);
         value = cell.getStringCellValue();
         assertTrue("HSSF will currently return empty string, XSSF/SXSSF will return null, but had: " + value,
                 value == null || value.length() == 0);
+        
+        wb.close();
     }
-    
+
     /**
      * Formulas with Nested Ifs, or If with text functions like
      *  Mid in it, can give #VALUE in Excel
      */
     @Test
-    public void bug55747() {
-        Workbook wb = _testDataProvider.createWorkbook();
-        FormulaEvaluator ev = wb.getCreationHelper().createFormulaEvaluator();
-        Sheet s = wb.createSheet();
-        
+    public void bug55747() throws Exception {
+        Workbook wb1 = _testDataProvider.createWorkbook();
+        FormulaEvaluator ev = wb1.getCreationHelper().createFormulaEvaluator();
+        Sheet s = wb1.createSheet();
+
         Row row = s.createRow(0);
         row.createCell(0).setCellValue("abc");
         row.createCell(1).setCellValue("");
@@ -1138,38 +1169,40 @@ public abstract class BaseTestBugzillaIssues {
         cell.setCellFormula("IF(A1<>\"\",MID(A1,1,2),\" \")");
         ev.evaluateAll();
         assertEquals("ab", cell.getStringCellValue());
-        
+
         cell = row.createCell(6);
         cell.setCellFormula("IF(B1<>\"\",MID(A1,1,2),\"empty\")");
         ev.evaluateAll();
         assertEquals("empty", cell.getStringCellValue());
-        
+
         cell = row.createCell(7);
         cell.setCellFormula("IF(A1<>\"\",IF(C1<>\"\",MID(A1,1,2),\"c1\"),\"c2\")");
         ev.evaluateAll();
         assertEquals("ab", cell.getStringCellValue());
-        
+
         // Write it back out, and re-read
-        wb = _testDataProvider.writeOutAndReadBack(wb);
-        ev = wb.getCreationHelper().createFormulaEvaluator();
-        s = wb.getSheetAt(0);
+        Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+        wb1.close();
+        ev = wb2.getCreationHelper().createFormulaEvaluator();
+        s = wb2.getSheetAt(0);
         row = s.getRow(0);
-        
+
         // Check read ok, and re-evaluate fine
         cell = row.getCell(5);
         assertEquals("ab", cell.getStringCellValue());
         ev.evaluateFormulaCell(cell);
         assertEquals("ab", cell.getStringCellValue());
-        
+
         cell = row.getCell(6);
         assertEquals("empty", cell.getStringCellValue());
         ev.evaluateFormulaCell(cell);
         assertEquals("empty", cell.getStringCellValue());
-        
+
         cell = row.getCell(7);
         assertEquals("ab", cell.getStringCellValue());
         ev.evaluateFormulaCell(cell);
         assertEquals("ab", cell.getStringCellValue());
+        wb2.close();
     }
 
     @Test
@@ -1187,11 +1220,11 @@ public abstract class BaseTestBugzillaIssues {
             //Row row = worksheet.createRow(i);
 
             //Create cell style
-            final CellStyle style; 
+            CellStyle style = null;
             try {
                 style = wb.createCellStyle();
             } catch (IllegalStateException e) {
-                throw new IllegalStateException("Failed for row " + i, e);
+               fail("Failed for row " + i);
             }
             style.setAlignment(CellStyle.ALIGN_RIGHT);
             if((wb instanceof HSSFWorkbook)) {
@@ -1221,24 +1254,24 @@ public abstract class BaseTestBugzillaIssues {
         } catch (IllegalStateException e) {
             // expected here
         }
-        
+
         /*//add column width for appearance sake
         worksheet.setColumnWidth(0, 5000);
-        
-        // Write the output to a file       
+
+        // Write the output to a file
         System.out.println("Writing...");
         OutputStream fileOut = new FileOutputStream("C:\\temp\\58260." + _testDataProvider.getStandardFileNameExtension());
-        
+
         // the resulting file can be compressed nicely, so we need to disable the zip bomb detection here
         double before = ZipSecureFile.getMinInflateRatio();
         try {
             ZipSecureFile.setMinInflateRatio(0.00001);
             wb.write(fileOut);
-        } finally { 
+        } finally {
             fileOut.close();
             ZipSecureFile.setMinInflateRatio(before);
         }*/
-        
+
         wb.close();
     }
 }
index 4d6b31497333d5037bbab0d4607cda911098b16d..20451d6f3571cffec96b94ac0e21c647d607d3a7 100644 (file)
@@ -26,8 +26,6 @@ import static org.junit.Assert.fail;
 
 import java.io.IOException;
 import java.util.Calendar;
-import java.util.Locale;
-import java.util.TimeZone;
 
 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
 import org.apache.poi.ss.ITestDataProvider;
@@ -41,6 +39,7 @@ import junit.framework.AssertionFailedError;
  * Common superclass for testing implementations of
  *  {@link org.apache.poi.ss.usermodel.Cell}
  */
+@SuppressWarnings("deprecation")
 public abstract class BaseTestCell {
 
        protected final ITestDataProvider _testDataProvider;
@@ -53,7 +52,7 @@ public abstract class BaseTestCell {
        }
 
        @Test
-       public void testSetValues() {
+       public void testSetValues() throws Exception {
                Workbook book = _testDataProvider.createWorkbook();
                Sheet sheet = book.createSheet("test");
                Row row = sheet.createRow(0);
@@ -108,6 +107,8 @@ public abstract class BaseTestCell {
                assertEquals(Cell.CELL_TYPE_ERROR, cell.getCellType());
                assertProhibitedValueAccess(cell, Cell.CELL_TYPE_NUMERIC, Cell.CELL_TYPE_BOOLEAN,
                                Cell.CELL_TYPE_FORMULA, Cell.CELL_TYPE_STRING);
+               
+               book.close();
        }
 
        private static void assertProhibitedValueAccess(Cell cell, int ... types){
@@ -142,10 +143,10 @@ public abstract class BaseTestCell {
         * test that Boolean and Error types (BoolErrRecord) are supported properly.
         */
        @Test
-       public void testBoolErr() {
+       public void testBoolErr() throws Exception {
 
-               Workbook wb = _testDataProvider.createWorkbook();
-               Sheet s = wb.createSheet("testSheet1");
+               Workbook wb1 = _testDataProvider.createWorkbook();
+               Sheet s = wb1.createSheet("testSheet1");
                Row r;
                Cell c;
                r = s.createRow(0);
@@ -166,8 +167,9 @@ public abstract class BaseTestCell {
                //c.setCellType(HSSFCell.CELL_TYPE_ERROR);
                c.setCellErrorValue((byte)7);
 
-               wb = _testDataProvider.writeOutAndReadBack(wb);
-               s = wb.getSheetAt(0);
+               Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+               wb1.close();
+               s = wb2.getSheetAt(0);
                r = s.getRow(0);
                c = r.getCell(1);
                assertTrue("boolean value 0,1 = true",c.getBooleanCellValue());
@@ -178,20 +180,21 @@ public abstract class BaseTestCell {
                assertTrue("boolean value 0,1 = 0",c.getErrorCellValue() == 0);
                c = r.getCell(2);
                assertTrue("boolean value 0,2 = 7",c.getErrorCellValue() == 7);
+               wb2.close();
        }
 
        /**
         * test that Cell Styles being applied to formulas remain intact
         */
        @Test
-       public void testFormulaStyle() {
+       public void testFormulaStyle() throws Exception {
 
-               Workbook wb = _testDataProvider.createWorkbook();
-               Sheet s = wb.createSheet("testSheet1");
+               Workbook wb1 = _testDataProvider.createWorkbook();
+               Sheet s = wb1.createSheet("testSheet1");
                Row r = null;
                Cell c = null;
-               CellStyle cs = wb.createCellStyle();
-               Font f = wb.createFont();
+               CellStyle cs = wb1.createCellStyle();
+               Font f = wb1.createFont();
                f.setFontHeightInPoints((short) 20);
                f.setColor(IndexedColors.RED.getIndex());
                f.setBoldweight(Font.BOLDWEIGHT_BOLD);
@@ -208,8 +211,9 @@ public abstract class BaseTestCell {
                c.setCellStyle(cs);
                c.setCellFormula("2*3");
 
-               wb = _testDataProvider.writeOutAndReadBack(wb);
-               s = wb.getSheetAt(0);
+               Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+               wb1.close();
+               s = wb2.getSheetAt(0);
                r = s.getRow(0);
                c = r.getCell(0);
 
@@ -222,14 +226,15 @@ public abstract class BaseTestCell {
                assertTrue("Left Border", (cs.getBorderLeft() == (short)1));
                assertTrue("Right Border", (cs.getBorderRight() == (short)1));
                assertTrue("Bottom Border", (cs.getBorderBottom() == (short)1));
+               wb2.close();
        }
 
        /**tests the toString() method of HSSFCell*/
-       @Test
-       public void testToString() {
-               Workbook wb = _testDataProvider.createWorkbook();
-               Row r = wb.createSheet("Sheet1").createRow(0);
-               CreationHelper factory = wb.getCreationHelper();
+    @Test
+       public void testToString() throws Exception {
+               Workbook wb1 = _testDataProvider.createWorkbook();
+               Row r = wb1.createSheet("Sheet1").createRow(0);
+               CreationHelper factory = wb1.getCreationHelper();
 
                r.createCell(0).setCellValue(true);
                r.createCell(1).setCellValue(1.5);
@@ -244,21 +249,23 @@ public abstract class BaseTestCell {
                assertEquals("Formula", "A1+B1", r.getCell(4).toString());
 
                //Write out the file, read it in, and then check cell values
-               wb = _testDataProvider.writeOutAndReadBack(wb);
+               Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+               wb1.close();
 
-               r = wb.getSheetAt(0).getRow(0);
+               r = wb2.getSheetAt(0).getRow(0);
                assertEquals("Boolean", "TRUE", r.getCell(0).toString());
                assertEquals("Numeric", "1.5", r.getCell(1).toString());
                assertEquals("String", "Astring", r.getCell(2).toString());
                assertEquals("Error", "#DIV/0!", r.getCell(3).toString());
                assertEquals("Formula", "A1+B1", r.getCell(4).toString());
+               wb2.close();
        }
 
        /**
         *  Test that setting cached formula result keeps the cell type
         */
        @Test
-       public void testSetFormulaValue() {
+       public void testSetFormulaValue() throws Exception {
                Workbook wb = _testDataProvider.createWorkbook();
                Sheet s = wb.createSheet();
                Row r = s.createRow(0);
@@ -285,6 +292,7 @@ public abstract class BaseTestCell {
         Cell c3 = r.createCell(2);
         c3.setCellFormula(null);
         assertEquals(Cell.CELL_TYPE_BLANK, c3.getCellType());
+        wb.close();
 
     }
        private Cell createACell() {
@@ -454,9 +462,9 @@ public abstract class BaseTestCell {
         *   ClassCastException if cell is created using HSSFRow.createCell(short column, int type)
         */
        @Test
-       public void test40296() {
-               Workbook wb = _testDataProvider.createWorkbook();
-               Sheet workSheet = wb.createSheet("Sheet1");
+       public void test40296() throws Exception {
+               Workbook wb1 = _testDataProvider.createWorkbook();
+               Sheet workSheet = wb1.createSheet("Sheet1");
                Cell cell;
                Row row = workSheet.createRow(0);
 
@@ -476,8 +484,9 @@ public abstract class BaseTestCell {
                assertEquals("SUM(A1:B1)", cell.getCellFormula());
 
                //serialize and check again
-               wb = _testDataProvider.writeOutAndReadBack(wb);
-               row = wb.getSheetAt(0).getRow(0);
+               Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+               wb1.close();
+               row = wb2.getSheetAt(0).getRow(0);
                cell = row.getCell(0);
                assertEquals(Cell.CELL_TYPE_NUMERIC, cell.getCellType());
                assertEquals(1.0, cell.getNumericCellValue(), 0.0);
@@ -489,25 +498,23 @@ public abstract class BaseTestCell {
                cell = row.getCell(2);
                assertEquals(Cell.CELL_TYPE_FORMULA, cell.getCellType());
                assertEquals("SUM(A1:B1)", cell.getCellFormula());
+               wb2.close();
        }
 
        @Test
-       public void testSetStringInFormulaCell_bug44606() {
+       public void testSetStringInFormulaCell_bug44606() throws Exception {
                Workbook wb = _testDataProvider.createWorkbook();
                Cell cell = wb.createSheet("Sheet1").createRow(0).createCell(0);
                cell.setCellFormula("B1&C1");
-               try {
-                       cell.setCellValue(wb.getCreationHelper().createRichTextString("hello"));
-               } catch (ClassCastException e) {
-                       throw new AssertionFailedError("Identified bug 44606");
-               }
+               cell.setCellValue(wb.getCreationHelper().createRichTextString("hello"));
+               wb.close();
        }
 
     /**
      *  Make sure that cell.setCellType(Cell.CELL_TYPE_BLANK) preserves the cell style
      */
        @Test
-       public void testSetBlank_bug47028() {
+       public void testSetBlank_bug47028() throws Exception {
         Workbook wb = _testDataProvider.createWorkbook();
         CellStyle style = wb.createCellStyle();
         Cell cell = wb.createSheet("Sheet1").createRow(0).createCell(0);
@@ -516,6 +523,7 @@ public abstract class BaseTestCell {
         cell.setCellType(Cell.CELL_TYPE_BLANK);
         int i2 = cell.getCellStyle().getIndex();
         assertEquals(i1, i2);
+        wb.close();
     }
 
     /**
@@ -538,9 +546,9 @@ public abstract class BaseTestCell {
      * </ul>
      */
        @Test
-       public void testNanAndInfinity() {
-        Workbook wb = _testDataProvider.createWorkbook();
-        Sheet workSheet = wb.createSheet("Sheet1");
+       public void testNanAndInfinity() throws Exception {
+        Workbook wb1 = _testDataProvider.createWorkbook();
+        Sheet workSheet = wb1.createSheet("Sheet1");
         Row row = workSheet.createRow(0);
 
         Cell cell0 = row.createCell(0);
@@ -558,8 +566,9 @@ public abstract class BaseTestCell {
         assertEquals("Double.NEGATIVE_INFINITY should change cell type to CELL_TYPE_ERROR", Cell.CELL_TYPE_ERROR, cell2.getCellType());
         assertEquals("Double.NEGATIVE_INFINITY should change cell value to #DIV/0!", ErrorConstants.ERROR_DIV_0, cell2.getErrorCellValue());
 
-        wb = _testDataProvider.writeOutAndReadBack(wb);
-        row = wb.getSheetAt(0).getRow(0);
+        Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+        wb1.close();
+        row = wb2.getSheetAt(0).getRow(0);
 
         cell0 = row.getCell(0);
         assertEquals(Cell.CELL_TYPE_ERROR, cell0.getCellType());
@@ -572,13 +581,14 @@ public abstract class BaseTestCell {
         cell2 = row.getCell(2);
         assertEquals(Cell.CELL_TYPE_ERROR, cell2.getCellType());
         assertEquals(ErrorConstants.ERROR_DIV_0, cell2.getErrorCellValue());
+        wb2.close();
     }
 
        @Test
-       public void testDefaultStyleProperties() {
-        Workbook wb = _testDataProvider.createWorkbook();
+       public void testDefaultStyleProperties() throws Exception {
+        Workbook wb1 = _testDataProvider.createWorkbook();
 
-        Cell cell = wb.createSheet("Sheet1").createRow(0).createCell(0);
+        Cell cell = wb1.createSheet("Sheet1").createRow(0).createCell(0);
         CellStyle style = cell.getCellStyle();
 
         assertTrue(style.getLocked());
@@ -589,7 +599,7 @@ public abstract class BaseTestCell {
         assertEquals(0, style.getDataFormat());
         assertEquals(false, style.getWrapText());
 
-        CellStyle style2 = wb.createCellStyle();
+        CellStyle style2 = wb1.createCellStyle();
         assertTrue(style2.getLocked());
         assertFalse(style2.getHidden());
         style2.setLocked(false);
@@ -597,8 +607,9 @@ public abstract class BaseTestCell {
         assertFalse(style2.getLocked());
         assertTrue(style2.getHidden());
 
-        wb = _testDataProvider.writeOutAndReadBack(wb);
-        cell = wb.getSheetAt(0).getRow(0).getCell(0);
+        Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+        wb1.close();
+        cell = wb2.getSheetAt(0).getRow(0).getCell(0);
         style = cell.getCellStyle();
         assertFalse(style2.getLocked());
         assertTrue(style2.getHidden());
@@ -607,12 +618,13 @@ public abstract class BaseTestCell {
         style2.setHidden(false);
         assertTrue(style2.getLocked());
         assertFalse(style2.getHidden());
+        wb2.close();
     }
 
        @Test
-       public void testBug55658SetNumericValue(){
-        Workbook wb = _testDataProvider.createWorkbook();
-        Sheet sh = wb.createSheet();
+       public void testBug55658SetNumericValue() throws Exception {
+        Workbook wb1 = _testDataProvider.createWorkbook();
+        Sheet sh = wb1.createSheet();
         Row row = sh.createRow(0);
         Cell cell = row.createCell(0);
         cell.setCellValue(Integer.valueOf(23));
@@ -624,18 +636,20 @@ public abstract class BaseTestCell {
         
         cell.setCellValue("24");
 
-        wb = _testDataProvider.writeOutAndReadBack(wb);
+        Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+        wb1.close();
 
-        assertEquals("some", wb.getSheetAt(0).getRow(0).getCell(0).getStringCellValue());
-        assertEquals("24", wb.getSheetAt(0).getRow(0).getCell(1).getStringCellValue());
+        assertEquals("some", wb2.getSheetAt(0).getRow(0).getCell(0).getStringCellValue());
+        assertEquals("24", wb2.getSheetAt(0).getRow(0).getCell(1).getStringCellValue());
+        wb2.close();
     }
 
        @Test
-       public void testRemoveHyperlink(){
-        Workbook wb = _testDataProvider.createWorkbook();
-        Sheet sh = wb.createSheet("test");
+       public void testRemoveHyperlink() throws Exception {
+        Workbook wb1 = _testDataProvider.createWorkbook();
+        Sheet sh = wb1.createSheet("test");
         Row row = sh.createRow(0);
-        CreationHelper helper = wb.getCreationHelper();
+        CreationHelper helper = wb1.getCreationHelper();
 
         Cell cell1 = row.createCell(1);
         Hyperlink link1 = helper.createHyperlink(Hyperlink.LINK_URL);
@@ -657,15 +671,17 @@ public abstract class BaseTestCell {
         cell3.setHyperlink(link3);
         assertNotNull(cell3.getHyperlink());
 
-        Workbook wbBack = _testDataProvider.writeOutAndReadBack(wb);
-        assertNotNull(wbBack);
+        Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+        wb1.close();
+        assertNotNull(wb2);
         
-        cell1 = wbBack.getSheet("test").getRow(0).getCell(1);
+        cell1 = wb2.getSheet("test").getRow(0).getCell(1);
         assertNull(cell1.getHyperlink());
-        cell2 = wbBack.getSheet("test").getRow(0).getCell(0);
+        cell2 = wb2.getSheet("test").getRow(0).getCell(0);
         assertNull(cell2.getHyperlink());
-        cell3 = wbBack.getSheet("test").getRow(0).getCell(2);
+        cell3 = wb2.getSheet("test").getRow(0).getCell(2);
         assertNotNull(cell3.getHyperlink());
+        wb2.close();
     }
 
     /**
@@ -730,8 +746,8 @@ public abstract class BaseTestCell {
 
        @Test
        public void test57008() throws IOException {
-        Workbook wb = _testDataProvider.createWorkbook();
-               Sheet sheet = wb.createSheet();
+        Workbook wb1 = _testDataProvider.createWorkbook();
+               Sheet sheet = wb1.createSheet();
                
                Row row0 = sheet.createRow(0);
                Cell cell0 = row0.createCell(0);
@@ -743,18 +759,12 @@ public abstract class BaseTestCell {
                Cell cell2 = row0.createCell(2);
                cell2.setCellValue("hgh_x0041_**_x0100_*_x0101_*_x0190_*_x0200_*_x0300_*_x0427_*");
 
-               checkUnicodeValues(wb);
-               
-//             String fname = "/tmp/Test_xNNNN_inCell" + (wb instanceof HSSFWorkbook ? ".xls" : ".xlsx");
-//             FileOutputStream out = new FileOutputStream(fname);
-//             try {
-//                     wb.write(out);
-//             } finally {
-//                     out.close();
-//             }
+               checkUnicodeValues(wb1);
                
-               Workbook wbBack = _testDataProvider.writeOutAndReadBack(wb);
-               checkUnicodeValues(wbBack);
+               Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+               checkUnicodeValues(wb2);
+               wb2.close();
+               wb1.close();
        }
 
        private void checkUnicodeValues(Workbook wb) {