src/testcases/org/apache/poi/hssf/usermodel/TestNamedRange.java

   1 /* ====================================================================
   2    Licensed to the Apache Software Foundation (ASF) under one or more
   3    contributor license agreements.  See the NOTICE file distributed with
   4    this work for additional information regarding copyright ownership.
   5    The ASF licenses this file to You under the Apache License, Version 2.0
   6    (the "License"); you may not use this file except in compliance with
   7    the License.  You may obtain a copy of the License at
   8
   9        http://www.apache.org/licenses/LICENSE-2.0
  10
  11    Unless required by applicable law or agreed to in writing, software
  12    distributed under the License is distributed on an "AS IS" BASIS,
  13    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14    See the License for the specific language governing permissions and
  15    limitations under the License.
  16 ==================================================================== */
  17
  18 package org.apache.poi.hssf.usermodel;
  19
  20 import java.io.ByteArrayInputStream;
  21 import java.io.ByteArrayOutputStream;
  22 import java.io.File;
  23 import java.io.FileOutputStream;
  24
  25 import junit.framework.TestCase;
  26
  27 import org.apache.poi.hssf.HSSFTestDataSamples;
  28 import org.apache.poi.hssf.util.AreaReference;
  29 import org.apache.poi.hssf.util.CellReference;
  30 import org.apache.poi.poifs.filesystem.POIFSFileSystem;
  31
  32 /**
  33  *
  34  * @author ROMANL
  35  * @author Andrew C. Oliver (acoliver at apache dot org)
  36  * @author Danny Mui (danny at muibros.com)
  37  * @author Amol S. Deshmukh &lt; amol at ap ache dot org &gt;
  38  */
  39 public final class TestNamedRange extends TestCase {
  40
  41         private static HSSFWorkbook openSample(String sampleFileName) {
  42                 return HSSFTestDataSamples.openSampleWorkbook(sampleFileName);
  43         }
  44
  45         public static void main(String[] args) {
  46                 junit.textui.TestRunner.run(TestNamedRange.class);
  47         }
  48
  49         /** Test of TestCase method, of class test.RangeTest. */
  50         public void testNamedRange() {
  51                 HSSFWorkbook wb = openSample("Simple.xls");
  52
  53                 //Creating new Named Range
  54                 HSSFName newNamedRange = wb.createName();
  55
  56                 //Getting Sheet Name for the reference
  57                 String sheetName = wb.getSheetName(0);
  58
  59                 //Setting its name
  60                 newNamedRange.setNameName("RangeTest");
  61                 //Setting its reference
  62                 newNamedRange.setReference(sheetName + "!$D$4:$E$8");
  63
  64                 //Getting NAmed Range
  65                 HSSFName namedRange1 = wb.getNameAt(0);
  66                 //Getting it sheet name
  67                 sheetName = namedRange1.getSheetName();
  68                 //Getting its reference
  69                 String referece = namedRange1.getReference();
  70
  71                 // sanity check
  72                 SanityChecker c = new SanityChecker();
  73                 c.checkHSSFWorkbook(wb);
  74
  75                 wb = HSSFTestDataSamples.writeOutAndReadBack(wb);
  76                 HSSFName nm =wb.getNameAt(wb.getNameIndex("RangeTest"));
  77                 assertTrue("Name is "+nm.getNameName(),"RangeTest".equals(nm.getNameName()));
  78                 assertEquals(wb.getSheetName(0)+"!$D$4:$E$8", nm.getReference());
  79         }
  80
  81         /**
  82          * Reads an excel file already containing a named range.
  83          * <p>
  84          * Addresses Bug <a href="http://issues.apache.org/bugzilla/show_bug.cgi?id=9632" target="_bug">#9632</a>
  85          */
  86         public void testNamedRead() {
  87                 HSSFWorkbook wb = openSample("namedinput.xls");
  88
  89                 //Get index of the namedrange with the name = "NamedRangeName" , which was defined in input.xls as A1:D10
  90                 int NamedRangeIndex      = wb.getNameIndex("NamedRangeName");
  91
  92                 //Getting NAmed Range
  93                 HSSFName namedRange1 = wb.getNameAt(NamedRangeIndex);
  94                 String sheetName = wb.getSheetName(0);
  95
  96                 //Getting its reference
  97                 String reference = namedRange1.getReference();
  98
  99                 assertEquals(sheetName+"!$A$1:$D$10", reference);
 100
 101                 HSSFName namedRange2 = wb.getNameAt(1);
 102
 103                 assertEquals(sheetName+"!$D$17:$G$27", namedRange2.getReference());
 104                 assertEquals("SecondNamedRange", namedRange2.getNameName());
 105         }
 106
 107         /**
 108          * Reads an excel file already containing a named range and updates it
 109          * <p>
 110          * Addresses Bug <a href="http://issues.apache.org/bugzilla/show_bug.cgi?id=16411" target="_bug">#16411</a>
 111          */
 112         public void testNamedReadModify() {
 113                 HSSFWorkbook wb = openSample("namedinput.xls");
 114
 115                 HSSFName name = wb.getNameAt(0);
 116                 String sheetName = wb.getSheetName(0);
 117
 118                 assertEquals(sheetName+"!$A$1:$D$10", name.getReference());
 119
 120                 name = wb.getNameAt(1);
 121                 String newReference = sheetName +"!$A$1:$C$36";
 122
 123                 name.setReference(newReference);
 124                 assertEquals(newReference, name.getReference());
 125         }
 126
 127         /**
 128          * Test that multiple named ranges can be added written and read
 129          */
 130         public void testMultipleNamedWrite() {
 131                 HSSFWorkbook wb  = new HSSFWorkbook();
 132
 133
 134                 wb.createSheet("testSheet1");
 135                 String sheetName = wb.getSheetName(0);
 136
 137                 assertEquals("testSheet1", sheetName);
 138
 139                 //Creating new Named Range
 140                 HSSFName newNamedRange = wb.createName();
 141
 142                 newNamedRange.setNameName("RangeTest");
 143                 newNamedRange.setReference(sheetName + "!$D$4:$E$8");
 144
 145                 //Creating another new Named Range
 146                 HSSFName newNamedRange2 = wb.createName();
 147
 148                 newNamedRange2.setNameName("AnotherTest");
 149                 newNamedRange2.setReference(sheetName + "!$F$1:$G$6");
 150
 151
 152                 HSSFName namedRange1 = wb.getNameAt(0);
 153                 String referece = namedRange1.getReference();
 154
 155                 wb = HSSFTestDataSamples.writeOutAndReadBack(wb);
 156                 HSSFName nm =wb.getNameAt(wb.getNameIndex("RangeTest"));
 157                 assertTrue("Name is "+nm.getNameName(),"RangeTest".equals(nm.getNameName()));
 158                 assertTrue("Reference is "+nm.getReference(),(wb.getSheetName(0)+"!$D$4:$E$8").equals(nm.getReference()));
 159
 160                 nm = wb.getNameAt(wb.getNameIndex("AnotherTest"));
 161                 assertTrue("Name is "+nm.getNameName(),"AnotherTest".equals(nm.getNameName()));
 162                 assertTrue("Reference is "+nm.getReference(),newNamedRange2.getReference().equals(nm.getReference()));
 163         }
 164
 165         /**
 166          * Test case provided by czhang@cambian.com (Chun Zhang)
 167          * <p>
 168          * Addresses Bug <a href="http://issues.apache.org/bugzilla/show_bug.cgi?id=13775" target="_bug">#13775</a>
 169          */
 170         public void testMultiNamedRange() {
 171
 172                  // Create a new workbook
 173                  HSSFWorkbook wb = new HSSFWorkbook ();
 174
 175
 176                  // Create a worksheet 'sheet1' in the new workbook
 177                  wb.createSheet ();
 178                  wb.setSheetName (0, "sheet1");
 179
 180                  // Create another worksheet 'sheet2' in the new workbook
 181                  wb.createSheet ();
 182                  wb.setSheetName (1, "sheet2");
 183
 184                  // Create a new named range for worksheet 'sheet1'
 185                  HSSFName namedRange1 = wb.createName();
 186
 187                  // Set the name for the named range for worksheet 'sheet1'
 188                  namedRange1.setNameName("RangeTest1");
 189
 190                  // Set the reference for the named range for worksheet 'sheet1'
 191                  namedRange1.setReference("sheet1" + "!$A$1:$L$41");
 192
 193                  // Create a new named range for worksheet 'sheet2'
 194                  HSSFName namedRange2 = wb.createName();
 195
 196                  // Set the name for the named range for worksheet 'sheet2'
 197                  namedRange2.setNameName("RangeTest2");
 198
 199                  // Set the reference for the named range for worksheet 'sheet2'
 200                  namedRange2.setReference("sheet2" + "!$A$1:$O$21");
 201
 202                  // Write the workbook to a file
 203                  // Read the Excel file and verify its content
 204                  wb = HSSFTestDataSamples.writeOutAndReadBack(wb);
 205                  HSSFName nm1 =wb.getNameAt(wb.getNameIndex("RangeTest1"));
 206                  assertTrue("Name is "+nm1.getNameName(),"RangeTest1".equals(nm1.getNameName()));
 207                  assertTrue("Reference is "+nm1.getReference(),(wb.getSheetName(0)+"!$A$1:$L$41").equals(nm1.getReference()));
 208
 209                  HSSFName nm2 =wb.getNameAt(wb.getNameIndex("RangeTest2"));
 210                  assertTrue("Name is "+nm2.getNameName(),"RangeTest2".equals(nm2.getNameName()));
 211                  assertTrue("Reference is "+nm2.getReference(),(wb.getSheetName(1)+"!$A$1:$O$21").equals(nm2.getReference()));
 212          }
 213
 214         public void testUnicodeNamedRange() {
 215                 HSSFWorkbook workBook = new HSSFWorkbook();
 216                 workBook.createSheet("Test");
 217                 HSSFName name = workBook.createName();
 218                 name.setNameName("\u03B1");
 219                 name.setReference("Test!$D$3:$E$8");
 220
 221
 222                 HSSFWorkbook workBook2 = HSSFTestDataSamples.writeOutAndReadBack(workBook);
 223                 HSSFName name2 = workBook2.getNameAt(0);
 224
 225                 assertEquals("\u03B1", name2.getNameName());
 226                 assertEquals("Test!$D$3:$E$8", name2.getReference());
 227         }
 228
 229          /**
 230           * Test to see if the print areas can be retrieved/created in memory
 231           */
 232          public void testSinglePrintArea()
 233          {
 234                  HSSFWorkbook workbook = new HSSFWorkbook();
 235                  HSSFSheet sheet = workbook.createSheet("Test Print Area");
 236                  String sheetName = workbook.getSheetName(0);
 237
 238                  String reference = sheetName+"!$A$1:$B$1";
 239                  workbook.setPrintArea(0, reference);
 240
 241                  String retrievedPrintArea = workbook.getPrintArea(0);
 242
 243                  assertNotNull("Print Area not defined for first sheet", retrievedPrintArea);
 244                  assertEquals("'" + sheetName + "'!$A$1:$B$1", retrievedPrintArea);
 245          }
 246
 247          /**
 248           * For Convenience, dont force sheet names to be used
 249           */
 250          public void testSinglePrintAreaWOSheet()
 251          {
 252                  HSSFWorkbook workbook = new HSSFWorkbook();
 253                  HSSFSheet sheet = workbook.createSheet("Test Print Area");
 254                  String sheetName = workbook.getSheetName(0);
 255
 256                  String reference = "$A$1:$B$1";
 257                  workbook.setPrintArea(0, reference);
 258
 259                  String retrievedPrintArea = workbook.getPrintArea(0);
 260
 261                  assertNotNull("Print Area not defined for first sheet", retrievedPrintArea);
 262                  assertEquals("'" + sheetName + "'!" + reference, retrievedPrintArea);
 263          }
 264
 265          /**
 266           * Test to see if the print area can be retrieved from an excel created file
 267           */
 268          public void testPrintAreaFileRead() {
 269                  HSSFWorkbook workbook = openSample("SimpleWithPrintArea.xls");
 270
 271                 String sheetName = workbook.getSheetName(0);
 272                 String reference = sheetName+"!$A$1:$C$5";
 273
 274                 assertEquals(reference, workbook.getPrintArea(0));
 275         }
 276
 277          /**
 278           * Test to see if the print area made it to the file
 279           */
 280          public void testPrintAreaFile() {
 281                 HSSFWorkbook workbook = new HSSFWorkbook();
 282                 workbook.createSheet("Test Print Area");
 283                 String sheetName = workbook.getSheetName(0);
 284
 285
 286                 String reference = sheetName+"!$A$1:$B$1";
 287                 workbook.setPrintArea(0, reference);
 288
 289                 workbook = HSSFTestDataSamples.writeOutAndReadBack(workbook);
 290
 291                 String retrievedPrintArea = workbook.getPrintArea(0);
 292                 assertNotNull("Print Area not defined for first sheet", retrievedPrintArea);
 293                 assertEquals("References Match", "'" + sheetName + "'!$A$1:$B$1", retrievedPrintArea);
 294         }
 295
 296         /**
 297          * Test to see if multiple print areas made it to the file
 298          */
 299         public void testMultiplePrintAreaFile() {
 300                 HSSFWorkbook workbook = new HSSFWorkbook();
 301
 302                 workbook.createSheet("Sheet1");
 303                 workbook.createSheet("Sheet2");
 304                 workbook.createSheet("Sheet3");
 305                 String reference1 = "Sheet1!$A$1:$B$1";
 306                 String reference2 = "Sheet2!$B$2:$D$5";
 307                 String reference3 = "Sheet3!$D$2:$F$5";
 308
 309                 workbook.setPrintArea(0, reference1);
 310                 workbook.setPrintArea(1, reference2);
 311                 workbook.setPrintArea(2, reference3);
 312
 313                 //Check created print areas
 314                 String retrievedPrintArea;
 315
 316                 retrievedPrintArea = workbook.getPrintArea(0);
 317                 assertNotNull("Print Area Not Found (Sheet 1)", retrievedPrintArea);
 318                 assertEquals(reference1, retrievedPrintArea);
 319
 320                 retrievedPrintArea = workbook.getPrintArea(1);
 321                 assertNotNull("Print Area Not Found (Sheet 2)", retrievedPrintArea);
 322                 assertEquals(reference2, retrievedPrintArea);
 323
 324                 retrievedPrintArea = workbook.getPrintArea(2);
 325                 assertNotNull("Print Area Not Found (Sheet 3)", retrievedPrintArea);
 326                 assertEquals(reference3, retrievedPrintArea);
 327
 328                 // Check print areas after re-reading workbook
 329                 workbook = HSSFTestDataSamples.writeOutAndReadBack(workbook);
 330
 331                 retrievedPrintArea = workbook.getPrintArea(0);
 332                 assertNotNull("Print Area Not Found (Sheet 1)", retrievedPrintArea);
 333                 assertEquals(reference1, retrievedPrintArea);
 334
 335                 retrievedPrintArea = workbook.getPrintArea(1);
 336                 assertNotNull("Print Area Not Found (Sheet 2)", retrievedPrintArea);
 337                 assertEquals(reference2, retrievedPrintArea);
 338
 339                 retrievedPrintArea = workbook.getPrintArea(2);
 340                 assertNotNull("Print Area Not Found (Sheet 3)", retrievedPrintArea);
 341                 assertEquals(reference3, retrievedPrintArea);
 342         }
 343
 344         /**
 345          * Tests the setting of print areas with coordinates (Row/Column designations)
 346          *
 347          */
 348         public void testPrintAreaCoords(){
 349                 HSSFWorkbook workbook = new HSSFWorkbook();
 350                 HSSFSheet sheet = workbook.createSheet("Test Print Area");
 351                 String sheetName = workbook.getSheetName(0);
 352
 353                 String reference = sheetName+"!$A$1:$B$1";
 354                 workbook.setPrintArea(0, 0, 1, 0, 0);
 355
 356                 String retrievedPrintArea = workbook.getPrintArea(0);
 357
 358                 assertNotNull("Print Area not defined for first sheet", retrievedPrintArea);
 359                 assertEquals("'" + sheetName + "'!$A$1:$B$1", retrievedPrintArea);
 360         }
 361
 362
 363         /**
 364          * Tests the parsing of union area expressions, and re-display in the presence of sheet names
 365          * with special characters.
 366          */
 367         public void testPrintAreaUnion(){
 368                 HSSFWorkbook workbook = new HSSFWorkbook();
 369                 HSSFSheet sheet = workbook.createSheet("Test Print Area");
 370                 String sheetName = workbook.getSheetName(0);
 371
 372
 373                 String reference =         sheetName +  "!$A$1:$B$1, " + sheetName + "!$D$1:$F$2";
 374                 String expResult = "'" + sheetName + "'!$A$1:$B$1,'" + sheetName + "'!$D$1:$F$2";
 375                 workbook.setPrintArea(0, reference);
 376
 377                 String retrievedPrintArea = workbook.getPrintArea(0);
 378
 379                 assertNotNull("Print Area not defined for first sheet", retrievedPrintArea);
 380                 assertEquals(expResult, retrievedPrintArea);
 381         }
 382
 383         /**
 384          * Verifies an existing print area is deleted
 385          *
 386          */
 387         public void testPrintAreaRemove() {
 388                 HSSFWorkbook workbook = new HSSFWorkbook();
 389                 HSSFSheet sheet = workbook.createSheet("Test Print Area");
 390                 String sheetName = workbook.getSheetName(0);
 391
 392                 String reference = sheetName+"!$A$1:$B$1";
 393                 workbook.setPrintArea(0, 0, 1, 0, 0);
 394
 395                 String retrievedPrintArea = workbook.getPrintArea(0);
 396
 397                 assertNotNull("Print Area not defined for first sheet", retrievedPrintArea);
 398
 399                 workbook.removePrintArea(0);
 400                 assertNull("PrintArea was not removed", workbook.getPrintArea(0));
 401         }
 402
 403         /**
 404          * Verifies correct functioning for "single cell named range" (aka "named cell")
 405          */
 406         public void testNamedCell_1() {
 407
 408                 // setup for this testcase
 409                 String sheetName = "Test Named Cell";
 410                 String cellName = "A name for a named cell";
 411                 String cellValue = "TEST Value";
 412                 HSSFWorkbook wb = new HSSFWorkbook();
 413                 HSSFSheet sheet = wb.createSheet(sheetName);
 414                 sheet.createRow(0).createCell((short) 0).setCellValue(cellValue);
 415
 416                 // create named range for a single cell using areareference
 417                 HSSFName namedCell = wb.createName();
 418                 namedCell.setNameName(cellName);
 419                 String reference = sheetName+"!A1:A1";
 420                 namedCell.setReference(reference);
 421
 422                 // retrieve the newly created named range
 423                 int namedCellIdx = wb.getNameIndex(cellName);
 424                 HSSFName aNamedCell = wb.getNameAt(namedCellIdx);
 425                 assertNotNull(aNamedCell);
 426
 427                 // retrieve the cell at the named range and test its contents
 428                 AreaReference aref = new AreaReference(aNamedCell.getReference());
 429                 assertTrue("Should be exactly 1 cell in the named cell :'" +cellName+"'", aref.isSingleCell());
 430
 431                 CellReference cref = aref.getFirstCell();
 432                 assertNotNull(cref);
 433                 HSSFSheet s = wb.getSheet(cref.getSheetName());
 434                 assertNotNull(s);
 435                 HSSFRow r = sheet.getRow(cref.getRow());
 436                 HSSFCell c = r.getCell(cref.getCol());
 437                 String contents = c.getRichStringCellValue().getString();
 438                 assertEquals("Contents of cell retrieved by its named reference", contents, cellValue);
 439         }
 440
 441         /**
 442          * Verifies correct functioning for "single cell named range" (aka "named cell")
 443          */
 444         public void testNamedCell_2() {
 445
 446                 // setup for this testcase
 447                 String sname = "TestSheet", cname = "TestName", cvalue = "TestVal";
 448                 HSSFWorkbook wb = new HSSFWorkbook();
 449                 HSSFSheet sheet = wb.createSheet(sname);
 450                 sheet.createRow(0).createCell((short) 0).setCellValue(cvalue);
 451
 452                 // create named range for a single cell using cellreference
 453                 HSSFName namedCell = wb.createName();
 454                 namedCell.setNameName(cname);
 455                 String reference = sname+"!A1";
 456                 namedCell.setReference(reference);
 457
 458                 // retrieve the newly created named range
 459                 int namedCellIdx = wb.getNameIndex(cname);
 460                 HSSFName aNamedCell = wb.getNameAt(namedCellIdx);
 461                 assertNotNull(aNamedCell);
 462
 463                 // retrieve the cell at the named range and test its contents
 464                 CellReference cref = new CellReference(aNamedCell.getReference());
 465                 assertNotNull(cref);
 466                 HSSFSheet s = wb.getSheet(cref.getSheetName());
 467                 HSSFRow r = sheet.getRow(cref.getRow());
 468                 HSSFCell c = r.getCell(cref.getCol());
 469                 String contents = c.getRichStringCellValue().getString();
 470                 assertEquals("Contents of cell retrieved by its named reference", contents, cvalue);
 471         }
 472
 473         public void testDeletedReference() throws Exception {
 474                 HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("24207.xls");
 475                 assertEquals(2, wb.getNumberOfNames());
 476
 477                 HSSFName name1 = wb.getNameAt(0);
 478                 assertEquals("a", name1.getNameName());
 479                 assertEquals("Sheet1!$A$1", name1.getReference());
 480                 AreaReference ref1 = new AreaReference(name1.getReference());
 481                 assertTrue("Successfully constructed first reference", true);
 482
 483                 HSSFName name2 = wb.getNameAt(1);
 484                 assertEquals("b", name2.getNameName());
 485                 assertEquals("#REF!", name2.getReference());
 486                 assertTrue(name2.isDeleted());
 487                 try {
 488                         AreaReference ref2 = new AreaReference(name2.getReference());
 489                         fail("attempt to supply an invalid reference to AreaReference constructor results in exception");
 490                 } catch (StringIndexOutOfBoundsException e) { // TODO - use a different exception for this condition
 491                         // expected during successful test
 492                 }
 493    }
 494
 495         public void testRepeatingRowsAndColumsNames() throws Exception {
 496                 HSSFWorkbook wb = new HSSFWorkbook();
 497                 HSSFSheet sheet = wb.createSheet();
 498
 499                 for (int rowItem = 0; rowItem < 10; rowItem++) {
 500                         HSSFRow r = sheet.createRow(rowItem);
 501                         for (int column = 0; column < 2; column++) {
 502                                 HSSFCell cellItem = r.createCell((short) column);
 503                                 cellItem.setCellType(HSSFCell.CELL_TYPE_STRING);
 504                                 cellItem.setCellValue(new HSSFRichTextString("Some value here"));
 505                                 if (rowItem == 2) {
 506                                         wb.setRepeatingRowsAndColumns(0, 0, 0, 0, 3 - 1);
 507                                         sheet.createFreezePane(0, 3);
 508                                 }
 509                         }
 510                 }
 511
 512                 assertEquals(2, wb.getNumberOfNames());
 513                 HSSFName nr1 = wb.getNameAt(0);
 514                 HSSFName nr2 = wb.getNameAt(1);
 515
 516                 assertEquals("Print_Titles", nr1.getNameName());
 517                 assertEquals("Sheet0!$A$1:$A$0,Sheet0!$A$1:$IV$3", nr1.getReference());
 518
 519                 assertEquals("Excel_Name_Record_Titles_1_1", nr2.getNameName());
 520                 assertEquals("Sheet0!$A$1:$A$0,Sheet0!$A$1:$IV$3", nr2.getReference());
 521
 522                 // Save and re-open
 523                 ByteArrayOutputStream baos = new ByteArrayOutputStream();
 524                 wb.write(baos);
 525                 ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
 526                 HSSFWorkbook nwb = new HSSFWorkbook(new POIFSFileSystem(bais));
 527
 528                 assertEquals(2, nwb.getNumberOfNames());
 529                 nr1 = nwb.getNameAt(0);
 530                 nr2 = nwb.getNameAt(1);
 531
 532                 // TODO -
 533                 //  should these references really have been corrected?
 534                 //  and if so, why not also above?
 535                 assertEquals("Print_Titles", nr1.getNameName());
 536                 assertEquals("Sheet0!A:A,Sheet0!$A$1:$IV$3", nr1.getReference());
 537
 538                 assertEquals("Excel_Name_Record_Titles_1_1", nr2.getNameName());
 539                 assertEquals("Sheet0!A:A,Sheet0!$A$1:$IV$3", nr2.getReference());
 540
 541                 // In case you fancy checking in excel, to ensure it
 542                 //  won't complain about the file now
 543                 FileOutputStream fout = new FileOutputStream(File.createTempFile("POI-45126-", ".xls"));
 544                 wb.write(fout);
 545                 fout.close();
 546         }
 547 }