Apache
/
poi
mirror of https://github.com/apache/poi.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

sonar fixes 

close resources in tests
fix gradle warnings

git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@1892683 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Andreas Beeker 2021-08-28 23:48:48 +00:00
parent 6d9b450ce3
commit f71cebcce5
50 changed files with 1617 additions and 1688 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
build.gradle
View File

@ -209,7 +209,7 @@ subprojects {
// make XML test-results available for Jenkins CI
useJUnitPlatform()
reports {
junitXml.enabled = true
junitXml.required = true
}
// Exclude some tests that are not actually tests or do not run cleanly on purpose
@ -238,7 +238,7 @@ subprojects {
"-Dversion.id=${project.version}",
'-ea',
'-Djunit.jupiter.execution.parallel.config.strategy=fixed',
'-Djunit.jupiter.execution.parallel.config.fixed.parallelism=3'
'-Djunit.jupiter.execution.parallel.config.fixed.parallelism=2'
// -Xjit:verbose={compileStart|compileEnd},vlog=build/jit.log${no.jit.sherlock} ... if ${isIBMVM}
]
@ -278,7 +278,7 @@ subprojects {
jacocoTestReport {
reports {
xml.enabled true
xml.required = true
}
}
@ -396,6 +396,7 @@ subprojects {
spotbugs {
ignoreFailures = true
showStackTraces = false
}
}
@ -536,7 +537,7 @@ task replaceVersion() {
task zipJavadocs(type: Zip, dependsOn: allJavaDoc) {
from('build/docs/javadoc/')
destinationDir = file('build/dist')
destinationDirectory = file('build/dist')
archiveBaseName = 'poi'
archiveVersion = subprojects[0].version
archiveAppendix = 'javadoc'

2
poi-examples/build.gradle
View File

@ -65,6 +65,8 @@ task cacheJava9(type: Copy) {
}
jar {
dependsOn cacheJava9
destinationDirectory = file("../build/dist/maven/${project.archivesBaseName}")
if (JavaVersion.current() == JavaVersion.VERSION_1_8) {

4
poi-excelant/build.gradle
View File

@ -105,6 +105,8 @@ task cacheTest9(type: Copy) {
}
jar {
dependsOn cacheJava9
destinationDirectory = file("../build/dist/maven/${project.archivesBaseName}")
if (JavaVersion.current() == JavaVersion.VERSION_1_8) {
@ -120,7 +122,7 @@ jar {
// Create a separate jar for test-code to depend on it in other projects
// See http://stackoverflow.com/questions/5144325/gradle-test-dependency
task testJar(type: Jar, dependsOn: testClasses) {
task testJar(type: Jar, dependsOn: [ testClasses, cacheTest9 ] ) {
destinationDirectory = file("../build/dist/maven/${project.archivesBaseName}-tests")
classifier 'tests'

2
poi-integration/build.gradle
View File

@ -96,7 +96,7 @@ jar {
// Create a separate jar for test-code to depend on it in other projects
// See http://stackoverflow.com/questions/5144325/gradle-test-dependency
task testJar(type: Jar, dependsOn: testClasses) {
task testJar(type: Jar, dependsOn: [ testClasses, cacheTest9 ] ) {
destinationDirectory = file("../build/dist/maven/${project.archivesBaseName}-tests")
classifier 'tests'

1
poi-integration/src/test/java/org/apache/poi/stress/BaseIntegrationTest.java
View File

@ -37,6 +37,7 @@ import org.apache.poi.poifs.filesystem.OfficeXmlFileException;
* types of files/exceptions, e.g. old file formats.
*
*/
@SuppressWarnings({"java:S2187", "unused"})
public class BaseIntegrationTest {
private final File rootDir;
private final String file;

12
poi-integration/src/test/java/org/apache/poi/stress/XSSFFileHandler.java
View File

@ -17,6 +17,8 @@
package org.apache.poi.stress;
import static org.apache.commons.io.output.NullOutputStream.NULL_OUTPUT_STREAM;
import static org.apache.poi.xssf.XSSFTestDataSamples.getSampleFile;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
@ -219,12 +221,14 @@ class XSSFFileHandler extends SpreadsheetHandler {
}
@Test
void testExtracting() throws Exception {
handleExtracting(new File("test-data/spreadsheet/ref-56737.xlsx"));
void testExtracting() {
File testFile = getSampleFile("ref-56737.xlsx");
assertDoesNotThrow(() -> handleExtracting(testFile));
}
@Test
void testAdditional() throws Exception {
handleAdditional(new File("test-data/spreadsheet/poc-xmlbomb.xlsx"));
void testAdditional() {
File testFile = getSampleFile("poc-xmlbomb.xlsx");
assertDoesNotThrow(() -> handleAdditional(testFile));
}
}

2
poi-ooxml-lite/build.gradle
View File

@ -141,3 +141,5 @@ jar {
}
}
spotbugsTest.enabled = false
spotbugsMain.enabled = false

16
poi-ooxml/src/main/java/org/apache/poi/poifs/crypt/dsig/DigestOutputStream.java
View File

@ -66,13 +66,14 @@ import org.ietf.jgss.Oid;
}
public byte[] sign() throws IOException, GeneralSecurityException {
UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream();
bos.write(getHashMagic());
bos.write(md.digest());
try (UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream()) {
bos.write(getHashMagic());
bos.write(md.digest());
final Cipher cipher = CryptoFunctions.getCipher(key, CipherAlgorithm.rsa
, ChainingMode.ecb, null, Cipher.ENCRYPT_MODE, "PKCS1Padding");
return cipher.doFinal(bos.toByteArray());
final Cipher cipher = CryptoFunctions.getCipher(key, CipherAlgorithm.rsa
, ChainingMode.ecb, null, Cipher.ENCRYPT_MODE, "PKCS1Padding");
return cipher.doFinal(bos.toByteArray());
}
}
static boolean isMSCapi(final PrivateKey key) {
@ -91,10 +92,9 @@ import org.ietf.jgss.Oid;
// in an earlier release the hashMagic (aka DigestAlgorithmIdentifier) contained only
// an object identifier, but to conform with the header generated by the
// javax-signature API, the empty <associated parameters> are also included
try {
try (UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream()) {
final byte[] oidBytes = new Oid(algo.rsaOid).getDER();
final UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream();
bos.write(0x30);
bos.write(algo.hashSize+oidBytes.length+6);
bos.write(0x30);

11
poi-ooxml/src/main/java/org/apache/poi/poifs/crypt/dsig/OOXMLURIDereferencer.java
View File

@ -90,12 +90,13 @@ public class OOXMLURIDereferencer implements URIDereferencer {
// although xmlsec has an option to ignore line breaks, currently this
// only affects .rels files, so we only modify these
// http://stackoverflow.com/questions/4728300
UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream();
for (int ch; (ch = dataStream.read()) != -1; ) {
if (ch == 10 || ch == 13) continue;
bos.write(ch);
try (UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream()) {
for (int ch; (ch = dataStream.read()) != -1; ) {
if (ch == 10 || ch == 13) continue;
bos.write(ch);
}
dataStream = bos.toInputStream();
}
dataStream = bos.toInputStream();
}
} catch (IOException e) {
throw new URIReferenceException("I/O error: " + e.getMessage(), e);

5
poi-ooxml/src/main/java/org/apache/poi/poifs/crypt/dsig/facets/XAdESXLSignatureFacet.java
View File

@ -289,8 +289,7 @@ public class XAdESXLSignatureFacet implements SignatureFacet {
}
public static byte[] getC14nValue(List<Node> nodeList, String c14nAlgoId) {
UnsynchronizedByteArrayOutputStream c14nValue = new UnsynchronizedByteArrayOutputStream();
try {
try (UnsynchronizedByteArrayOutputStream c14nValue = new UnsynchronizedByteArrayOutputStream()) {
for (Node node : nodeList) {
/*
* Re-initialize the c14n else the namespaces will get cached
@ -299,12 +298,12 @@ public class XAdESXLSignatureFacet implements SignatureFacet {
Canonicalizer c14n = Canonicalizer.getInstance(c14nAlgoId);
c14n.canonicalizeSubtree(node, c14nValue);
}
return c14nValue.toByteArray();
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException("c14n error: " + e.getMessage(), e);
}
return c14nValue.toByteArray();
}
private BigInteger getCrlNumber(X509CRL crl) {

12
poi-ooxml/src/main/java/org/apache/poi/xssf/usermodel/XSSFConditionalFormattingThreshold.java
View File

@ -27,34 +27,39 @@ import org.openxmlformats.schemas.spreadsheetml.x2006.main.STCfvoType;
* Colour Scale change thresholds
*/
public class XSSFConditionalFormattingThreshold implements org.apache.poi.ss.usermodel.ConditionalFormattingThreshold {
private CTCfvo cfvo;
private final CTCfvo cfvo;
protected XSSFConditionalFormattingThreshold(CTCfvo cfvo) {
this.cfvo = cfvo;
}
protected CTCfvo getCTCfvo() {
return cfvo;
}
@Override
public RangeType getRangeType() {
return RangeType.byName(cfvo.getType().toString());
}
@Override
public void setRangeType(RangeType type) {
STCfvoType.Enum xtype = STCfvoType.Enum.forString(type.name);
cfvo.setType(xtype);
}
@Override
public String getFormula() {
if (cfvo.getType() == STCfvoType.FORMULA) {
return cfvo.getVal();
}
return null;
}
@Override
public void setFormula(String formula) {
cfvo.setVal(formula);
}
@Override
public Double getValue() {
if (cfvo.getType() == STCfvoType.FORMULA ||
cfvo.getType() == STCfvoType.MIN ||
@ -67,6 +72,7 @@ public class XSSFConditionalFormattingThreshold implements org.apache.poi.ss.use
return null;
}
}
@Override
public void setValue(Double value) {
if (value == null) {
cfvo.unsetVal();

13
poi-ooxml/src/main/java/org/apache/poi/xssf/usermodel/XSSFIconMultiStateFormatting.java
View File

@ -25,7 +25,7 @@ import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTIconSet;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STIconSetType;
/**
* High level representation for Icon / Multi-State Formatting
* High level representation for Icon / Multi-State Formatting
* component of Conditional Formatting settings
*/
public class XSSFIconMultiStateFormatting implements IconMultiStateFormatting {
@ -35,42 +35,50 @@ public class XSSFIconMultiStateFormatting implements IconMultiStateFormatting {
_iconset = iconset;
}
@Override
public IconSet getIconSet() {
String set = _iconset.getIconSet().toString();
return IconSet.byName(set);
}
@Override
public void setIconSet(IconSet set) {
STIconSetType.Enum xIconSet = STIconSetType.Enum.forString(set.name);
_iconset.setIconSet(xIconSet);
}
@Override
public boolean isIconOnly() {
if (_iconset.isSetShowValue())
return !_iconset.getShowValue();
return false;
}
@Override
public void setIconOnly(boolean only) {
_iconset.setShowValue(!only);
}
@Override
public boolean isReversed() {
if (_iconset.isSetReverse())
return _iconset.getReverse();
return false;
}
@Override
public void setReversed(boolean reversed) {
_iconset.setReverse(reversed);
}
@Override
public XSSFConditionalFormattingThreshold[] getThresholds() {
CTCfvo[] cfvos = _iconset.getCfvoArray();
XSSFConditionalFormattingThreshold[] t =
XSSFConditionalFormattingThreshold[] t =
new XSSFConditionalFormattingThreshold[cfvos.length];
for (int i=0; i<cfvos.length; i++) {
t[i] = new XSSFConditionalFormattingThreshold(cfvos[i]);
}
return t;
}
@Override
public void setThresholds(ConditionalFormattingThreshold[] thresholds) {
CTCfvo[] cfvos = new CTCfvo[thresholds.length];
for (int i=0; i<thresholds.length; i++) {
@ -78,6 +86,7 @@ public class XSSFIconMultiStateFormatting implements IconMultiStateFormatting {
}
_iconset.setCfvoArray(cfvos);
}
@Override
public XSSFConditionalFormattingThreshold createThreshold() {
return new XSSFConditionalFormattingThreshold(_iconset.addNewCfvo());
}

1
poi-ooxml/src/main/java/org/apache/poi/xssf/usermodel/XSSFWorkbookFactory.java
View File

@ -139,6 +139,7 @@ public class XSSFWorkbookFactory implements WorkbookProvider {
* @throws IOException if an error occurs while reading the data
* @throws EncryptedDocumentException If the wrong password is given for a protected file
*/
@Override
@SuppressWarnings("resource")
public XSSFWorkbook create(File file, String password, boolean readOnly) throws IOException {
FileMagic fm = FileMagic.valueOf(file);

7
poi-ooxml/src/test/java/org/apache/poi/xssf/extractor/TestXSSFExportToXML.java
View File

@ -45,7 +45,6 @@ import org.apache.poi.xssf.XSSFTestDataSamples;
import org.apache.poi.xssf.model.MapInfo;
import org.apache.poi.xssf.usermodel.XSSFMap;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
@ -216,15 +215,13 @@ public final class TestXSSFExportToXML {
}
@Test
@Disabled(value="Fails, but I don't know if it is ok or not...")
void testExportToXMLSingleAttributeNamespace() throws Exception {
try (XSSFWorkbook wb = XSSFTestDataSamples.openSampleWorkbook("CustomXMLMapping-singleattributenamespace.xlsx")) {
for (XSSFMap map : wb.getCustomXMLMappings()) {
XSSFExportToXml exporter = new XSSFExportToXml(map);
UnsynchronizedByteArrayOutputStream os = new UnsynchronizedByteArrayOutputStream();
exporter.exportToXML(os, true);
SAXParseException ex = assertThrows(SAXParseException.class, () -> exporter.exportToXML(os, true));
assertEquals("schema_reference: Failed to read schema document 'Schema11', because 'file' access is not allowed due to restriction set by the accessExternalSchema property.", ex.getMessage().trim());
}
}
}

276
poi-ooxml/src/test/java/org/apache/poi/xssf/streaming/TestDeferredSXSSFWorkbook.java
View File

@ -41,6 +41,8 @@ import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
public final class TestDeferredSXSSFWorkbook extends BaseTestXWorkbook {
@ -90,112 +92,109 @@ public final class TestDeferredSXSSFWorkbook extends BaseTestXWorkbook {
@Test
void existingWorkbook() throws IOException {
XSSFWorkbook xssfWb1 = new XSSFWorkbook();
xssfWb1.createSheet("S1");
DeferredSXSSFWorkbook wb1 = new DeferredSXSSFWorkbook(xssfWb1);
XSSFWorkbook xssfWb2 = DeferredSXSSFITestDataProvider.instance.writeOutAndReadBack(wb1);
assertTrue(wb1.dispose());
try (XSSFWorkbook xssfWb1 = new XSSFWorkbook()) {
xssfWb1.createSheet("S1");
try (DeferredSXSSFWorkbook wb1 = new DeferredSXSSFWorkbook(xssfWb1);
XSSFWorkbook xssfWb2 = DeferredSXSSFITestDataProvider.instance.writeOutAndReadBack(wb1)) {
assertTrue(wb1.dispose());
DeferredSXSSFWorkbook wb2 = new DeferredSXSSFWorkbook(xssfWb2);
assertEquals(1, wb2.getNumberOfSheets());
Sheet sheet = wb2.getStreamingSheetAt(0);
assertNotNull(sheet);
assertEquals("S1", sheet.getSheetName());
assertTrue(wb2.dispose());
xssfWb2.close();
xssfWb1.close();
wb2.close();
wb1.close();
try (DeferredSXSSFWorkbook wb2 = new DeferredSXSSFWorkbook(xssfWb2)) {
assertEquals(1, wb2.getNumberOfSheets());
Sheet sheet = wb2.getStreamingSheetAt(0);
assertNotNull(sheet);
assertEquals("S1", sheet.getSheetName());
assertTrue(wb2.dispose());
}
}
}
}
@Test
void addToExistingWorkbook() throws IOException {
XSSFWorkbook xssfWb1 = new XSSFWorkbook();
xssfWb1.createSheet("S1");
Sheet sheet = xssfWb1.createSheet("S2");
Row row = sheet.createRow(1);
Cell cell = row.createCell(1);
cell.setCellValue("value 2_1_1");
DeferredSXSSFWorkbook wb1 = new DeferredSXSSFWorkbook(xssfWb1);
XSSFWorkbook xssfWb2 = DeferredSXSSFITestDataProvider.instance.writeOutAndReadBack(wb1);
assertTrue(wb1.dispose());
xssfWb1.close();
try (XSSFWorkbook xssfWb1 = new XSSFWorkbook()) {
xssfWb1.createSheet("S1");
Sheet sheet = xssfWb1.createSheet("S2");
Row row = sheet.createRow(1);
Cell cell = row.createCell(1);
cell.setCellValue("value 2_1_1");
DeferredSXSSFWorkbook wb2 = new DeferredSXSSFWorkbook(xssfWb2);
// Add a row to the existing empty sheet
DeferredSXSSFSheet ssheet1 = wb2.getStreamingSheetAt(0);
ssheet1.setRowGenerator((ssxSheet) -> {
Row row1_1 = ssxSheet.createRow(1);
Cell cell1_1_1 = row1_1.createCell(1);
cell1_1_1.setCellValue("value 1_1_1");
});
try (DeferredSXSSFWorkbook wb1 = new DeferredSXSSFWorkbook(xssfWb1);
XSSFWorkbook xssfWb2 = DeferredSXSSFITestDataProvider.instance.writeOutAndReadBack(wb1)) {
assertTrue(wb1.dispose());
// Add a row to the existing non-empty sheet
DeferredSXSSFSheet ssheet2 = wb2.getStreamingSheetAt(1);
ssheet2.setRowGenerator((ssxSheet) -> {
Row row2_2 = ssxSheet.createRow(2);
Cell cell2_2_1 = row2_2.createCell(1);
cell2_2_1.setCellValue("value 2_2_1");
});
// Add a sheet with one row
DeferredSXSSFSheet ssheet3 = wb2.createSheet("S3");
ssheet3.setRowGenerator((ssxSheet) -> {
Row row3_1 = ssxSheet.createRow(1);
Cell cell3_1_1 = row3_1.createCell(1);
cell3_1_1.setCellValue("value 3_1_1");
});
try (DeferredSXSSFWorkbook wb2 = new DeferredSXSSFWorkbook(xssfWb2)) {
// Add a row to the existing empty sheet
DeferredSXSSFSheet ssheet1 = wb2.getStreamingSheetAt(0);
ssheet1.setRowGenerator((ssxSheet) -> {
Row row1_1 = ssxSheet.createRow(1);
Cell cell1_1_1 = row1_1.createCell(1);
cell1_1_1.setCellValue("value 1_1_1");
});
XSSFWorkbook xssfWb3 = DeferredSXSSFITestDataProvider.instance.writeOutAndReadBack(wb2);
wb2.close();
// Add a row to the existing non-empty sheet
DeferredSXSSFSheet ssheet2 = wb2.getStreamingSheetAt(1);
ssheet2.setRowGenerator((ssxSheet) -> {
Row row2_2 = ssxSheet.createRow(2);
Cell cell2_2_1 = row2_2.createCell(1);
cell2_2_1.setCellValue("value 2_2_1");
});
// Add a sheet with one row
DeferredSXSSFSheet ssheet3 = wb2.createSheet("S3");
ssheet3.setRowGenerator((ssxSheet) -> {
Row row3_1 = ssxSheet.createRow(1);
Cell cell3_1_1 = row3_1.createCell(1);
cell3_1_1.setCellValue("value 3_1_1");
});
assertEquals(3, xssfWb3.getNumberOfSheets());
// Verify sheet 1
XSSFSheet sheet1 = xssfWb3.getSheetAt(0);
assertEquals("S1", sheet1.getSheetName());
assertEquals(1, sheet1.getPhysicalNumberOfRows());
XSSFRow row1_1 = sheet1.getRow(1);
assertNotNull(row1_1);
XSSFCell cell1_1_1 = row1_1.getCell(1);
assertNotNull(cell1_1_1);
assertEquals("value 1_1_1", cell1_1_1.getStringCellValue());
// Verify sheet 2
XSSFSheet sheet2 = xssfWb3.getSheetAt(1);
assertEquals("S2", sheet2.getSheetName());
assertEquals(2, sheet2.getPhysicalNumberOfRows());
Row row2_1 = sheet2.getRow(1);
assertNotNull(row2_1);
Cell cell2_1_1 = row2_1.getCell(1);
assertNotNull(cell2_1_1);
assertEquals("value 2_1_1", cell2_1_1.getStringCellValue());
XSSFRow row2_2 = sheet2.getRow(2);
assertNotNull(row2_2);
XSSFCell cell2_2_1 = row2_2.getCell(1);
assertNotNull(cell2_2_1);
assertEquals("value 2_2_1", cell2_2_1.getStringCellValue());
// Verify sheet 3
XSSFSheet sheet3 = xssfWb3.getSheetAt(2);
assertEquals("S3", sheet3.getSheetName());
assertEquals(1, sheet3.getPhysicalNumberOfRows());
XSSFRow row3_1 = sheet3.getRow(1);
assertNotNull(row3_1);
XSSFCell cell3_1_1 = row3_1.getCell(1);
assertNotNull(cell3_1_1);
assertEquals("value 3_1_1", cell3_1_1.getStringCellValue());
try (XSSFWorkbook xssfWb3 = DeferredSXSSFITestDataProvider.instance.writeOutAndReadBack(wb2)) {
xssfWb2.close();
xssfWb3.close();
wb1.close();
assertEquals(3, xssfWb3.getNumberOfSheets());
// Verify sheet 1
XSSFSheet sheet1 = xssfWb3.getSheetAt(0);
assertEquals("S1", sheet1.getSheetName());
assertEquals(1, sheet1.getPhysicalNumberOfRows());
XSSFRow row1_1 = sheet1.getRow(1);
assertNotNull(row1_1);
XSSFCell cell1_1_1 = row1_1.getCell(1);
assertNotNull(cell1_1_1);
assertEquals("value 1_1_1", cell1_1_1.getStringCellValue());
// Verify sheet 2
XSSFSheet sheet2 = xssfWb3.getSheetAt(1);
assertEquals("S2", sheet2.getSheetName());
assertEquals(2, sheet2.getPhysicalNumberOfRows());
Row row2_1 = sheet2.getRow(1);
assertNotNull(row2_1);
Cell cell2_1_1 = row2_1.getCell(1);
assertNotNull(cell2_1_1);
assertEquals("value 2_1_1", cell2_1_1.getStringCellValue());
XSSFRow row2_2 = sheet2.getRow(2);
assertNotNull(row2_2);
XSSFCell cell2_2_1 = row2_2.getCell(1);
assertNotNull(cell2_2_1);
assertEquals("value 2_2_1", cell2_2_1.getStringCellValue());
// Verify sheet 3
XSSFSheet sheet3 = xssfWb3.getSheetAt(2);
assertEquals("S3", sheet3.getSheetName());
assertEquals(1, sheet3.getPhysicalNumberOfRows());
XSSFRow row3_1 = sheet3.getRow(1);
assertNotNull(row3_1);
XSSFCell cell3_1_1 = row3_1.getCell(1);
assertNotNull(cell3_1_1);
assertEquals("value 3_1_1", cell3_1_1.getStringCellValue());
}
}
}
}
}
@Test
void sheetdataWriter() throws IOException {
DeferredSXSSFWorkbook wb = new DeferredSXSSFWorkbook();
SXSSFSheet sh = wb.createSheet();
assertSame(sh.getClass(), DeferredSXSSFSheet.class);
SheetDataWriter wr = sh.getSheetDataWriter();
assertNull(wr);
wb.close();
try (DeferredSXSSFWorkbook wb = new DeferredSXSSFWorkbook()) {
SXSSFSheet sh = wb.createSheet();
assertSame(sh.getClass(), DeferredSXSSFSheet.class);
SheetDataWriter wr = sh.getSheetDataWriter();
assertNull(wr);
}
}
@Test
@ -225,71 +224,65 @@ public final class TestDeferredSXSSFWorkbook extends BaseTestXWorkbook {
@Test
void gzipSheetdataWriter() throws IOException {
DeferredSXSSFWorkbook wb = new DeferredSXSSFWorkbook();
try (DeferredSXSSFWorkbook wb = new DeferredSXSSFWorkbook()) {
final int rowNum = 1000;
final int sheetNum = 5;
populateData(wb, 1000, 5);
final int rowNum = 1000;
final int sheetNum = 5;
populateData(wb);
XSSFWorkbook xwb = DeferredSXSSFITestDataProvider.instance.writeOutAndReadBack(wb);
for (int i = 0; i < sheetNum; i++) {
Sheet sh = xwb.getSheetAt(i);
assertEquals("sheet" + i, sh.getSheetName());
for (int j = 0; j < rowNum; j++) {
Row row = sh.getRow(j);
assertNotNull(row, "row[" + j + "]");
Cell cell1 = row.getCell(0);
assertEquals(new CellReference(cell1).formatAsString(), cell1.getStringCellValue());
try (XSSFWorkbook xwb = DeferredSXSSFITestDataProvider.instance.writeOutAndReadBack(wb)) {
for (int i = 0; i < sheetNum; i++) {
Sheet sh = xwb.getSheetAt(i);
assertEquals("sheet" + i, sh.getSheetName());
for (int j = 0; j < rowNum; j++) {
Row row = sh.getRow(j);
assertNotNull(row, "row[" + j + "]");
Cell cell1 = row.getCell(0);
assertEquals(new CellReference(cell1).formatAsString(), cell1.getStringCellValue());
Cell cell2 = row.getCell(1);
assertEquals(i, (int) cell2.getNumericCellValue());
Cell cell2 = row.getCell(1);
assertEquals(i, (int) cell2.getNumericCellValue());
Cell cell3 = row.getCell(2);
assertEquals(j, (int) cell3.getNumericCellValue());
Cell cell3 = row.getCell(2);
assertEquals(j, (int) cell3.getNumericCellValue());
}
}
assertTrue(wb.dispose());
}
}
assertTrue(wb.dispose());
xwb.close();
wb.close();
}
@Test
void workbookDispose() throws IOException {
DeferredSXSSFWorkbook wb1 = new DeferredSXSSFWorkbook();
// the underlying writer is SheetDataWriter
assertWorkbookDispose(wb1);
wb1.close();
@ParameterizedTest
@ValueSource(booleans = {false, true})
void workbookDispose(boolean compressTempFiles) throws IOException {
try (DeferredSXSSFWorkbook wb = new DeferredSXSSFWorkbook()) {
// compressTempFiles == false: the underlying writer is SheetDataWriter
// compressTempFiles == true: the underlying writer is GZIPSheetDataWriter
wb.setCompressTempFiles(compressTempFiles);
DeferredSXSSFWorkbook wb2 = new DeferredSXSSFWorkbook();
wb2.setCompressTempFiles(true);
// the underlying writer is GZIPSheetDataWriter
assertWorkbookDispose(wb2);
wb2.close();
}
populateData(wb);
private static void assertWorkbookDispose(DeferredSXSSFWorkbook wb) {
populateData(wb, 1000, 5);
for (Sheet sheet : wb) {
DeferredSXSSFSheet sxSheet = (DeferredSXSSFSheet) sheet;
assertNull(sxSheet.getSheetDataWriter());
}
for (Sheet sheet : wb) {
DeferredSXSSFSheet sxSheet = (DeferredSXSSFSheet) sheet;
assertNull(sxSheet.getSheetDataWriter());
}
assertTrue(wb.dispose());
assertTrue(wb.dispose());
for (Sheet sheet : wb) {
DeferredSXSSFSheet sxSheet = (DeferredSXSSFSheet) sheet;
assertNull(sxSheet.getSheetDataWriter());
for (Sheet sheet : wb) {
DeferredSXSSFSheet sxSheet = (DeferredSXSSFSheet) sheet;
assertNull(sxSheet.getSheetDataWriter());
}
}
}
private static void populateData(DeferredSXSSFWorkbook wb, final int rowNum, final int sheetNum) {
for (int i = 0; i < sheetNum; i++) {
private static void populateData(DeferredSXSSFWorkbook wb) {
for (int i = 0; i < 5; i++) {
DeferredSXSSFSheet sheet = wb.createSheet("sheet" + i);
int index = i;
sheet.setRowGenerator((sh) -> {
for (int j = 0; j < rowNum; j++) {
for (int j = 0; j < 1000; j++) {
Row row = sh.createRow(j);
Cell cell1 = row.createCell(0);
cell1.setCellValue(new CellReference(cell1).formatAsString());
@ -304,7 +297,8 @@ public final class TestDeferredSXSSFWorkbook extends BaseTestXWorkbook {
}
}
void changeSheetNameWithSharedFormulas() {
/* not implemented */
@Override
@Disabled("not implemented")
protected void changeSheetNameWithSharedFormulas() {
}
}

396
poi-ooxml/src/test/java/org/apache/poi/xssf/streaming/TestSXSSFWorkbook.java
View File

@ -55,6 +55,8 @@ import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
public final class TestSXSSFWorkbook extends BaseTestXWorkbook {
@ -98,225 +100,201 @@ public final class TestSXSSFWorkbook extends BaseTestXWorkbook {
@Test
void existingWorkbook() throws IOException {
XSSFWorkbook xssfWb1 = new XSSFWorkbook();
xssfWb1.createSheet("S1");
SXSSFWorkbook wb1 = new SXSSFWorkbook(xssfWb1);
XSSFWorkbook xssfWb2 = SXSSFITestDataProvider.instance.writeOutAndReadBack(wb1);
assertTrue(wb1.dispose());
try (XSSFWorkbook xssfWb1 = new XSSFWorkbook()) {
xssfWb1.createSheet("S1");
try (SXSSFWorkbook wb1 = new SXSSFWorkbook(xssfWb1);
XSSFWorkbook xssfWb2 = SXSSFITestDataProvider.instance.writeOutAndReadBack(wb1)) {
assertTrue(wb1.dispose());
SXSSFWorkbook wb2 = new SXSSFWorkbook(xssfWb2);
assertEquals(1, wb2.getNumberOfSheets());
Sheet sheet = wb2.getSheetAt(0);
assertNotNull(sheet);
assertEquals("S1", sheet.getSheetName());
assertTrue(wb2.dispose());
xssfWb2.close();
xssfWb1.close();
wb2.close();
wb1.close();
try (SXSSFWorkbook wb2 = new SXSSFWorkbook(xssfWb2)) {
assertEquals(1, wb2.getNumberOfSheets());
Sheet sheet = wb2.getSheetAt(0);
assertNotNull(sheet);
assertEquals("S1", sheet.getSheetName());
assertTrue(wb2.dispose());
}
}
}
}
@Test
void useSharedStringsTable() throws Exception {
SXSSFWorkbook wb = new SXSSFWorkbook(null, 10, false, true);
try (SXSSFWorkbook wb = new SXSSFWorkbook(null, 10, false, true)) {
SharedStringsTable sss = wb.getSharedStringSource();
SharedStringsTable sss = wb.getSharedStringSource();
assertNotNull(sss);
assertNotNull(sss);
Row row = wb.createSheet("S1").createRow(0);
Row row = wb.createSheet("S1").createRow(0);
row.createCell(0).setCellValue("A");
row.createCell(1).setCellValue("B");
row.createCell(2).setCellValue("A");
row.createCell(0).setCellValue("A");
row.createCell(1).setCellValue("B");
row.createCell(2).setCellValue("A");
XSSFWorkbook xssfWorkbook = SXSSFITestDataProvider.instance.writeOutAndReadBack(wb);
sss = wb.getSharedStringSource();
assertEquals(2, sss.getUniqueCount());
assertTrue(wb.dispose());
try (XSSFWorkbook xssfWorkbook = SXSSFITestDataProvider.instance.writeOutAndReadBack(wb)) {
sss = wb.getSharedStringSource();
assertEquals(2, sss.getUniqueCount());
assertTrue(wb.dispose());
Sheet sheet1 = xssfWorkbook.getSheetAt(0);
assertEquals("S1", sheet1.getSheetName());
assertEquals(1, sheet1.getPhysicalNumberOfRows());
row = sheet1.getRow(0);
assertNotNull(row);
Cell cell = row.getCell(0);
assertNotNull(cell);
assertEquals("A", cell.getStringCellValue());
cell = row.getCell(1);
assertNotNull(cell);
assertEquals("B", cell.getStringCellValue());
cell = row.getCell(2);
assertNotNull(cell);
assertEquals("A", cell.getStringCellValue());
xssfWorkbook.close();
wb.close();
Sheet sheet1 = xssfWorkbook.getSheetAt(0);
assertEquals("S1", sheet1.getSheetName());
assertEquals(1, sheet1.getPhysicalNumberOfRows());
row = sheet1.getRow(0);
assertNotNull(row);
Cell cell = row.getCell(0);
assertNotNull(cell);
assertEquals("A", cell.getStringCellValue());
cell = row.getCell(1);
assertNotNull(cell);
assertEquals("B", cell.getStringCellValue());
cell = row.getCell(2);
assertNotNull(cell);
assertEquals("A", cell.getStringCellValue());
}
}
}
@Test
void addToExistingWorkbook() throws IOException {
XSSFWorkbook xssfWb1 = new XSSFWorkbook();
xssfWb1.createSheet("S1");
Sheet sheet = xssfWb1.createSheet("S2");
Row row = sheet.createRow(1);
Cell cell = row.createCell(1);
cell.setCellValue("value 2_1_1");
SXSSFWorkbook wb1 = new SXSSFWorkbook(xssfWb1);
XSSFWorkbook xssfWb2 = SXSSFITestDataProvider.instance.writeOutAndReadBack(wb1);
assertTrue(wb1.dispose());
xssfWb1.close();
try (XSSFWorkbook xssfWb1 = new XSSFWorkbook()) {
xssfWb1.createSheet("S1");
Sheet sheet = xssfWb1.createSheet("S2");
Row row = sheet.createRow(1);
Cell cell = row.createCell(1);
cell.setCellValue("value 2_1_1");
try (SXSSFWorkbook wb1 = new SXSSFWorkbook(xssfWb1);
XSSFWorkbook xssfWb2 = SXSSFITestDataProvider.instance.writeOutAndReadBack(wb1)) {
assertTrue(wb1.dispose());
SXSSFWorkbook wb2 = new SXSSFWorkbook(xssfWb2);
// Add a row to the existing empty sheet
Sheet sheet1 = wb2.getSheetAt(0);
Row row1_1 = sheet1.createRow(1);
Cell cell1_1_1 = row1_1.createCell(1);
cell1_1_1.setCellValue("value 1_1_1");
try (SXSSFWorkbook wb2 = new SXSSFWorkbook(xssfWb2)) {
// Add a row to the existing empty sheet
Sheet sheet1 = wb2.getSheetAt(0);
Row row1_1 = sheet1.createRow(1);
Cell cell1_1_1 = row1_1.createCell(1);
cell1_1_1.setCellValue("value 1_1_1");
// Add a row to the existing non-empty sheet
Sheet sheet2 = wb2.getSheetAt(1);
Row row2_2 = sheet2.createRow(2);
Cell cell2_2_1 = row2_2.createCell(1);
cell2_2_1.setCellValue("value 2_2_1");
// Add a row to the existing non-empty sheet
Sheet sheet2 = wb2.getSheetAt(1);
Row row2_2 = sheet2.createRow(2);
Cell cell2_2_1 = row2_2.createCell(1);
cell2_2_1.setCellValue("value 2_2_1");
// Add a sheet with one row
Sheet sheet3 = wb2.createSheet("S3");
Row row3_1 = sheet3.createRow(1);
Cell cell3_1_1 = row3_1.createCell(1);
cell3_1_1.setCellValue("value 3_1_1");
// Add a sheet with one row
Sheet sheet3 = wb2.createSheet("S3");
Row row3_1 = sheet3.createRow(1);
Cell cell3_1_1 = row3_1.createCell(1);
cell3_1_1.setCellValue("value 3_1_1");
XSSFWorkbook xssfWb3 = SXSSFITestDataProvider.instance.writeOutAndReadBack(wb2);
wb2.close();
assertEquals(3, xssfWb3.getNumberOfSheets());
// Verify sheet 1
sheet1 = xssfWb3.getSheetAt(0);
assertEquals("S1", sheet1.getSheetName());
assertEquals(1, sheet1.getPhysicalNumberOfRows());
row1_1 = sheet1.getRow(1);
assertNotNull(row1_1);
cell1_1_1 = row1_1.getCell(1);
assertNotNull(cell1_1_1);
assertEquals("value 1_1_1", cell1_1_1.getStringCellValue());
// Verify sheet 2
sheet2 = xssfWb3.getSheetAt(1);
assertEquals("S2", sheet2.getSheetName());
assertEquals(2, sheet2.getPhysicalNumberOfRows());
Row row2_1 = sheet2.getRow(1);
assertNotNull(row2_1);
Cell cell2_1_1 = row2_1.getCell(1);
assertNotNull(cell2_1_1);
assertEquals("value 2_1_1", cell2_1_1.getStringCellValue());
row2_2 = sheet2.getRow(2);
assertNotNull(row2_2);
cell2_2_1 = row2_2.getCell(1);
assertNotNull(cell2_2_1);
assertEquals("value 2_2_1", cell2_2_1.getStringCellValue());
// Verify sheet 3
sheet3 = xssfWb3.getSheetAt(2);
assertEquals("S3", sheet3.getSheetName());
assertEquals(1, sheet3.getPhysicalNumberOfRows());
row3_1 = sheet3.getRow(1);
assertNotNull(row3_1);
cell3_1_1 = row3_1.getCell(1);
assertNotNull(cell3_1_1);
assertEquals("value 3_1_1", cell3_1_1.getStringCellValue());
xssfWb2.close();
xssfWb3.close();
wb1.close();
try (XSSFWorkbook xssfWb3 = SXSSFITestDataProvider.instance.writeOutAndReadBack(wb2)) {
assertEquals(3, xssfWb3.getNumberOfSheets());
// Verify sheet 1
sheet1 = xssfWb3.getSheetAt(0);
assertEquals("S1", sheet1.getSheetName());
assertEquals(1, sheet1.getPhysicalNumberOfRows());
row1_1 = sheet1.getRow(1);
assertNotNull(row1_1);
cell1_1_1 = row1_1.getCell(1);
assertNotNull(cell1_1_1);
assertEquals("value 1_1_1", cell1_1_1.getStringCellValue());
// Verify sheet 2
sheet2 = xssfWb3.getSheetAt(1);
assertEquals("S2", sheet2.getSheetName());
assertEquals(2, sheet2.getPhysicalNumberOfRows());
Row row2_1 = sheet2.getRow(1);
assertNotNull(row2_1);
Cell cell2_1_1 = row2_1.getCell(1);
assertNotNull(cell2_1_1);
assertEquals("value 2_1_1", cell2_1_1.getStringCellValue());
row2_2 = sheet2.getRow(2);
assertNotNull(row2_2);
cell2_2_1 = row2_2.getCell(1);
assertNotNull(cell2_2_1);
assertEquals("value 2_2_1", cell2_2_1.getStringCellValue());
// Verify sheet 3
sheet3 = xssfWb3.getSheetAt(2);
assertEquals("S3", sheet3.getSheetName());
assertEquals(1, sheet3.getPhysicalNumberOfRows());
row3_1 = sheet3.getRow(1);
assertNotNull(row3_1);
cell3_1_1 = row3_1.getCell(1);
assertNotNull(cell3_1_1);
assertEquals("value 3_1_1", cell3_1_1.getStringCellValue());
}
}
}
}
}
@Test
void sheetdataWriter() throws IOException{
SXSSFWorkbook wb = new SXSSFWorkbook();
SXSSFSheet sh = wb.createSheet();
SheetDataWriter wr = sh.getSheetDataWriter();
assertSame(wr.getClass(), SheetDataWriter.class);
File tmp = wr.getTempFile();
assertStartsWith(tmp.getName(), "poi-sxssf-sheet");
assertEndsWith(tmp.getName(), ".xml");
assertTrue(wb.dispose());
wb.close();
try (SXSSFWorkbook wb = new SXSSFWorkbook()) {
SXSSFSheet sh = wb.createSheet();
SheetDataWriter wr = sh.getSheetDataWriter();
assertSame(wr.getClass(), SheetDataWriter.class);
File tmp = wr.getTempFile();
assertStartsWith(tmp.getName(), "poi-sxssf-sheet");
assertEndsWith(tmp.getName(), ".xml");
assertTrue(wb.dispose());
}
wb = new SXSSFWorkbook();
wb.setCompressTempFiles(true);
sh = wb.createSheet();
wr = sh.getSheetDataWriter();
assertSame(wr.getClass(), GZIPSheetDataWriter.class);
tmp = wr.getTempFile();
assertStartsWith(tmp.getName(), "poi-sxssf-sheet-xml");
assertEndsWith(tmp.getName(), ".gz");
assertTrue(wb.dispose());
wb.close();
try (SXSSFWorkbook wb = new SXSSFWorkbook()) {
wb.setCompressTempFiles(true);
SXSSFSheet sh = wb.createSheet();
SheetDataWriter wr = sh.getSheetDataWriter();
assertSame(wr.getClass(), GZIPSheetDataWriter.class);
File tmp = wr.getTempFile();
assertStartsWith(tmp.getName(), "poi-sxssf-sheet-xml");
assertEndsWith(tmp.getName(), ".gz");
assertTrue(wb.dispose());
}
//Test escaping of Unicode control characters
wb = new SXSSFWorkbook();
wb.createSheet("S1").createRow(0).createCell(0).setCellValue("value\u0019");
XSSFWorkbook xssfWorkbook = SXSSFITestDataProvider.instance.writeOutAndReadBack(wb);
Cell cell = xssfWorkbook.getSheet("S1").getRow(0).getCell(0);
assertEquals("value?", cell.getStringCellValue());
assertTrue(wb.dispose());
wb.close();
xssfWorkbook.close();
try (SXSSFWorkbook wb = new SXSSFWorkbook()) {
wb.createSheet("S1").createRow(0).createCell(0).setCellValue("value\u0019");
try (XSSFWorkbook xssfWorkbook = SXSSFITestDataProvider.instance.writeOutAndReadBack(wb)) {
Cell cell = xssfWorkbook.getSheet("S1").getRow(0).getCell(0);
assertEquals("value?", cell.getStringCellValue());
assertTrue(wb.dispose());
}
}
}
@Test
void gzipSheetdataWriter() throws IOException {
SXSSFWorkbook wb = new SXSSFWorkbook();
wb.setCompressTempFiles(true);
try (SXSSFWorkbook wb = new SXSSFWorkbook()) {
wb.setCompressTempFiles(true);
final int rowNum = 1000;
final int sheetNum = 5;
populateData(wb, 1000, 5);
final int rowNum = 1000;
final int sheetNum = 5;
populateData(wb);
XSSFWorkbook xwb = SXSSFITestDataProvider.instance.writeOutAndReadBack(wb);
for(int i = 0; i < sheetNum; i++){
Sheet sh = xwb.getSheetAt(i);
assertEquals("sheet" + i, sh.getSheetName());
for(int j = 0; j < rowNum; j++){
Row row = sh.getRow(j);
assertNotNull(row, "row[" + j + "]");
Cell cell1 = row.getCell(0);
assertEquals(new CellReference(cell1).formatAsString(), cell1.getStringCellValue());
try (XSSFWorkbook xwb = SXSSFITestDataProvider.instance.writeOutAndReadBack(wb)) {
for (int i = 0; i < sheetNum; i++) {
Sheet sh = xwb.getSheetAt(i);
assertEquals("sheet" + i, sh.getSheetName());
for (int j = 0; j < rowNum; j++) {
Row row = sh.getRow(j);
assertNotNull(row, "row[" + j + "]");
Cell cell1 = row.getCell(0);
assertEquals(new CellReference(cell1).formatAsString(), cell1.getStringCellValue());
Cell cell2 = row.getCell(1);
assertEquals(i, (int)cell2.getNumericCellValue());
Cell cell2 = row.getCell(1);
assertEquals(i, (int) cell2.getNumericCellValue());
Cell cell3 = row.getCell(2);
assertEquals(j, (int)cell3.getNumericCellValue());
Cell cell3 = row.getCell(2);
assertEquals(j, (int) cell3.getNumericCellValue());
}
}
assertTrue(wb.dispose());
}
}
assertTrue(wb.dispose());
xwb.close();
wb.close();
}
private static void assertWorkbookDispose(SXSSFWorkbook wb)
{
populateData(wb, 1000, 5);
for (Sheet sheet : wb) {
SXSSFSheet sxSheet = (SXSSFSheet) sheet;
assertTrue(sxSheet.getSheetDataWriter().getTempFile().exists());
}
assertTrue(wb.dispose());
for (Sheet sheet : wb) {
SXSSFSheet sxSheet = (SXSSFSheet) sheet;
assertFalse(sxSheet.getSheetDataWriter().getTempFile().exists());
}
}
private static void populateData(Workbook wb, final int rowNum, final int sheetNum) {
for(int i = 0; i < sheetNum; i++){
private static void populateData(Workbook wb) {
for(int i = 0; i < 5; i++){
Sheet sh = wb.createSheet("sheet" + i);
for(int j = 0; j < rowNum; j++){
for(int j = 0; j < 1000; j++){
Row row = sh.createRow(j);
Cell cell1 = row.createCell(0);
cell1.setCellValue(new CellReference(cell1).formatAsString());
@ -330,28 +308,40 @@ public final class TestSXSSFWorkbook extends BaseTestXWorkbook {
}
}
@Test
void workbookDispose() throws IOException {
SXSSFWorkbook wb1 = new SXSSFWorkbook();
// the underlying writer is SheetDataWriter
assertWorkbookDispose(wb1);
wb1.close();
@ParameterizedTest
@ValueSource(booleans = {false, true})
void workbookDispose(boolean compressTempFiles) throws IOException {
try (SXSSFWorkbook wb = new SXSSFWorkbook()) {
// compressTempFiles == false: the underlying writer is SheetDataWriter
// compressTempFiles == true: the underlying writer is GZIPSheetDataWriter
wb.setCompressTempFiles(compressTempFiles);
SXSSFWorkbook wb2 = new SXSSFWorkbook();
wb2.setCompressTempFiles(true);
// the underlying writer is GZIPSheetDataWriter
assertWorkbookDispose(wb2);
wb2.close();
populateData(wb);
for (Sheet sheet : wb) {
SXSSFSheet sxSheet = (SXSSFSheet) sheet;
assertTrue(sxSheet.getSheetDataWriter().getTempFile().exists());
}
assertTrue(wb.dispose());
for (Sheet sheet : wb) {
SXSSFSheet sxSheet = (SXSSFSheet) sheet;
assertFalse(sxSheet.getSheetDataWriter().getTempFile().exists());
}
}
}
@Test
void bug53515() throws Exception {
try (Workbook wb1 = new SXSSFWorkbook(10)) {
populateWorkbook(wb1);
saveTwice(wb1);
assertDoesNotThrow(() -> wb1.write(NULL_OUTPUT_STREAM));
assertDoesNotThrow(() -> wb1.write(NULL_OUTPUT_STREAM));
try (Workbook wb2 = new XSSFWorkbook()) {
populateWorkbook(wb2);
saveTwice(wb2);
assertDoesNotThrow(() -> wb2.write(NULL_OUTPUT_STREAM));
assertDoesNotThrow(() -> wb2.write(NULL_OUTPUT_STREAM));
}
}
}
@ -405,18 +395,6 @@ public final class TestSXSSFWorkbook extends BaseTestXWorkbook {
}
}
private static void saveTwice(Workbook wb) throws Exception {
for (int i = 0; i < 2; i++) {
try {
wb.write(NULL_OUTPUT_STREAM);
} catch (Exception e) {
throw new Exception("ERROR: failed on " + (i + 1)
+ "th time calling " + wb.getClass().getName()
+ ".write() with exception " + e.getMessage(), e);
}
}
}
@Test
void closeDoesNotModifyWorkbook() throws IOException {
final String filename = "SampleSS.xlsx";
@ -460,10 +438,10 @@ public final class TestSXSSFWorkbook extends BaseTestXWorkbook {
char[] useless = new char[32767];
Arrays.fill(useless, ' ');
for (int row = 0; row < 1; row++) {
for (int row = 0; row < 10; row++) {
Row r = s.createRow(row);
for (int col = 0; col < 10; col++) {
char[] prefix = Integer.toHexString(row * 1000 + col).toCharArray();
char[] prefix = Integer.toHexString(row * 10 + col).toCharArray();
Arrays.fill(useless, 0, 10, ' ');
System.arraycopy(prefix, 0, useless, 0, prefix.length);
String ul = new String(useless);
@ -528,8 +506,8 @@ public final class TestSXSSFWorkbook extends BaseTestXWorkbook {
}
}
@Override
@Disabled("not implemented")
@Test
void changeSheetNameWithSharedFormulas() {
protected void changeSheetNameWithSharedFormulas() {
}
}

11
poi-ooxml/src/test/java/org/apache/poi/xssf/usermodel/TestXSSFBugs.java
View File

@ -100,7 +100,6 @@ import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.ss.util.CellReference;
import org.apache.poi.ss.util.CellUtil;
import org.apache.poi.util.LocaleUtil;
import org.apache.commons.io.output.NullOutputStream;
import org.apache.poi.util.TempFile;
import org.apache.poi.util.XMLHelper;
import org.apache.poi.xssf.SXSSFITestDataProvider;
@ -117,7 +116,14 @@ import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.EnumSource;
import org.junit.jupiter.params.provider.ValueSource;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.*;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTCalcCell;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTCols;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTDefinedName;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTDefinedNames;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTMergeCell;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTMergeCells;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTWorksheet;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STCellFormulaType;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.impl.CTFontImpl;
import org.xml.sax.InputSource;
import org.xml.sax.SAXParseException;
@ -2714,6 +2720,7 @@ public final class TestXSSFBugs extends BaseTestBugzillaIssues {
CellStyle style = wb.createCellStyle();
style.setRotation((short) -90);
cell.setCellStyle(style);
assertEquals(180, style.getRotation());
XSSFTestDataSamples.writeOut(wb, fileName);
}

14
poi-ooxml/src/test/java/org/apache/poi/xssf/usermodel/TestXSSFFont.java
View File

@ -259,11 +259,11 @@ public final class TestXSSFFont extends BaseTestFont{
xssfFont.setUnderline(Font.U_DOUBLE);
assertEquals(ctFont.sizeOfUArray(),1);
assertEquals(STUnderlineValues.DOUBLE,ctFont.getUArray(0).getVal());
assertSame(STUnderlineValues.DOUBLE,ctFont.getUArray(0).getVal());
xssfFont.setUnderline(FontUnderline.DOUBLE_ACCOUNTING);
assertEquals(ctFont.sizeOfUArray(),1);
assertEquals(STUnderlineValues.DOUBLE_ACCOUNTING,ctFont.getUArray(0).getVal());
assertSame(STUnderlineValues.DOUBLE_ACCOUNTING,ctFont.getUArray(0).getVal());
}
@Test
@ -342,7 +342,7 @@ public final class TestXSSFFont extends BaseTestFont{
assertEquals(FontScheme.MAJOR,font.getScheme());
font.setScheme(FontScheme.NONE);
assertEquals(STFontScheme.NONE,ctFont.getSchemeArray(0).getVal());
assertSame(STFontScheme.NONE,ctFont.getSchemeArray(0).getVal());
}
@Test
@ -356,17 +356,15 @@ public final class TestXSSFFont extends BaseTestFont{
assertEquals(Font.SS_NONE,font.getTypeOffset());
font.setTypeOffset(XSSFFont.SS_SUPER);
assertEquals(STVerticalAlignRun.SUPERSCRIPT,ctFont.getVertAlignArray(0).getVal());
assertSame(STVerticalAlignRun.SUPERSCRIPT,ctFont.getVertAlignArray(0).getVal());
}
// store test from TestSheetUtil here as it uses XSSF
@Test
void testCanComputeWidthXSSF() throws IOException {
try (Workbook wb = new XSSFWorkbook()) {
// cannot check on result because on some machines we get back false here!
SheetUtil.canComputeColumnWidth(wb.getFontAt(0));
assertDoesNotThrow(() -> SheetUtil.canComputeColumnWidth(wb.getFontAt(0)));
}
}
@ -377,7 +375,7 @@ public final class TestXSSFFont extends BaseTestFont{
font.setFontName("some non existing font name");
// Even with invalid fonts we still get back useful data most of the time...
SheetUtil.canComputeColumnWidth(font);
assertDoesNotThrow(() -> SheetUtil.canComputeColumnWidth(font));
}
/**

711
poi-ooxml/src/test/java/org/apache/poi/xssf/usermodel/TestXSSFSheet.java
View File

@ -252,14 +252,14 @@ public final class TestXSSFSheet extends BaseTestXSheet {
sheet.createFreezePane(2, 4);
assertEquals(2.0, ctWorksheet.getSheetViews().getSheetViewArray(0).getPane().getXSplit(), 0.0);
assertEquals(STPane.BOTTOM_RIGHT, ctWorksheet.getSheetViews().getSheetViewArray(0).getPane().getActivePane());
assertSame(STPane.BOTTOM_RIGHT, ctWorksheet.getSheetViews().getSheetViewArray(0).getPane().getActivePane());
sheet.createFreezePane(3, 6, 10, 10);
assertEquals(3.0, ctWorksheet.getSheetViews().getSheetViewArray(0).getPane().getXSplit(), 0.0);
// assertEquals(10, sheet.getTopRow());
// assertEquals(10, sheet.getLeftCol());
sheet.createSplitPane(4, 8, 12, 12, 1);
assertEquals(8.0, ctWorksheet.getSheetViews().getSheetViewArray(0).getPane().getYSplit(), 0.0);
assertEquals(STPane.BOTTOM_RIGHT, ctWorksheet.getSheetViews().getSheetViewArray(0).getPane().getActivePane());
assertSame(STPane.BOTTOM_RIGHT, ctWorksheet.getSheetViews().getSheetViewArray(0).getPane().getActivePane());
workbook.close();
}
@ -1152,7 +1152,7 @@ public final class TestXSSFSheet extends BaseTestXSheet {
CTCalcPr calcPr = wb1.getCTWorkbook().addNewCalcPr();
calcPr.setCalcMode(STCalcMode.MANUAL);
sheet.setForceFormulaRecalculation(true);
assertEquals(STCalcMode.AUTO, calcPr.getCalcMode());
assertSame(STCalcMode.AUTO, calcPr.getCalcMode());
// Check
sheet.setForceFormulaRecalculation(false);
@ -1422,350 +1422,337 @@ public final class TestXSSFSheet extends BaseTestXSheet {
wb.close();
}
private void testCopyOneRow(String copyRowsTestWorkbook) throws IOException {
final double FLOAT_PRECISION = 1e-9;
final XSSFWorkbook wb = XSSFTestDataSamples.openSampleWorkbook(copyRowsTestWorkbook);
final XSSFSheet sheet = wb.getSheetAt(0);
final CellCopyPolicy defaultCopyPolicy = new CellCopyPolicy();
sheet.copyRows(1, 1, 6, defaultCopyPolicy);
final Row srcRow = sheet.getRow(1);
final Row destRow = sheet.getRow(6);
int col = 0;
Cell cell;
cell = CellUtil.getCell(destRow, col++);
assertEquals("Source row ->", cell.getStringCellValue());
// Style
cell = CellUtil.getCell(destRow, col++);
assertEquals("Red", cell.getStringCellValue(), "[Style] B7 cell value");
assertEquals(CellUtil.getCell(srcRow, 1).getCellStyle(), cell.getCellStyle(), "[Style] B7 cell style");
// Blank
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.BLANK, cell.getCellType(), "[Blank] C7 cell type");
// Error
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.ERROR, cell.getCellType(), "[Error] D7 cell type");
final FormulaError error = FormulaError.forInt(cell.getErrorCellValue());
//FIXME: XSSFCell and HSSFCell expose different interfaces. getErrorCellString would be helpful here
assertEquals(FormulaError.NA, error, "[Error] D7 cell value");
// Date
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Date] E7 cell type");
final Date date = LocaleUtil.getLocaleCalendar(2000, Calendar.JANUARY, 1).getTime();
assertEquals(date, cell.getDateCellValue(), "[Date] E7 cell value");
// Boolean
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.BOOLEAN, cell.getCellType(), "[Boolean] F7 cell type");
assertTrue(cell.getBooleanCellValue(), "[Boolean] F7 cell value");
// String
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.STRING, cell.getCellType(), "[String] G7 cell type");
assertEquals("Hello", cell.getStringCellValue(), "[String] G7 cell value");
// Int
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Int] H7 cell type");
assertEquals(15, (int) cell.getNumericCellValue(), "[Int] H7 cell value");
// Float
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Float] I7 cell type");
assertEquals(12.5, cell.getNumericCellValue(), FLOAT_PRECISION, "[Float] I7 cell value");
// Cell Formula
cell = CellUtil.getCell(destRow, col++);
assertEquals("Sheet1!J7", new CellReference(cell).formatAsString());
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula] J7 cell type");
assertEquals("5+2", cell.getCellFormula(), "[Cell Formula] J7 cell formula");
//System.out.println("Cell formula evaluation currently unsupported");
// Cell Formula with Reference
// Formula row references should be adjusted by destRowNum-srcRowNum
cell = CellUtil.getCell(destRow, col++);
assertEquals("Sheet1!K7", new CellReference(cell).formatAsString());
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula with Reference] K7 cell type");
assertEquals("J7+H$2", cell.getCellFormula(), "[Cell Formula with Reference] K7 cell formula");
// Cell Formula with Reference spanning multiple rows
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula with Reference spanning multiple rows] L7 cell type");
assertEquals("G7&\" \"&G8", cell.getCellFormula(), "[Cell Formula with Reference spanning multiple rows] L7 cell formula");
// Cell Formula with Reference spanning multiple rows
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula with Area Reference] M7 cell type");
assertEquals("SUM(H7:I8)", cell.getCellFormula(), "[Cell Formula with Area Reference] M7 cell formula");
// Array Formula
cell = CellUtil.getCell(destRow, col++);
//System.out.println("Array formulas currently unsupported");
// FIXME: Array Formula set with Sheet.setArrayFormula() instead of cell.setFormula()
/*
assertEquals(CellType.FORMULA, cell.getCellType(), "[Array Formula] N7 cell type");
assertEquals("{SUM(H7:J7*{1,2,3})}", cell.getCellFormula(), "[Array Formula] N7 cell formula");
*/
// Data Format
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Data Format] O7 cell type");
assertEquals(100.20, cell.getNumericCellValue(), FLOAT_PRECISION, "[Data Format] O7 cell value");
//FIXME: currently fails
final String moneyFormat = "\"$\"#,##0.00_);[Red]\\(\"$\"#,##0.00\\)";
assertEquals(moneyFormat, cell.getCellStyle().getDataFormatString(), "[Data Format] O7 data format");
// Merged
cell = CellUtil.getCell(destRow, col);
assertEquals("Merged cells", cell.getStringCellValue(), "[Merged] P7:Q7 cell value");
assertTrue(sheet.getMergedRegions().contains(CellRangeAddress.valueOf("P7:Q7")), "[Merged] P7:Q7 merged region");
// Merged across multiple rows
// Microsoft Excel 2013 does not copy a merged region unless all rows of
// the source merged region are selected
// POI's behavior should match this behavior
col += 2;
cell = CellUtil.getCell(destRow, col);
// Note: this behavior deviates from Microsoft Excel,
// which will not overwrite a cell in destination row if merged region extends beyond the copied row.
// The Excel way would require:
//assertEquals("[Merged across multiple rows] R7:S8 merged region", "Should NOT be overwritten", cell.getStringCellValue());
//assertFalse("[Merged across multiple rows] R7:S8 merged region",
// sheet.getMergedRegions().contains(CellRangeAddress.valueOf("R7:S8")));
// As currently implemented, cell value is copied but merged region is not copied
assertEquals("Merged cells across multiple rows", cell.getStringCellValue(), "[Merged across multiple rows] R7:S8 cell value");
// shouldn't do 1-row merge
assertFalse(sheet.getMergedRegions().contains(CellRangeAddress.valueOf("R7:S7")), "[Merged across multiple rows] R7:S7 merged region (one row)");
//shouldn't do 2-row merge
assertFalse(sheet.getMergedRegions().contains(CellRangeAddress.valueOf("R7:S8")), "[Merged across multiple rows] R7:S8 merged region");
// Make sure other rows are blank (off-by-one errors)
assertNull(sheet.getRow(5));
assertNull(sheet.getRow(7));
wb.close();
}
private void testCopyMultipleRows(String copyRowsTestWorkbook) throws IOException {
final double FLOAT_PRECISION = 1e-9;
final XSSFWorkbook wb = XSSFTestDataSamples.openSampleWorkbook(copyRowsTestWorkbook);
final XSSFSheet sheet = wb.getSheetAt(0);
final CellCopyPolicy defaultCopyPolicy = new CellCopyPolicy();
sheet.copyRows(0, 3, 8, defaultCopyPolicy);
sheet.getRow(0);
final Row srcRow1 = sheet.getRow(1);
final Row srcRow2 = sheet.getRow(2);
final Row srcRow3 = sheet.getRow(3);
final Row destHeaderRow = sheet.getRow(8);
final Row destRow1 = sheet.getRow(9);
final Row destRow2 = sheet.getRow(10);
final Row destRow3 = sheet.getRow(11);
int col = 0;
Cell cell;
// Header row should be copied
assertNotNull(destHeaderRow);
// Data rows
cell = CellUtil.getCell(destRow1, col);
assertEquals("Source row ->", cell.getStringCellValue());
// Style
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals("Red", cell.getStringCellValue(), "[Style] B10 cell value");
assertEquals(CellUtil.getCell(srcRow1, 1).getCellStyle(), cell.getCellStyle(), "[Style] B10 cell style");
cell = CellUtil.getCell(destRow2, col);
assertEquals("Blue", cell.getStringCellValue(), "[Style] B11 cell value");
assertEquals(CellUtil.getCell(srcRow2, 1).getCellStyle(), cell.getCellStyle(), "[Style] B11 cell style");
// Blank
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals(CellType.BLANK, cell.getCellType(), "[Blank] C10 cell type");
cell = CellUtil.getCell(destRow2, col);
assertEquals(CellType.BLANK, cell.getCellType(), "[Blank] C11 cell type");
// Error
col++;
cell = CellUtil.getCell(destRow1, col);
FormulaError error = FormulaError.forInt(cell.getErrorCellValue());
//FIXME: XSSFCell and HSSFCell expose different interfaces. getErrorCellString would be helpful here
assertEquals(CellType.ERROR, cell.getCellType(), "[Error] D10 cell type");
assertEquals(FormulaError.NA, error, "[Error] D10 cell value");
cell = CellUtil.getCell(destRow2, col);
error = FormulaError.forInt(cell.getErrorCellValue());
//FIXME: XSSFCell and HSSFCell expose different interfaces. getErrorCellString would be helpful here
assertEquals(CellType.ERROR, cell.getCellType(), "[Error] D11 cell type");
assertEquals(FormulaError.NAME, error, "[Error] D11 cell value");
// Date
col++;
cell = CellUtil.getCell(destRow1, col);
Date date = LocaleUtil.getLocaleCalendar(2000, Calendar.JANUARY, 1).getTime();
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Date] E10 cell type");
assertEquals(date, cell.getDateCellValue(), "[Date] E10 cell value");
cell = CellUtil.getCell(destRow2, col);
date = LocaleUtil.getLocaleCalendar(2000, Calendar.JANUARY, 2).getTime();
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Date] E11 cell type");
assertEquals(date, cell.getDateCellValue(), "[Date] E11 cell value");
// Boolean
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals(CellType.BOOLEAN, cell.getCellType(), "[Boolean] F10 cell type");
assertTrue(cell.getBooleanCellValue(), "[Boolean] F10 cell value");
cell = CellUtil.getCell(destRow2, col);
assertEquals(CellType.BOOLEAN, cell.getCellType(), "[Boolean] F11 cell type");
assertFalse(cell.getBooleanCellValue(), "[Boolean] F11 cell value");
// String
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals(CellType.STRING, cell.getCellType(), "[String] G10 cell type");
assertEquals("Hello", cell.getStringCellValue(), "[String] G10 cell value");
cell = CellUtil.getCell(destRow2, col);
assertEquals(CellType.STRING, cell.getCellType(), "[String] G11 cell type");
assertEquals("World", cell.getStringCellValue(), "[String] G11 cell value");
// Int
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Int] H10 cell type");
assertEquals(15, (int) cell.getNumericCellValue(), "[Int] H10 cell value");
cell = CellUtil.getCell(destRow2, col);
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Int] H11 cell type");
assertEquals(42, (int) cell.getNumericCellValue(), "[Int] H11 cell value");
// Float
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Float] I10 cell type");
assertEquals(12.5, cell.getNumericCellValue(), FLOAT_PRECISION, "[Float] I10 cell value");
cell = CellUtil.getCell(destRow2, col);
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Float] I11 cell type");
assertEquals(5.5, cell.getNumericCellValue(), FLOAT_PRECISION, "[Float] I11 cell value");
// Cell Formula
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula] J10 cell type");
assertEquals("5+2", cell.getCellFormula(), "[Cell Formula] J10 cell formula");
cell = CellUtil.getCell(destRow2, col);
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula] J11 cell type");
assertEquals("6+18", cell.getCellFormula(), "[Cell Formula] J11 cell formula");
// Cell Formula with Reference
col++;
// Formula row references should be adjusted by destRowNum-srcRowNum
cell = CellUtil.getCell(destRow1, col);
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula with Reference] K10 cell type");
assertEquals("J10+H$2", cell.getCellFormula(), "[Cell Formula with Reference] K10 cell formula");
cell = CellUtil.getCell(destRow2, col);
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula with Reference] K11 cell type");
assertEquals("J11+H$2", cell.getCellFormula(), "[Cell Formula with Reference] K11 cell formula");
// Cell Formula with Reference spanning multiple rows
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula with Reference spanning multiple rows] L10 cell type");
assertEquals("G10&\" \"&G11", cell.getCellFormula(), "[Cell Formula with Reference spanning multiple rows] L10 cell formula");
cell = CellUtil.getCell(destRow2, col);
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula with Reference spanning multiple rows] L11 cell type");
assertEquals("G11&\" \"&G12", cell.getCellFormula(), "[Cell Formula with Reference spanning multiple rows] L11 cell formula");
// Cell Formula with Area Reference
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula with Area Reference] M10 cell type");
assertEquals("SUM(H10:I11)", cell.getCellFormula(), "[Cell Formula with Area Reference] M10 cell formula");
cell = CellUtil.getCell(destRow2, col);
// Also acceptable: SUM($H10:I$3), but this AreaReference isn't in ascending order
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula with Area Reference] M11 cell type");
assertEquals("SUM($H$3:I10)", cell.getCellFormula(), "[Cell Formula with Area Reference] M11 cell formula");
// Array Formula
col++;
cell = CellUtil.getCell(destRow1, col);
// System.out.println("Array formulas currently unsupported");
/*
// FIXME: Array Formula set with Sheet.setArrayFormula() instead of cell.setFormula()
assertEquals(CellType.FORMULA, cell.getCellType(), "[Array Formula] N10 cell type");
assertEquals("{SUM(H10:J10*{1,2,3})}", cell.getCellFormula(), "[Array Formula] N10 cell formula");
cell = CellUtil.getCell(destRow2, col);
// FIXME: Array Formula set with Sheet.setArrayFormula() instead of cell.setFormula()
assertEquals(CellType.FORMULA, cell.getCellType(). "[Array Formula] N11 cell type");
assertEquals("{SUM(H11:J11*{1,2,3})}", cell.getCellFormula(). "[Array Formula] N11 cell formula");
*/
// Data Format
col++;
cell = CellUtil.getCell(destRow2, col);
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Data Format] O10 cell type");
assertEquals(100.20, cell.getNumericCellValue(), FLOAT_PRECISION, "[Data Format] O10 cell value");
final String moneyFormat = "\"$\"#,##0.00_);[Red]\\(\"$\"#,##0.00\\)";
assertEquals(moneyFormat, cell.getCellStyle().getDataFormatString(), "[Data Format] O10 cell data format");
// Merged
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals("Merged cells", cell.getStringCellValue(), "[Merged] P10:Q10 cell value");
assertTrue(sheet.getMergedRegions().contains(CellRangeAddress.valueOf("P10:Q10")), "[Merged] P10:Q10 merged region");
cell = CellUtil.getCell(destRow2, col);
assertEquals("Merged cells", cell.getStringCellValue(), "[Merged] P11:Q11 cell value");
assertTrue(sheet.getMergedRegions().contains(CellRangeAddress.valueOf("P11:Q11")), "[Merged] P11:Q11 merged region");
// Should Q10/Q11 be checked?
// Merged across multiple rows
// Microsoft Excel 2013 does not copy a merged region unless all rows of
// the source merged region are selected
// POI's behavior should match this behavior
col += 2;
cell = CellUtil.getCell(destRow1, col);
assertEquals("Merged cells across multiple rows", cell.getStringCellValue(), "[Merged across multiple rows] R10:S11 cell value");
assertTrue(sheet.getMergedRegions().contains(CellRangeAddress.valueOf("R10:S11")), "[Merged across multiple rows] R10:S11 merged region");
// Row 3 (zero-based) was empty, so Row 11 (zero-based) should be empty too.
if (srcRow3 == null) {
assertNull(destRow3, "Row 3 was empty, so Row 11 should be empty");
}
// Make sure other rows are blank (off-by-one errors)
assertNull(sheet.getRow(7), "Off-by-one lower edge case"); //one row above destHeaderRow
assertNull(sheet.getRow(12), "Off-by-one upper edge case"); //one row below destRow3
wb.close();
}
@Test
void testCopyOneRow() throws IOException {
testCopyOneRow("XSSFSheet.copyRows.xlsx");
final double FLOAT_PRECISION = 1e-9;
try (final XSSFWorkbook wb = XSSFTestDataSamples.openSampleWorkbook("XSSFSheet.copyRows.xlsx")) {
final XSSFSheet sheet = wb.getSheetAt(0);
final CellCopyPolicy defaultCopyPolicy = new CellCopyPolicy();
sheet.copyRows(1, 1, 6, defaultCopyPolicy);
final Row srcRow = sheet.getRow(1);
final Row destRow = sheet.getRow(6);
int col = 0;
Cell cell;
cell = CellUtil.getCell(destRow, col++);
assertEquals("Source row ->", cell.getStringCellValue());
// Style
cell = CellUtil.getCell(destRow, col++);
assertEquals("Red", cell.getStringCellValue(), "[Style] B7 cell value");
assertEquals(CellUtil.getCell(srcRow, 1).getCellStyle(), cell.getCellStyle(), "[Style] B7 cell style");
// Blank
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.BLANK, cell.getCellType(), "[Blank] C7 cell type");
// Error
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.ERROR, cell.getCellType(), "[Error] D7 cell type");
final FormulaError error = FormulaError.forInt(cell.getErrorCellValue());
//FIXME: XSSFCell and HSSFCell expose different interfaces. getErrorCellString would be helpful here
assertEquals(FormulaError.NA, error, "[Error] D7 cell value");
// Date
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Date] E7 cell type");
final Date date = LocaleUtil.getLocaleCalendar(2000, Calendar.JANUARY, 1).getTime();
assertEquals(date, cell.getDateCellValue(), "[Date] E7 cell value");
// Boolean
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.BOOLEAN, cell.getCellType(), "[Boolean] F7 cell type");
assertTrue(cell.getBooleanCellValue(), "[Boolean] F7 cell value");
// String
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.STRING, cell.getCellType(), "[String] G7 cell type");
assertEquals("Hello", cell.getStringCellValue(), "[String] G7 cell value");
// Int
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Int] H7 cell type");
assertEquals(15, (int) cell.getNumericCellValue(), "[Int] H7 cell value");
// Float
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Float] I7 cell type");
assertEquals(12.5, cell.getNumericCellValue(), FLOAT_PRECISION, "[Float] I7 cell value");
// Cell Formula
cell = CellUtil.getCell(destRow, col++);
assertEquals("Sheet1!J7", new CellReference(cell).formatAsString());
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula] J7 cell type");
assertEquals("5+2", cell.getCellFormula(), "[Cell Formula] J7 cell formula");
//System.out.println("Cell formula evaluation currently unsupported");
// Cell Formula with Reference
// Formula row references should be adjusted by destRowNum-srcRowNum
cell = CellUtil.getCell(destRow, col++);
assertEquals("Sheet1!K7", new CellReference(cell).formatAsString());
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula with Reference] K7 cell type");
assertEquals("J7+H$2", cell.getCellFormula(), "[Cell Formula with Reference] K7 cell formula");
// Cell Formula with Reference spanning multiple rows
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula with Reference spanning multiple rows] L7 cell type");
assertEquals("G7&\" \"&G8", cell.getCellFormula(), "[Cell Formula with Reference spanning multiple rows] L7 cell formula");
// Cell Formula with Reference spanning multiple rows
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula with Area Reference] M7 cell type");
assertEquals("SUM(H7:I8)", cell.getCellFormula(), "[Cell Formula with Area Reference] M7 cell formula");
// Array Formula
col++;
// cell = CellUtil.getCell(destRow, col++);
// Array formulas currently unsupported"
// FIXME: Array Formula set with Sheet.setArrayFormula() instead of cell.setFormula()
// assertEquals(CellType.FORMULA, cell.getCellType(), "[Array Formula] N7 cell type");
// assertEquals("{SUM(H7:J7*{1,2,3})}", cell.getCellFormula(), "[Array Formula] N7 cell formula");
// Data Format
cell = CellUtil.getCell(destRow, col++);
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Data Format] O7 cell type");
assertEquals(100.20, cell.getNumericCellValue(), FLOAT_PRECISION, "[Data Format] O7 cell value");
//FIXME: currently fails
final String moneyFormat = "\"$\"#,##0.00_);[Red]\\(\"$\"#,##0.00\\)";
assertEquals(moneyFormat, cell.getCellStyle().getDataFormatString(), "[Data Format] O7 data format");
// Merged
cell = CellUtil.getCell(destRow, col);
assertEquals("Merged cells", cell.getStringCellValue(), "[Merged] P7:Q7 cell value");
assertTrue(sheet.getMergedRegions().contains(CellRangeAddress.valueOf("P7:Q7")), "[Merged] P7:Q7 merged region");
// Merged across multiple rows
// Microsoft Excel 2013 does not copy a merged region unless all rows of
// the source merged region are selected
// POI's behavior should match this behavior
col += 2;
cell = CellUtil.getCell(destRow, col);
// Note: this behavior deviates from Microsoft Excel,
// which will not overwrite a cell in destination row if merged region extends beyond the copied row.
// The Excel way would require:
//assertEquals("[Merged across multiple rows] R7:S8 merged region", "Should NOT be overwritten", cell.getStringCellValue());
//assertFalse("[Merged across multiple rows] R7:S8 merged region",
// sheet.getMergedRegions().contains(CellRangeAddress.valueOf("R7:S8")));
// As currently implemented, cell value is copied but merged region is not copied
assertEquals("Merged cells across multiple rows", cell.getStringCellValue(), "[Merged across multiple rows] R7:S8 cell value");
// shouldn't do 1-row merge
assertFalse(sheet.getMergedRegions().contains(CellRangeAddress.valueOf("R7:S7")), "[Merged across multiple rows] R7:S7 merged region (one row)");
//shouldn't do 2-row merge
assertFalse(sheet.getMergedRegions().contains(CellRangeAddress.valueOf("R7:S8")), "[Merged across multiple rows] R7:S8 merged region");
// Make sure other rows are blank (off-by-one errors)
assertNull(sheet.getRow(5));
assertNull(sheet.getRow(7));
}
}
@Test
void testCopyMultipleRows() throws IOException {
testCopyMultipleRows("XSSFSheet.copyRows.xlsx");
final double FLOAT_PRECISION = 1e-9;
try (XSSFWorkbook wb = XSSFTestDataSamples.openSampleWorkbook("XSSFSheet.copyRows.xlsx")) {
final XSSFSheet sheet = wb.getSheetAt(0);
final CellCopyPolicy defaultCopyPolicy = new CellCopyPolicy();
sheet.copyRows(0, 3, 8, defaultCopyPolicy);
sheet.getRow(0);
final Row srcRow1 = sheet.getRow(1);
final Row srcRow2 = sheet.getRow(2);
final Row srcRow3 = sheet.getRow(3);
final Row destHeaderRow = sheet.getRow(8);
final Row destRow1 = sheet.getRow(9);
final Row destRow2 = sheet.getRow(10);
final Row destRow3 = sheet.getRow(11);
int col = 0;
Cell cell;
// Header row should be copied
assertNotNull(destHeaderRow);
// Data rows
cell = CellUtil.getCell(destRow1, col);
assertEquals("Source row ->", cell.getStringCellValue());
// Style
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals("Red", cell.getStringCellValue(), "[Style] B10 cell value");
assertEquals(CellUtil.getCell(srcRow1, 1).getCellStyle(), cell.getCellStyle(), "[Style] B10 cell style");
cell = CellUtil.getCell(destRow2, col);
assertEquals("Blue", cell.getStringCellValue(), "[Style] B11 cell value");
assertEquals(CellUtil.getCell(srcRow2, 1).getCellStyle(), cell.getCellStyle(), "[Style] B11 cell style");
// Blank
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals(CellType.BLANK, cell.getCellType(), "[Blank] C10 cell type");
cell = CellUtil.getCell(destRow2, col);
assertEquals(CellType.BLANK, cell.getCellType(), "[Blank] C11 cell type");
// Error
col++;
cell = CellUtil.getCell(destRow1, col);
FormulaError error = FormulaError.forInt(cell.getErrorCellValue());
//FIXME: XSSFCell and HSSFCell expose different interfaces. getErrorCellString would be helpful here
assertEquals(CellType.ERROR, cell.getCellType(), "[Error] D10 cell type");
assertEquals(FormulaError.NA, error, "[Error] D10 cell value");
cell = CellUtil.getCell(destRow2, col);
error = FormulaError.forInt(cell.getErrorCellValue());
//FIXME: XSSFCell and HSSFCell expose different interfaces. getErrorCellString would be helpful here
assertEquals(CellType.ERROR, cell.getCellType(), "[Error] D11 cell type");
assertEquals(FormulaError.NAME, error, "[Error] D11 cell value");
// Date
col++;
cell = CellUtil.getCell(destRow1, col);
Date date = LocaleUtil.getLocaleCalendar(2000, Calendar.JANUARY, 1).getTime();
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Date] E10 cell type");
assertEquals(date, cell.getDateCellValue(), "[Date] E10 cell value");
cell = CellUtil.getCell(destRow2, col);
date = LocaleUtil.getLocaleCalendar(2000, Calendar.JANUARY, 2).getTime();
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Date] E11 cell type");
assertEquals(date, cell.getDateCellValue(), "[Date] E11 cell value");
// Boolean
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals(CellType.BOOLEAN, cell.getCellType(), "[Boolean] F10 cell type");
assertTrue(cell.getBooleanCellValue(), "[Boolean] F10 cell value");
cell = CellUtil.getCell(destRow2, col);
assertEquals(CellType.BOOLEAN, cell.getCellType(), "[Boolean] F11 cell type");
assertFalse(cell.getBooleanCellValue(), "[Boolean] F11 cell value");
// String
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals(CellType.STRING, cell.getCellType(), "[String] G10 cell type");
assertEquals("Hello", cell.getStringCellValue(), "[String] G10 cell value");
cell = CellUtil.getCell(destRow2, col);
assertEquals(CellType.STRING, cell.getCellType(), "[String] G11 cell type");
assertEquals("World", cell.getStringCellValue(), "[String] G11 cell value");
// Int
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Int] H10 cell type");
assertEquals(15, (int) cell.getNumericCellValue(), "[Int] H10 cell value");
cell = CellUtil.getCell(destRow2, col);
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Int] H11 cell type");
assertEquals(42, (int) cell.getNumericCellValue(), "[Int] H11 cell value");
// Float
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Float] I10 cell type");
assertEquals(12.5, cell.getNumericCellValue(), FLOAT_PRECISION, "[Float] I10 cell value");
cell = CellUtil.getCell(destRow2, col);
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Float] I11 cell type");
assertEquals(5.5, cell.getNumericCellValue(), FLOAT_PRECISION, "[Float] I11 cell value");
// Cell Formula
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula] J10 cell type");
assertEquals("5+2", cell.getCellFormula(), "[Cell Formula] J10 cell formula");
cell = CellUtil.getCell(destRow2, col);
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula] J11 cell type");
assertEquals("6+18", cell.getCellFormula(), "[Cell Formula] J11 cell formula");
// Cell Formula with Reference
col++;
// Formula row references should be adjusted by destRowNum-srcRowNum
cell = CellUtil.getCell(destRow1, col);
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula with Reference] K10 cell type");
assertEquals("J10+H$2", cell.getCellFormula(), "[Cell Formula with Reference] K10 cell formula");
cell = CellUtil.getCell(destRow2, col);
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula with Reference] K11 cell type");
assertEquals("J11+H$2", cell.getCellFormula(), "[Cell Formula with Reference] K11 cell formula");
// Cell Formula with Reference spanning multiple rows
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula with Reference spanning multiple rows] L10 cell type");
assertEquals("G10&\" \"&G11", cell.getCellFormula(), "[Cell Formula with Reference spanning multiple rows] L10 cell formula");
cell = CellUtil.getCell(destRow2, col);
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula with Reference spanning multiple rows] L11 cell type");
assertEquals("G11&\" \"&G12", cell.getCellFormula(), "[Cell Formula with Reference spanning multiple rows] L11 cell formula");
// Cell Formula with Area Reference
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula with Area Reference] M10 cell type");
assertEquals("SUM(H10:I11)", cell.getCellFormula(), "[Cell Formula with Area Reference] M10 cell formula");
cell = CellUtil.getCell(destRow2, col);
// Also acceptable: SUM($H10:I$3), but this AreaReference isn't in ascending order
assertEquals(CellType.FORMULA, cell.getCellType(), "[Cell Formula with Area Reference] M11 cell type");
assertEquals("SUM($H$3:I10)", cell.getCellFormula(), "[Cell Formula with Area Reference] M11 cell formula");
// Array Formula
col++;
// cell = CellUtil.getCell(destRow1, col);
// Array formulas currently unsupported
// FIXME: Array Formula set with Sheet.setArrayFormula() instead of cell.setFormula()
// assertEquals(CellType.FORMULA, cell.getCellType(), "[Array Formula] N10 cell type");
// assertEquals("{SUM(H10:J10*{1,2,3})}", cell.getCellFormula(), "[Array Formula] N10 cell formula");
// cell = CellUtil.getCell(destRow2, col);
// FIXME: Array Formula set with Sheet.setArrayFormula() instead of cell.setFormula()
// assertEquals(CellType.FORMULA, cell.getCellType(). "[Array Formula] N11 cell type");
// assertEquals("{SUM(H11:J11*{1,2,3})}", cell.getCellFormula(). "[Array Formula] N11 cell formula");
// Data Format
col++;
cell = CellUtil.getCell(destRow2, col);
assertEquals(CellType.NUMERIC, cell.getCellType(), "[Data Format] O10 cell type");
assertEquals(100.20, cell.getNumericCellValue(), FLOAT_PRECISION, "[Data Format] O10 cell value");
final String moneyFormat = "\"$\"#,##0.00_);[Red]\\(\"$\"#,##0.00\\)";
assertEquals(moneyFormat, cell.getCellStyle().getDataFormatString(), "[Data Format] O10 cell data format");
// Merged
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals("Merged cells", cell.getStringCellValue(), "[Merged] P10:Q10 cell value");
assertTrue(sheet.getMergedRegions().contains(CellRangeAddress.valueOf("P10:Q10")), "[Merged] P10:Q10 merged region");
cell = CellUtil.getCell(destRow2, col);
assertEquals("Merged cells", cell.getStringCellValue(), "[Merged] P11:Q11 cell value");
assertTrue(sheet.getMergedRegions().contains(CellRangeAddress.valueOf("P11:Q11")), "[Merged] P11:Q11 merged region");
// Should Q10/Q11 be checked?
// Merged across multiple rows
// Microsoft Excel 2013 does not copy a merged region unless all rows of
// the source merged region are selected
// POI's behavior should match this behavior
col += 2;
cell = CellUtil.getCell(destRow1, col);
assertEquals("Merged cells across multiple rows", cell.getStringCellValue(), "[Merged across multiple rows] R10:S11 cell value");
assertTrue(sheet.getMergedRegions().contains(CellRangeAddress.valueOf("R10:S11")), "[Merged across multiple rows] R10:S11 merged region");
// Row 3 (zero-based) was empty, so Row 11 (zero-based) should be empty too.
if (srcRow3 == null) {
assertNull(destRow3, "Row 3 was empty, so Row 11 should be empty");
}
// Make sure other rows are blank (off-by-one errors)
assertNull(sheet.getRow(7), "Off-by-one lower edge case"); //one row above destHeaderRow
assertNull(sheet.getRow(12), "Off-by-one upper edge case"); //one row below destRow3
}
}
@Test
@ -1998,26 +1985,34 @@ public final class TestXSSFSheet extends BaseTestXSheet {
@Test
public void bug65120() throws IOException {
XSSFWorkbook wb = new XSSFWorkbook();
CreationHelper creationHelper = wb.getCreationHelper();
try (XSSFWorkbook wb = new XSSFWorkbook()) {
XSSFCreationHelper creationHelper = wb.getCreationHelper();
Sheet sheet1 = wb.createSheet();
Cell cell1 = sheet1.createRow(0).createCell(0);
Comment comment1 = sheet1.createDrawingPatriarch().createCellComment(creationHelper.createClientAnchor());
cell1.setCellComment(comment1);
XSSFSheet sheet1 = wb.createSheet();
Cell cell1 = sheet1.createRow(0).createCell(0);
XSSFDrawing dwg1 = sheet1.createDrawingPatriarch();
XSSFComment comment1 = dwg1.createCellComment(creationHelper.createClientAnchor());
cell1.setCellComment(comment1);
XSSFVMLDrawing vml0 = sheet1.getVMLDrawing(false);
assertEquals("/xl/drawings/vmlDrawing0.vml", vml0.getPackagePart().getPartName().getName());
Sheet sheet2 = wb.createSheet();
Cell cell2 = sheet2.createRow(0).createCell(0);
Comment comment2 = sheet2.createDrawingPatriarch().createCellComment(creationHelper.createClientAnchor());
cell2.setCellComment(comment2);
XSSFSheet sheet2 = wb.createSheet();
Cell cell2 = sheet2.createRow(0).createCell(0);
XSSFDrawing dwg2 = sheet2.createDrawingPatriarch();
Comment comment2 = dwg2.createCellComment(creationHelper.createClientAnchor());
cell2.setCellComment(comment2);
XSSFVMLDrawing vml1 = sheet2.getVMLDrawing(false);
assertEquals("/xl/drawings/vmlDrawing1.vml", vml1.getPackagePart().getPartName().getName());
wb.removeSheetAt(0);
wb.removeSheetAt(0);
Sheet sheet3 = wb.createSheet();
Cell cell3 = sheet3.createRow(0).createCell(0);
Comment comment3 = sheet3.createDrawingPatriarch().createCellComment(creationHelper.createClientAnchor());
cell3.setCellComment(comment3);
wb.close();
XSSFSheet sheet3 = wb.createSheet();
Cell cell3 = sheet3.createRow(0).createCell(0);
XSSFDrawing dwg3 = sheet3.createDrawingPatriarch();
Comment comment3 = dwg3.createCellComment(creationHelper.createClientAnchor());
cell3.setCellComment(comment3);
XSSFVMLDrawing vml2 = sheet3.getVMLDrawing(false);
assertEquals("/xl/drawings/vmlDrawing2.vml", vml2.getPackagePart().getPartName().getName());
}
}
}

5
poi-scratchpad/src/main/java/org/apache/poi/hemf/record/emfplus/HemfPlusBrush.java
View File

@ -399,18 +399,17 @@ public class HemfPlusBrush {
}
public byte[] getRawData(List<? extends EmfPlusObjectData> continuedObjectData) {
UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream();
try {
try (UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream()) {
bos.write(getBrushBytes());
if (continuedObjectData != null) {
for (EmfPlusObjectData od : continuedObjectData) {
bos.write(((EmfPlusBrush)od).getBrushBytes());
}
}
return bos.toByteArray();
} catch (IOException e) {
throw new RuntimeException(e);
}
return bos.toByteArray();
}

5
poi-scratchpad/src/main/java/org/apache/poi/hemf/record/emfplus/HemfPlusImage.java
View File

@ -445,18 +445,17 @@ public class HemfPlusImage {
}
public byte[] getRawData(List<? extends EmfPlusObjectData> continuedObjectData) {
UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream();
try {
try (UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream()) {
bos.write(getImageData());
if (continuedObjectData != null) {
for (EmfPlusObjectData od : continuedObjectData) {
bos.write(((EmfPlusImage)od).getImageData());
}
}
return bos.toByteArray();
} catch (IOException e) {
throw new RuntimeException(e);
}
return bos.toByteArray();
}
@Override

42
poi-scratchpad/src/main/java/org/apache/poi/hemf/usermodel/HemfEmbeddedIterator.java
View File

@ -35,6 +35,7 @@ import org.apache.poi.hemf.record.emf.HemfComment.EmfCommentDataMultiformats;
import org.apache.poi.hemf.record.emf.HemfComment.EmfCommentDataPlus;
import org.apache.poi.hemf.record.emf.HemfComment.EmfCommentDataWMF;
import org.apache.poi.hemf.record.emf.HemfRecord;
import org.apache.poi.hemf.record.emfplus.HemfPlusImage;
import org.apache.poi.hemf.record.emfplus.HemfPlusImage.EmfPlusBitmapDataType;
import org.apache.poi.hemf.record.emfplus.HemfPlusImage.EmfPlusImage;
import org.apache.poi.hemf.record.emfplus.HemfPlusObject.EmfPlusObject;
@ -63,6 +64,10 @@ public class HemfEmbeddedIterator implements Iterator<HwmfEmbedded> {
@Override
public boolean hasNext() {
return moveNext();
}
private boolean moveNext() {
if (iterStack.isEmpty()) {
return false;
}
@ -290,36 +295,33 @@ public class HemfEmbeddedIterator implements Iterator<HwmfEmbedded> {
final int objectId = epo.getObjectId();
HwmfEmbedded emb = new HwmfEmbedded();
final HwmfEmbedded emb = new HwmfEmbedded();
EmfPlusImage img = epo.getObjectData();
assert(img.getImageDataType() != null);
int totalSize = epo.getTotalObjectSize();
// totalSize is only set, if there are multiple chunks
final int totalSize = epo.getTotalObjectSize() == 0
? ((EmfPlusImage)epo.getObjectData()).getImageData().length
: epo.getTotalObjectSize();
IOUtils.safelyAllocateCheck(totalSize, MAX_RECORD_LENGTH);
UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream(epo.getTotalObjectSize());
try {
for (;;) {
try (UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream(totalSize)) {
boolean hasNext = false;
do {
EmfPlusImage img = epo.getObjectData();
assert(img.getImageDataType() != null);
assert(!hasNext || img.getImageDataType() == HemfPlusImage.EmfPlusImageDataType.CONTINUED);
bos.write(img.getImageData());
current = null;
//noinspection ConstantConditions
if (hasNext() &&
hasNext = moveNext() &&
(current instanceof EmfPlusObject) &&
((epo = (EmfPlusObject) current).getObjectId() == objectId) &&
bos.size() < totalSize-16
) {
img = epo.getObjectData();
} else {
return emb;
}
}
bos.size() < totalSize-16;
} while (hasNext);
emb.setData(bos.toByteArray());
return emb;
} catch (IOException ignored) {
// UnsynchronizedByteArrayOutputStream doesn't throw IOException
return null;
} finally {
emb.setData(bos.toByteArray());
}
}
}

48
poi-scratchpad/src/main/java/org/apache/poi/hslf/blip/PICT.java
View File

@ -70,9 +70,8 @@ public final class PICT extends Metafile {
@Override
public byte[] getData(){
byte[] rawdata = getRawData();
try {
try (UnsynchronizedByteArrayOutputStream out = new UnsynchronizedByteArrayOutputStream()) {
byte[] macheader = new byte[512];
UnsynchronizedByteArrayOutputStream out = new UnsynchronizedByteArrayOutputStream();
out.write(macheader);
int pos = CHECKSUM_SIZE*getUIDInstanceCount();
byte[] pict = read(rawdata, pos);
@ -93,30 +92,33 @@ public final class PICT extends Metafile {
throw new EOFException();
}
byte[] chunk = new byte[4096];
UnsynchronizedByteArrayOutputStream out = new UnsynchronizedByteArrayOutputStream(header.getWmfSize());
try (InflaterInputStream inflater = new InflaterInputStream(bis)) {
int count;
while ((count = inflater.read(chunk)) >= 0) {
out.write(chunk, 0, count);
// PICT zip-stream can be erroneous, so we clear the array to determine
// the maximum of read bytes, after the inflater crashed
bytefill(chunk, (byte) 0);
}
} catch (Exception e) {
int lastLen;
for (lastLen = chunk.length - 1; lastLen >= 0 && chunk[lastLen] == 0; lastLen--) ;
if (++lastLen > 0) {
if (header.getWmfSize() > out.size()) {
// sometimes the wmfsize is smaller than the amount of already successfully read bytes
// in this case we take the lastLen as-is, otherwise we truncate it to the given size
lastLen = Math.min(lastLen, header.getWmfSize() - out.size());
try (UnsynchronizedByteArrayOutputStream out = new UnsynchronizedByteArrayOutputStream(header.getWmfSize())) {
try (InflaterInputStream inflater = new InflaterInputStream(bis)) {
int count;
while ((count = inflater.read(chunk)) >= 0) {
out.write(chunk, 0, count);
// PICT zip-stream can be erroneous, so we clear the array to determine
// the maximum of read bytes, after the inflater crashed
bytefill(chunk, (byte) 0);
}
out.write(chunk, 0, lastLen);
} catch (Exception e) {
int lastLen = chunk.length - 1;
while (lastLen >= 0 && chunk[lastLen] == 0) {
lastLen--;
}
if (++lastLen > 0) {
if (header.getWmfSize() > out.size()) {
// sometimes the wmfsize is smaller than the amount of already successfully read bytes
// in this case we take the lastLen as-is, otherwise we truncate it to the given size
lastLen = Math.min(lastLen, header.getWmfSize() - out.size());
}
out.write(chunk, 0, lastLen);
}
// End of picture marker for PICT is 0x00 0xFF
LOG.atError().withThrowable(e).log("PICT zip-stream is invalid, read as much as possible. Uncompressed length of header: {} / Read bytes: {}", box(header.getWmfSize()), box(out.size()));
}
// End of picture marker for PICT is 0x00 0xFF
LOG.atError().withThrowable(e).log("PICT zip-stream is invalid, read as much as possible. Uncompressed length of header: {} / Read bytes: {}", box(header.getWmfSize()),box(out.size()));
return out.toByteArray();
}
return out.toByteArray();
}
@Override

13
poi-scratchpad/src/main/java/org/apache/poi/hslf/record/EscherTextboxWrapper.java
View File

@ -89,12 +89,13 @@ public final class EscherTextboxWrapper extends RecordContainer {
// Write out our children, and stuff them into the Escher layer
// Grab the children's data
UnsynchronizedByteArrayOutputStream baos = new UnsynchronizedByteArrayOutputStream();
for (org.apache.poi.hslf.record.Record r : _children) r.writeOut(baos);
byte[] data = baos.toByteArray();
// Save in the escher layer
_escherRecord.setData(data);
try (UnsynchronizedByteArrayOutputStream baos = new UnsynchronizedByteArrayOutputStream()) {
for (org.apache.poi.hslf.record.Record r : _children) {
r.writeOut(baos);
}
// Save in the escher layer
_escherRecord.setData(baos.toByteArray());
}
}
/**

25
poi-scratchpad/src/main/java/org/apache/poi/hslf/record/ExOleObjStg.java
View File

@ -27,8 +27,8 @@ import java.util.function.Supplier;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.InflaterInputStream;
import org.apache.commons.io.output.UnsynchronizedByteArrayOutputStream;
import org.apache.commons.io.input.BoundedInputStream;
import org.apache.commons.io.output.UnsynchronizedByteArrayOutputStream;
import org.apache.poi.util.GenericRecordUtil;
import org.apache.poi.util.IOUtils;
import org.apache.poi.util.LittleEndian;
@ -124,18 +124,19 @@ public class ExOleObjStg extends PositionDependentRecordAtom implements PersistR
* @param data the embedded data.
*/
public void setData(byte[] data) throws IOException {
UnsynchronizedByteArrayOutputStream out = new UnsynchronizedByteArrayOutputStream();
//first four bytes is the length of the raw data
byte[] b = new byte[4];
LittleEndian.putInt(b, 0, data.length);
out.write(b);
try (UnsynchronizedByteArrayOutputStream out = new UnsynchronizedByteArrayOutputStream();
DeflaterOutputStream def = new DeflaterOutputStream(out)) {
//first four bytes is the length of the raw data
byte[] b = new byte[4];
LittleEndian.putInt(b, 0, data.length);
out.write(b);
DeflaterOutputStream def = new DeflaterOutputStream(out);
def.write(data, 0, data.length);
def.finish();
// TODO: CHECK if it's correct that DeflaterOutputStream is only finished and not closed?
_data = out.toByteArray();
LittleEndian.putInt(_header, 4, _data.length);
def.write(data, 0, data.length);
def.finish();
// TODO: CHECK if it's correct that DeflaterOutputStream is only finished and not closed?
_data = out.toByteArray();
LittleEndian.putInt(_header, 4, _data.length);
}
}
/**

72
poi-scratchpad/src/main/java/org/apache/poi/hslf/record/PPDrawingGroup.java
View File

@ -49,7 +49,7 @@ public final class PPDrawingGroup extends RecordAtom {
//cached dgg
private EscherDggRecord dgg;
protected PPDrawingGroup(byte[] source, int start, int len) {
PPDrawingGroup(byte[] source, int start, int len) {
// Get the header
_header = Arrays.copyOfRange(source, start, start+8);
@ -80,44 +80,44 @@ public final class PPDrawingGroup extends RecordAtom {
@Override
public void writeOut(OutputStream out) throws IOException {
UnsynchronizedByteArrayOutputStream bout = new UnsynchronizedByteArrayOutputStream();
for (EscherRecord r : dggContainer) {
if (r.getRecordId() == EscherContainerRecord.BSTORE_CONTAINER){
EscherContainerRecord bstore = (EscherContainerRecord)r;
UnsynchronizedByteArrayOutputStream b2 = new UnsynchronizedByteArrayOutputStream();
for (EscherRecord br : bstore) {
byte[] b = new byte[36+8];
br.serialize(0, b);
b2.write(b);
byte[] bstorehead = new byte[8];
byte[] recordBytes = new byte[36 + 8];
try (UnsynchronizedByteArrayOutputStream bout = new UnsynchronizedByteArrayOutputStream();
UnsynchronizedByteArrayOutputStream recordBuf = new UnsynchronizedByteArrayOutputStream()) {
for (EscherRecord r : dggContainer) {
if (r.getRecordId() == EscherContainerRecord.BSTORE_CONTAINER) {
EscherContainerRecord bstore = (EscherContainerRecord) r;
recordBuf.reset();
for (EscherRecord br : bstore) {
br.serialize(0, recordBytes);
recordBuf.write(recordBytes);
}
LittleEndian.putShort(bstorehead, 0, bstore.getOptions());
LittleEndian.putShort(bstorehead, 2, bstore.getRecordId());
LittleEndian.putInt(bstorehead, 4, recordBuf.size());
bout.write(bstorehead);
recordBuf.writeTo(bout);
} else {
bout.write(r.serialize());
}
byte[] bstorehead = new byte[8];
LittleEndian.putShort(bstorehead, 0, bstore.getOptions());
LittleEndian.putShort(bstorehead, 2, bstore.getRecordId());
LittleEndian.putInt(bstorehead, 4, b2.size());
bout.write(bstorehead);
bout.write(b2.toByteArray());
} else {
bout.write(r.serialize());
}
int size = bout.size();
// Update the size (header bytes 5-8)
LittleEndian.putInt(_header, 4, size + 8);
// Write out our header
out.write(_header);
byte[] dgghead = new byte[8];
LittleEndian.putShort(dgghead, 0, dggContainer.getOptions());
LittleEndian.putShort(dgghead, 2, dggContainer.getRecordId());
LittleEndian.putInt(dgghead, 4, size);
out.write(dgghead);
// Finally, write out the children
bout.writeTo(out);
}
int size = bout.size();
// Update the size (header bytes 5-8)
LittleEndian.putInt(_header,4,size+8);
// Write out our header
out.write(_header);
byte[] dgghead = new byte[8];
LittleEndian.putShort(dgghead, 0, dggContainer.getOptions());
LittleEndian.putShort(dgghead, 2, dggContainer.getRecordId());
LittleEndian.putInt(dgghead, 4, size);
out.write(dgghead);
// Finally, write out the children
bout.writeTo(out);
}
public EscherContainerRecord getDggContainer(){

42
poi-scratchpad/src/main/java/org/apache/poi/hslf/record/RecordContainer.java
View File

@ -227,30 +227,30 @@ public abstract class RecordContainer extends Record
*/
public void writeOut(byte headerA, byte headerB, long type, Record[] children, OutputStream out) throws IOException {
// Create a UnsynchronizedByteArrayOutputStream to hold everything in
UnsynchronizedByteArrayOutputStream baos = new UnsynchronizedByteArrayOutputStream();
try (UnsynchronizedByteArrayOutputStream baos = new UnsynchronizedByteArrayOutputStream()) {
// Write out our header, less the size
baos.write(new byte[] {headerA,headerB});
byte[] typeB = new byte[2];
LittleEndian.putShort(typeB,0,(short)type);
baos.write(typeB);
baos.write(new byte[] {0,0,0,0});
// Write out our header, less the size
baos.write(new byte[]{headerA, headerB});
byte[] typeB = new byte[2];
LittleEndian.putShort(typeB, 0, (short) type);
baos.write(typeB);
baos.write(new byte[]{0, 0, 0, 0});
// Write out our children
for (Record aChildren : children) {
aChildren.writeOut(baos);
// Write out our children
for (Record aChildren : children) {
aChildren.writeOut(baos);
}
// Grab the bytes back
byte[] toWrite = baos.toByteArray();
// Update our header with the size
// Don't forget to knock 8 more off, since we don't include the header in the size
LittleEndian.putInt(toWrite, 4, (toWrite.length - 8));
// Write out the bytes
out.write(toWrite);
}
// Grab the bytes back
byte[] toWrite = baos.toByteArray();
// Update our header with the size
// Don't forget to knock 8 more off, since we don't include the
// header in the size
LittleEndian.putInt(toWrite,4,(toWrite.length-8));
// Write out the bytes
out.write(toWrite);
}
/**

24
poi-scratchpad/src/main/java/org/apache/poi/hslf/record/StyleTextPropAtom.java
View File

@ -309,22 +309,20 @@ public final class StyleTextPropAtom extends RecordAtom {
*/
private void updateRawContents() throws IOException {
if (initialised) {
// Only update the style bytes, if the styles have been potentially
// changed
// Only update the style bytes, if the styles have been potentially changed
try (UnsynchronizedByteArrayOutputStream baos = new UnsynchronizedByteArrayOutputStream()) {
// First up, we need to serialise the paragraph properties
for (TextPropCollection tpc : paragraphStyles) {
tpc.writeOut(baos);
}
UnsynchronizedByteArrayOutputStream baos = new UnsynchronizedByteArrayOutputStream();
// Now, we do the character ones
for (TextPropCollection tpc : charStyles) {
tpc.writeOut(baos);
}
// First up, we need to serialise the paragraph properties
for(TextPropCollection tpc : paragraphStyles) {
tpc.writeOut(baos);
rawContents = baos.toByteArray();
}
// Now, we do the character ones
for(TextPropCollection tpc : charStyles) {
tpc.writeOut(baos);
}
rawContents = baos.toByteArray();
}
// Now ensure that the header size is correct

40
poi-scratchpad/src/main/java/org/apache/poi/hslf/record/TextSpecInfoAtom.java
View File

@ -130,26 +130,28 @@ public final class TextSpecInfoAtom extends RecordAtom {
*/
public void setParentSize(int size) {
assert(size > 0);
int covered = 0;
UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream();
TextSpecInfoRun[] runs = getTextSpecInfoRuns();
assert(runs.length > 0);
for (int i=0; i<runs.length && covered < size; i++) {
TextSpecInfoRun run = runs[i];
if (covered + run.getLength() > size || i == runs.length-1) {
run.setLength(size-covered);
}
covered += run.getLength();
try {
run.writeOut(bos);
} catch (IOException e) {
throw new HSLFException(e);
}
}
_data = bos.toByteArray();
// Update the size (header bytes 5-8)
LittleEndian.putInt(_header, 4, _data.length);
try (UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream()) {
TextSpecInfoRun[] runs = getTextSpecInfoRuns();
int remaining = size;
int idx = 0;
for (TextSpecInfoRun run : runs) {
int len = run.getLength();
if (len > remaining || idx == runs.length - 1) {
run.setLength(len = remaining);
}
remaining -= len;
run.writeOut(bos);
idx++;
}
_data = bos.toByteArray();
// Update the size (header bytes 5-8)
LittleEndian.putInt(_header, 4, _data.length);
} catch (IOException e) {
throw new HSLFException(e);
}
}
/**

32
poi-scratchpad/src/main/java/org/apache/poi/hwmf/usermodel/HwmfEmbeddedIterator.java
View File

@ -110,33 +110,29 @@ public class HwmfEmbeddedIterator implements Iterator<HwmfEmbedded> {
if (!(current instanceof HwmfEscape)) {
return null;
}
final HwmfEscape esc = (HwmfEscape)current;
assert(esc.getEscapeFunction() == EscapeFunction.META_ESCAPE_ENHANCED_METAFILE);
WmfEscapeEMF img = esc.getEscapeData();
assert(img.isValid());
current = null;
final HwmfEmbedded emb = new HwmfEmbedded();
emb.setEmbeddedType(HwmfEmbeddedType.EMF);
UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream();
try {
for (;;) {
bos.write(img.getEmfData());
try (UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream()) {
WmfEscapeEMF img;
do {
final HwmfEscape esc = (HwmfEscape)current;
assert(esc.getEscapeFunction() == EscapeFunction.META_ESCAPE_ENHANCED_METAFILE);
img = esc.getEscapeData();
assert(img.isValid());
bos.write(img.getEmfData());
current = null;
if (img.getRemainingBytes() > 0 && hasNext() && (current instanceof HwmfEscape)) {
img = ((HwmfEscape)current).getEscapeData();
} else {
return emb;
}
}
} while (img.getRemainingBytes() > 0 && hasNext() && (current instanceof HwmfEscape));
emb.setData(bos.toByteArray());
return emb;
} catch (IOException ignored) {
// UnsynchronizedByteArrayOutputStream doesn't throw IOException
return null;
} finally {
emb.setData(bos.toByteArray());
}
}
}

4
poi/build.gradle
View File

@ -104,6 +104,8 @@ task cacheTest9(type: Copy) {
}
jar {
dependsOn cacheJava9
if (JavaVersion.current() == JavaVersion.VERSION_1_8) {
into('META-INF/versions/9') {
from JAVA9_SRC include '*.class'
@ -117,7 +119,7 @@ jar {
// Create a separate jar for test-code to depend on it in other projects
// See http://stackoverflow.com/questions/5144325/gradle-test-dependency
task testJar(type: Jar, dependsOn: testClasses) {
task testJar(type: Jar, dependsOn: [ testClasses, cacheTest9 ]) {
destinationDirectory = file("../build/dist/maven/${project.archivesBaseName}-tests")
classifier 'tests'

17
poi/src/main/java/org/apache/poi/hpsf/ClassID.java
View File

@ -49,7 +49,7 @@ public class ClassID implements Duplicatable, GenericRecord {
private final byte[] bytes = new byte[LENGTH];
/**
* Creates a {@link ClassID} and reads its value from a byte array.
* Creates a ClassID and reads its value from a byte array.
*
* @param src The byte array to read from.
* @param offset The offset of the first byte to read.
@ -60,7 +60,7 @@ public class ClassID implements Duplicatable, GenericRecord {
/**
* Creates a {@link ClassID} and initializes its value with 0x00 bytes.
* Creates a ClassID and initializes its value with 0x00 bytes.
*/
public ClassID() {
Arrays.fill(bytes, (byte)0);
@ -77,7 +77,7 @@ public class ClassID implements Duplicatable, GenericRecord {
/**
* Creates a {@link ClassID} from a human-readable representation of the Class ID in standard
* Creates a ClassID from a human-readable representation of the Class ID in standard
* format {@code "{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}"}.
*
* @param externalForm representation of the Class ID represented by this object.
@ -102,12 +102,11 @@ public class ClassID implements Duplicatable, GenericRecord {
/**
* @return The number of bytes occupied by this object in the byte stream.
*/
@SuppressWarnings("java:S1845")
public int length() {
return LENGTH;
}
/**
* Gets the bytes making out the class ID. They are returned in correct order, i.e. big-endian.
*
@ -117,8 +116,6 @@ public class ClassID implements Duplicatable, GenericRecord {
return bytes;
}
/**
* Sets the bytes making out the class ID.
*
@ -129,8 +126,6 @@ public class ClassID implements Duplicatable, GenericRecord {
System.arraycopy(bytes, 0, this.bytes, 0, LENGTH);
}
/**
* Reads the class ID's value from a byte array by turning little-endian into big-endian.
*
@ -249,10 +244,6 @@ public class ClassID implements Duplicatable, GenericRecord {
;
}
/**
* @see Object#hashCode()
*/
@Override
public int hashCode() {
return toString().hashCode();

73
poi/src/main/java/org/apache/poi/hpsf/PropertySet.java
View File

@ -514,51 +514,52 @@ public class PropertySet {
}
private byte[] toBytes() throws WritingNotSupportedException, IOException {
UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream();
LittleEndianOutputStream leos = new LittleEndianOutputStream(bos);
try (UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream();
LittleEndianOutputStream leos = new LittleEndianOutputStream(bos)) {
/* Write the number of sections in this property set stream. */
final int nrSections = getSectionCount();
/* Write the number of sections in this property set stream. */
final int nrSections = getSectionCount();
/* Write the property set's header. */
leos.writeShort(getByteOrder());
leos.writeShort(getFormat());
leos.writeInt(getOSVersion());
putClassId(bos, getClassID());
leos.writeInt(nrSections);
/* Write the property set's header. */
leos.writeShort(getByteOrder());
leos.writeShort(getFormat());
leos.writeInt(getOSVersion());
putClassId(bos, getClassID());
leos.writeInt(nrSections);
assert(bos.size() == OFFSET_HEADER);
assert (bos.size() == OFFSET_HEADER);
final int[][] offsets = new int[getSectionCount()][2];
final int[][] offsets = new int[getSectionCount()][2];
/* Write the section list, i.e. the references to the sections. Each
* entry in the section list consist of the section's class ID and the
* section's offset relative to the beginning of the stream. */
int secCnt = 0;
for (final Section section : getSections()) {
final ClassID formatID = section.getFormatID();
if (formatID == null) {
throw new NoFormatIDException();
/* Write the section list, i.e. the references to the sections. Each
* entry in the section list consist of the section's class ID and the
* section's offset relative to the beginning of the stream. */
int secCnt = 0;
for (final Section section : getSections()) {
final ClassID formatID = section.getFormatID();
if (formatID == null) {
throw new NoFormatIDException();
}
putClassId(bos, formatID);
offsets[secCnt++][0] = bos.size();
// offset dummy - filled later
leos.writeInt(-1);
}
putClassId(bos, formatID);
offsets[secCnt++][0] = bos.size();
// offset dummy - filled later
leos.writeInt(-1);
}
/* Write the sections themselves. */
secCnt = 0;
for (final Section section : getSections()) {
offsets[secCnt++][1] = bos.size();
section.write(bos);
}
/* Write the sections themselves. */
secCnt = 0;
for (final Section section : getSections()) {
offsets[secCnt++][1] = bos.size();
section.write(bos);
}
byte[] result = bos.toByteArray();
for (int[] off : offsets) {
LittleEndian.putInt(result, off[0], off[1]);
}
byte[] result = bos.toByteArray();
for (int[] off : offsets) {
LittleEndian.putInt(result, off[0], off[1]);
}
return result;
return result;
}
}
/**

83
poi/src/main/java/org/apache/poi/hpsf/Section.java
View File

@ -735,53 +735,54 @@ public class Section {
}
final int[][] offsets = new int[properties.size()][2];
final UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream();
final LittleEndianOutputStream leos = new LittleEndianOutputStream(bos);
try (UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream();
LittleEndianOutputStream leos = new LittleEndianOutputStream(bos)) {
/* Write the section's length - dummy value, fixed later */
leos.writeInt(-1);
/* Write the section's number of properties: */
leos.writeInt(properties.size());
int propCnt = 0;
for (Property p : properties.values()) {
/* Write the property list entry. */
leos.writeUInt(p.getID());
// dummy offset to be fixed later
offsets[propCnt++][0] = bos.size();
/* Write the section's length - dummy value, fixed later */
leos.writeInt(-1);
}
/* Write the section's number of properties: */
leos.writeInt(properties.size());
/* Write the properties and the property list into their respective
* streams: */
propCnt = 0;
for (Property p : properties.values()) {
offsets[propCnt++][1] = bos.size();
/* If the property ID is not equal 0 we write the property and all
* is fine. However, if it equals 0 we have to write the section's
* dictionary which has an implicit type only and an explicit
* value. */
if (p.getID() != 0) {
/* Write the property and update the position to the next
* property. */
p.write(bos, codepage);
} else {
writeDictionary(bos, codepage);
int propCnt = 0;
for (Property p : properties.values()) {
/* Write the property list entry. */
leos.writeUInt(p.getID());
// dummy offset to be fixed later
offsets[propCnt++][0] = bos.size();
leos.writeInt(-1);
}
/* Write the properties and the property list into their respective
* streams: */
propCnt = 0;
for (Property p : properties.values()) {
offsets[propCnt++][1] = bos.size();
/* If the property ID is not equal 0 we write the property and all
* is fine. However, if it equals 0 we have to write the section's
* dictionary which has an implicit type only and an explicit
* value. */
if (p.getID() != 0) {
/* Write the property and update the position to the next
* property. */
p.write(bos, codepage);
} else {
writeDictionary(bos, codepage);
}
}
byte[] result = bos.toByteArray();
LittleEndian.putInt(result, 0, bos.size());
for (int[] off : offsets) {
LittleEndian.putUInt(result, off[0], off[1]);
}
out.write(result);
return bos.size();
}
byte[] result = bos.toByteArray();
LittleEndian.putInt(result, 0, bos.size());
for (int[] off : offsets) {
LittleEndian.putUInt(result, off[0], off[1]);
}
out.write(result);
return bos.size();
}
/**

19
poi/src/main/java/org/apache/poi/hssf/record/RecordInputStream.java
View File

@ -459,17 +459,20 @@ public final class RecordInputStream implements LittleEndianInput {
*/
@Deprecated
public byte[] readAllContinuedRemainder() {
UnsynchronizedByteArrayOutputStream out = new UnsynchronizedByteArrayOutputStream(2 * MAX_RECORD_DATA_SIZE);
try (UnsynchronizedByteArrayOutputStream out = new UnsynchronizedByteArrayOutputStream(2 * MAX_RECORD_DATA_SIZE)) {
while (true) {
byte[] b = readRemainder();
out.write(b, 0, b.length);
if (!isContinueNext()) {
break;
while (true) {
byte[] b = readRemainder();
out.write(b, 0, b.length);
if (!isContinueNext()) {
break;
}
nextRecord();
}
nextRecord();
return out.toByteArray();
} catch (IOException ex) {
throw new RecordFormatException(ex);
}
return out.toByteArray();
}
/** The remaining number of bytes in the <i>current</i> record.

40
poi/src/main/java/org/apache/poi/hssf/usermodel/HSSFConditionalFormattingRule.java
View File

@ -64,8 +64,8 @@ public final class HSSFConditionalFormattingRule implements ConditionalFormattin
* Only newer style formatting rules have priorities. For older ones,
* we don't know priority for these, other than definition/model order,
* which appears to be what Excel uses.
* @see org.apache.poi.ss.usermodel.ConditionalFormattingRule#getPriority()
*/
@Override
public int getPriority() {
CFRule12Record rule12 = getCFRule12Record(false);
if (rule12 == null) return 0;
@ -74,8 +74,8 @@ public final class HSSFConditionalFormattingRule implements ConditionalFormattin
/**
* Always true for HSSF files, per Microsoft Excel documentation
* @see org.apache.poi.ss.usermodel.ConditionalFormattingRule#getStopIfTrue()
*/
@Override
public boolean getStopIfTrue() {
return true;
}
@ -95,8 +95,8 @@ public final class HSSFConditionalFormattingRule implements ConditionalFormattin
/**
* Always null for HSSF records, until someone figures out where to find it
* @see org.apache.poi.ss.usermodel.ConditionalFormattingRule#getNumberFormat()
*/
@Override
public ExcelNumberFormat getNumberFormat() {
return null;
}
@ -112,16 +112,18 @@ public final class HSSFConditionalFormattingRule implements ConditionalFormattin
}
/**
* @return - font formatting object if defined, <code>null</code> otherwise
* @return - font formatting object if defined, {@code null} otherwise
*/
@Override
public HSSFFontFormatting getFontFormatting() {
return getFontFormatting(false);
}
/**
* create a new font formatting structure if it does not exist,
* otherwise just return existing object.
* @return - font formatting object, never returns <code>null</code>.
* @return - font formatting object, never returns {@code null}.
*/
@Override
public HSSFFontFormatting createFontFormatting() {
return getFontFormatting(true);
}
@ -137,16 +139,18 @@ public final class HSSFConditionalFormattingRule implements ConditionalFormattin
}
/**
* @return - border formatting object if defined, <code>null</code> otherwise
* @return - border formatting object if defined, {@code null} otherwise
*/
@Override
public HSSFBorderFormatting getBorderFormatting() {
return getBorderFormatting(false);
}
/**
* create a new border formatting structure if it does not exist,
* otherwise just return existing object.
* @return - border formatting object, never returns <code>null</code>.
* @return - border formatting object, never returns {@code null}.
*/
@Override
public HSSFBorderFormatting createBorderFormatting() {
return getBorderFormatting(true);
}
@ -162,8 +166,9 @@ public final class HSSFConditionalFormattingRule implements ConditionalFormattin
}
/**
* @return - pattern formatting object if defined, <code>null</code> otherwise
* @return - pattern formatting object if defined, {@code null} otherwise
*/
@Override
public HSSFPatternFormatting getPatternFormatting()
{
return getPatternFormatting(false);
@ -171,8 +176,9 @@ public final class HSSFConditionalFormattingRule implements ConditionalFormattin
/**
* create a new pattern formatting structure if it does not exist,
* otherwise just return existing object.
* @return - pattern formatting object, never returns <code>null</code>.
* @return - pattern formatting object, never returns {@code null}.
*/
@Override
public HSSFPatternFormatting createPatternFormatting()
{
return getPatternFormatting(true);
@ -192,8 +198,9 @@ public final class HSSFConditionalFormattingRule implements ConditionalFormattin
}
/**
* @return databar / data-bar formatting object if defined, <code>null</code> otherwise
* @return databar / data-bar formatting object if defined, {@code null} otherwise
*/
@Override
public HSSFDataBarFormatting getDataBarFormatting() {
return getDataBarFormatting(false);
}
@ -218,8 +225,9 @@ public final class HSSFConditionalFormattingRule implements ConditionalFormattin
}
/**
* @return icon / multi-state formatting object if defined, <code>null</code> otherwise
* @return icon / multi-state formatting object if defined, {@code null} otherwise
*/
@Override
public HSSFIconMultiStateFormatting getMultiStateFormatting() {
return getMultiStateFormatting(false);
}
@ -245,8 +253,9 @@ public final class HSSFConditionalFormattingRule implements ConditionalFormattin
}
/**
* @return color scale / gradient formatting object if defined, <code>null</code> otherwise
* @return color scale / gradient formatting object if defined, {@code null} otherwise
*/
@Override
public HSSFColorScaleFormatting getColorScaleFormatting() {
return getColorScaleFormatting(false);
}
@ -270,12 +279,13 @@ public final class HSSFConditionalFormattingRule implements ConditionalFormattin
/**
* always null (not a filter condition) or {@link ConditionFilterType#FILTER} if it is.
* @see org.apache.poi.ss.usermodel.ConditionalFormattingRule#getConditionFilterType()
*/
@Override
public ConditionFilterType getConditionFilterType() {
return getConditionType() == ConditionType.FILTER ? ConditionFilterType.FILTER : null;
}
@Override
public ConditionFilterData getFilterConfiguration() {
return null;
}
@ -288,11 +298,13 @@ public final class HSSFConditionalFormattingRule implements ConditionalFormattin
return cfRuleRecord.getComparisonOperation();
}
@Override
public String getFormula1()
{
return toFormulaString(cfRuleRecord.getParsedExpression1());
}
@Override
public String getFormula2() {
byte conditionType = cfRuleRecord.getConditionType();
if (conditionType == CELL_COMPARISON) {
@ -306,6 +318,7 @@ public final class HSSFConditionalFormattingRule implements ConditionalFormattin
return null;
}
@Override
public String getText() {
return null; // not available here, unless it exists and is unimplemented in cfRuleRecord
}
@ -325,6 +338,7 @@ public final class HSSFConditionalFormattingRule implements ConditionalFormattin
* Conditional format rules don't define stripes, so always 0
* @see org.apache.poi.ss.usermodel.DifferentialStyleProvider#getStripeSize()
*/
@Override
public int getStripeSize() {
return 0;
}

12
poi/src/main/java/org/apache/poi/hssf/usermodel/HSSFConditionalFormattingThreshold.java
View File

@ -31,32 +31,40 @@ public final class HSSFConditionalFormattingThreshold implements org.apache.poi.
private final HSSFSheet sheet;
private final HSSFWorkbook workbook;
protected HSSFConditionalFormattingThreshold(Threshold threshold, HSSFSheet sheet) {
HSSFConditionalFormattingThreshold(Threshold threshold, HSSFSheet sheet) {
this.threshold = threshold;
this.sheet = sheet;
this.workbook = sheet.getWorkbook();
}
protected Threshold getThreshold() {
Threshold getThreshold() {
return threshold;
}
@Override
public RangeType getRangeType() {
return RangeType.byId(threshold.getType());
}
@Override
public void setRangeType(RangeType type) {
threshold.setType((byte)type.id);
}
@Override
public String getFormula() {
return toFormulaString(threshold.getParsedExpression(), workbook);
}
@Override
public void setFormula(String formula) {
threshold.setParsedExpression(parseFormula(formula, sheet));
}
@Override
public Double getValue() {
return threshold.getValue();
}
@Override
public void setValue(Double value) {
threshold.setValue(value);
}

17
poi/src/main/java/org/apache/poi/hssf/usermodel/HSSFIconMultiStateFormatting.java
View File

@ -24,41 +24,46 @@ import org.apache.poi.hssf.record.cf.Threshold;
import org.apache.poi.ss.usermodel.ConditionalFormattingThreshold;
/**
* High level representation for Icon / Multi-State Formatting
* High level representation for Icon / Multi-State Formatting
* component of Conditional Formatting settings
*/
public final class HSSFIconMultiStateFormatting implements org.apache.poi.ss.usermodel.IconMultiStateFormatting {
private final HSSFSheet sheet;
private final CFRule12Record cfRule12Record;
private final IconMultiStateFormatting iconFormatting;
protected HSSFIconMultiStateFormatting(CFRule12Record cfRule12Record, HSSFSheet sheet) {
HSSFIconMultiStateFormatting(CFRule12Record cfRule12Record, HSSFSheet sheet) {
this.sheet = sheet;
this.cfRule12Record = cfRule12Record;
this.iconFormatting = this.cfRule12Record.getMultiStateFormatting();
this.iconFormatting = cfRule12Record.getMultiStateFormatting();
}
@Override
public IconSet getIconSet() {
return iconFormatting.getIconSet();
}
@Override
public void setIconSet(IconSet set) {
iconFormatting.setIconSet(set);
}
@Override
public boolean isIconOnly() {
return iconFormatting.isIconOnly();
}
@Override
public void setIconOnly(boolean only) {
iconFormatting.setIconOnly(only);
}
@Override
public boolean isReversed() {
return iconFormatting.isReversed();
}
@Override
public void setReversed(boolean reversed) {
iconFormatting.setReversed(reversed);
}
@Override
public HSSFConditionalFormattingThreshold[] getThresholds() {
Threshold[] t = iconFormatting.getThresholds();
HSSFConditionalFormattingThreshold[] ht = new HSSFConditionalFormattingThreshold[t.length];
@ -68,6 +73,7 @@ public final class HSSFIconMultiStateFormatting implements org.apache.poi.ss.use
return ht;
}
@Override
public void setThresholds(ConditionalFormattingThreshold[] thresholds) {
Threshold[] t = new Threshold[thresholds.length];
for (int i=0; i<t.length; i++) {
@ -76,6 +82,7 @@ public final class HSSFIconMultiStateFormatting implements org.apache.poi.ss.use
iconFormatting.setThresholds(t);
}
@Override
public HSSFConditionalFormattingThreshold createThreshold() {
return new HSSFConditionalFormattingThreshold(new IconMultiStateThreshold(), sheet);
}

8
poi/src/main/java/org/apache/poi/hssf/usermodel/HSSFWorkbookFactory.java
View File

@ -48,6 +48,7 @@ public class HSSFWorkbookFactory implements WorkbookProvider {
*
* @return The created workbook
*/
@Override
public HSSFWorkbook create() {
return new HSSFWorkbook();
}
@ -66,6 +67,7 @@ public class HSSFWorkbookFactory implements WorkbookProvider {
* Note that in order to properly release resources the
* Workbook should be closed after use.
*/
@Override
public HSSFWorkbook create(final DirectoryNode root, String password) throws IOException {
boolean passwordSet = false;
if (password != null) {
@ -93,6 +95,7 @@ public class HSSFWorkbookFactory implements WorkbookProvider {
}
@Override
@SuppressWarnings("java:S2095")
public Workbook create(File file, String password, boolean readOnly) throws IOException {
boolean passwordSet = false;
if (password != null) {
@ -104,11 +107,8 @@ public class HSSFWorkbookFactory implements WorkbookProvider {
try {
return new HSSFWorkbook(fs, true);
} catch (RuntimeException e) {
// we need to close the filesystem
// if we encounter an exception to
// not leak file handles
// we need to close the filesystem if we encounter an exception to not leak file handles
fs.close();
throw e;
}
} finally {

12
poi/src/main/java/org/apache/poi/poifs/crypt/cryptoapi/CryptoAPIDecryptor.java
View File

@ -28,7 +28,7 @@ import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.io.output.UnsynchronizedByteArrayOutputStream;
import org.apache.commons.io.input.BoundedInputStream;
import org.apache.poi.EncryptedDocumentException;
import org.apache.poi.poifs.crypt.ChunkedCipherInputStream;
import org.apache.poi.poifs.crypt.CryptoFunctions;
@ -39,11 +39,9 @@ import org.apache.poi.poifs.crypt.EncryptionVerifier;
import org.apache.poi.poifs.crypt.HashAlgorithm;
import org.apache.poi.poifs.filesystem.DirectoryNode;
import org.apache.poi.poifs.filesystem.DocumentInputStream;
import org.apache.poi.poifs.filesystem.DocumentNode;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.util.BitField;
import org.apache.poi.util.BitFieldFactory;
import org.apache.commons.io.input.BoundedInputStream;
import org.apache.poi.util.IOUtils;
import org.apache.poi.util.LittleEndian;
import org.apache.poi.util.LittleEndianInputStream;
@ -170,14 +168,10 @@ public class CryptoAPIDecryptor extends Decryptor {
*/
public POIFSFileSystem getSummaryEntries(DirectoryNode root, String encryptedStream)
throws IOException, GeneralSecurityException {
DocumentNode es = (DocumentNode) root.getEntry(encryptedStream);
UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream();
try (DocumentInputStream dis = root.createDocumentInputStream(es)) {
IOUtils.copy(dis, bos);
}
POIFSFileSystem fsOut = null;
try (
CryptoAPIDocumentInputStream sbis = new CryptoAPIDocumentInputStream(this, bos.toByteArray());
DocumentInputStream dis = root.createDocumentInputStream(root.getEntry(encryptedStream));
CryptoAPIDocumentInputStream sbis = new CryptoAPIDocumentInputStream(this, IOUtils.toByteArray(dis));
LittleEndianInputStream leis = new LittleEndianInputStream(sbis)
) {
int streamDescriptorArrayOffset = (int) leis.readUInt();

58
poi/src/main/java/org/apache/poi/poifs/macros/VBAMacroReader.java
View File

@ -68,6 +68,7 @@ import org.apache.poi.util.StringUtil;
*
* @since 3.15-beta2
*/
@SuppressWarnings("unused")
public class VBAMacroReader implements Closeable {
private static final Logger LOGGER = LogManager.getLogger(VBAMacroReader.class);
@ -667,35 +668,36 @@ public class VBAMacroReader implements Closeable {
private static String readUnicode(InputStream is) throws IOException {
//reads null-terminated unicode string
UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream();
int b0 = IOUtils.readByte(is);
int b1 = IOUtils.readByte(is);
try (UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream()) {
int b0 = IOUtils.readByte(is);
int b1 = IOUtils.readByte(is);
int read = 2;
while ((b0 + b1) != 0 && read < MAX_STRING_LENGTH) {
bos.write(b0);
bos.write(b1);
b0 = IOUtils.readByte(is);
b1 = IOUtils.readByte(is);
read += 2;
int read = 2;
while ((b0 + b1) != 0 && read < MAX_STRING_LENGTH) {
bos.write(b0);
bos.write(b1);
b0 = IOUtils.readByte(is);
b1 = IOUtils.readByte(is);
read += 2;
}
if (read >= MAX_STRING_LENGTH) {
LOGGER.atWarn().log("stopped reading unicode name after {} bytes", box(read));
}
return bos.toString(StandardCharsets.UTF_16LE);
}
if (read >= MAX_STRING_LENGTH) {
LOGGER.atWarn().log("stopped reading unicode name after {} bytes", box(read));
}
return bos.toString(StandardCharsets.UTF_16LE);
}
private static String readMBCS(int firstByte, InputStream is, Charset charset) throws IOException {
UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream();
int len = 0;
int b = firstByte;
while (b > 0 && len < MAX_STRING_LENGTH) {
++len;
bos.write(b);
b = IOUtils.readByte(is);
try (UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream()) {
int len = 0;
int b = firstByte;
while (b > 0 && len < MAX_STRING_LENGTH) {
++len;
bos.write(b);
b = IOUtils.readByte(is);
}
return bos.toString(charset);
}
return bos.toString(charset);
}
/**
@ -792,9 +794,7 @@ public class VBAMacroReader implements Closeable {
*/
private static byte[] findCompressedStreamWBruteForce(InputStream is) throws IOException {
//buffer to memory for multiple tries
UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream();
IOUtils.copy(is, bos);
byte[] compressed = bos.toByteArray();
byte[] compressed = IOUtils.toByteArray(is);
byte[] decompressed = null;
for (int i = 0; i < compressed.length; i++) {
if (compressed[i] == 0x01 && i < compressed.length-1) {
@ -821,12 +821,10 @@ public class VBAMacroReader implements Closeable {
}
private static byte[] tryToDecompress(InputStream is) {
UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream();
try {
IOUtils.copy(new RLEDecompressingInputStream(is), bos);
try (RLEDecompressingInputStream ris = new RLEDecompressingInputStream(is)) {
return IOUtils.toByteArray(ris);
} catch (IllegalArgumentException | IOException | IllegalStateException e){
return null;
}
return bos.toByteArray();
}
}

7
poi/src/main/java/org/apache/poi/ss/extractor/EmbeddedExtractor.java
View File

@ -162,14 +162,13 @@ public class EmbeddedExtractor implements Iterable<EmbeddedExtractor> {
protected EmbeddedData extract(DirectoryNode dn) throws IOException {
assert(canExtract(dn));
UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream(20000);
try (POIFSFileSystem dest = new POIFSFileSystem()) {
try (UnsynchronizedByteArrayOutputStream bos = new UnsynchronizedByteArrayOutputStream(20000);
POIFSFileSystem dest = new POIFSFileSystem()) {
copyNodes(dn, dest.getRoot());
// start with a reasonable big size
dest.writeFilesystem(bos);
return new EmbeddedData(dn.getName(), bos.toByteArray(), CONTENT_TYPE_BYTES);
}
return new EmbeddedData(dn.getName(), bos.toByteArray(), CONTENT_TYPE_BYTES);
}
protected EmbeddedData extract(Picture source) throws IOException {

38
poi/src/main/java/org/apache/poi/ss/usermodel/ConditionalFormattingThreshold.java
View File

@ -27,7 +27,7 @@ package org.apache.poi.ss.usermodel;
* icon and which Yellow or Red.</p>
*/
public interface ConditionalFormattingThreshold {
public enum RangeType {
enum RangeType {
/** Number / Parameter */
NUMBER(1, "num"),
/** The minimum value from the range */
@ -41,16 +41,16 @@ public interface ConditionalFormattingThreshold {
UNALLOCATED(6, null),
/** Formula result */
FORMULA(7, "formula");
/** Numeric ID of the type */
public final int id;
/** Name (system) of the type */
public final String name;
public String toString() {
return id + " - " + name;
}
public static RangeType byId(int id) {
return values()[id-1]; // 1-based IDs
}
@ -60,51 +60,51 @@ public interface ConditionalFormattingThreshold {
}
return null;
}
private RangeType(int id, String name) {
RangeType(int id, String name) {
this.id = id; this.name = name;
}
}
/**
* Get the Range Type used
*/
RangeType getRangeType();
/**
* Changes the Range Type used
*
*
* <p>If you change the range type, you need to
* ensure that the Formula and Value parameters
* are compatible with it before saving</p>
*/
void setRangeType(RangeType type);
/**
* Formula to use to calculate the threshold,
* or <code>null</code> if no formula
* or {@code null} if no formula
*/
String getFormula();
/**
* Sets the formula used to calculate the threshold,
* or unsets it if <code>null</code> is given.
* or unsets it if {@code null} is given.
*/
void setFormula(String formula);
/**
* Gets the value used for the threshold, or
* <code>null</code> if there isn't one.
* Gets the value used for the threshold, or
* {@code null} if there isn't one.
*/
Double getValue();
/**
* Sets the value used for the threshold.
* <p>If the type is {@link RangeType#PERCENT} or
* Sets the value used for the threshold.
* <p>If the type is {@link RangeType#PERCENT} or
* {@link RangeType#PERCENTILE} it must be between 0 and 100.
* <p>If the type is {@link RangeType#MIN} or {@link RangeType#MAX}
* or {@link RangeType#FORMULA} it shouldn't be set.
* <p>Use <code>null</code> to unset
* <p>Use {@code null} to unset
*/
void setValue(Double value);
}

1
poi/src/main/java/org/apache/poi/util/GenericRecordJsonWriter.java
View File

@ -265,6 +265,7 @@ public class GenericRecordJsonWriter implements Closeable {
return true;
}
@SuppressWarnings("java:S3516")
protected boolean printNumber(String name, Object o) {
Number n = (Number)o;
printName(name);

36
poi/src/main/java/org/apache/poi/util/IOUtils.java
View File

@ -178,29 +178,29 @@ public final class IOUtils {
}
final int len = Math.min(length, maxLength);
UnsynchronizedByteArrayOutputStream baos = new UnsynchronizedByteArrayOutputStream(len == Integer.MAX_VALUE ? 4096 : len);
try (UnsynchronizedByteArrayOutputStream baos = new UnsynchronizedByteArrayOutputStream(len == Integer.MAX_VALUE ? 4096 : len)) {
byte[] buffer = new byte[4096];
int totalBytes = 0, readBytes;
do {
readBytes = stream.read(buffer, 0, Math.min(buffer.length, len - totalBytes));
totalBytes += Math.max(readBytes, 0);
if (readBytes > 0) {
baos.write(buffer, 0, readBytes);
}
byte[] buffer = new byte[4096];
int totalBytes = 0, readBytes;
do {
readBytes = stream.read(buffer, 0, Math.min(buffer.length, len-totalBytes));
totalBytes += Math.max(readBytes,0);
if (readBytes > 0) {
baos.write(buffer, 0, readBytes);
checkByteSizeLimit(totalBytes);
} while (totalBytes < len && readBytes > -1);
if (maxLength != Integer.MAX_VALUE && totalBytes == maxLength) {
throw new IOException("MaxLength (" + maxLength + ") reached - stream seems to be invalid.");
}
checkByteSizeLimit(totalBytes);
} while (totalBytes < len && readBytes > -1);
if (len != Integer.MAX_VALUE && totalBytes < len) {
throw new EOFException("unexpected EOF - expected len: " + len + " - actual len: " + totalBytes);
}
if (maxLength != Integer.MAX_VALUE && totalBytes == maxLength) {
throw new IOException("MaxLength ("+maxLength+") reached - stream seems to be invalid.");
return baos.toByteArray();
}
if (len != Integer.MAX_VALUE && totalBytes < len) {
throw new EOFException("unexpected EOF - expected len: "+len+" - actual len: "+totalBytes);
}
return baos.toByteArray();
}
private static void checkLength(long length, int maxLength) {

65
poi/src/test/java/org/apache/poi/POITestCase.java
View File

@ -25,8 +25,6 @@ import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static org.junit.jupiter.api.Assumptions.assumeTrue;
import java.io.File;
import java.lang.reflect.Field;
@ -47,6 +45,7 @@ import org.mockito.internal.matchers.apachecommons.ReflectionEquals;
* Util class for POI JUnit TestCases, which provide additional features
*/
@Internal
@SuppressWarnings("java:S2187")
public final class POITestCase {
private POITestCase() {
@ -141,68 +140,6 @@ public final class POITestCase {
assertTrue(new ReflectionEquals(expected, "$jacocoData").matches(actual));
}
/**
* Rather than adding {@literal @}Ignore to known-failing tests,
* write the test so that it notifies us if it starts passing.
* This is useful for closing related or forgotten bugs.
*
* An Example:
* <code><pre>
* public static int add(int a, int b) {
* // a known bug in behavior that has not been fixed yet
* raise UnsupportedOperationException("add");
* }
*
* {@literal @}Test
* void knownFailingUnitTest() {
* try {
* assertEquals(2, add(1,1));
* // this test fails because the assumption that this bug had not been fixed is false
* testPassesNow(12345);
* } catch (UnsupportedOperationException e) {
* // test is skipped because the assumption that this bug had not been fixed is true
* skipTest(e);
* }
* }
*
* Once passing, this unit test can be rewritten as:
* {@literal @}Test
* void knownPassingUnitTest() {
* assertEquals(2, add(1,1));
* }
*
* If you have a better idea how to simplify test code while still notifying
* us when a previous known-failing test now passes, please improve these.
* As a bonus, a known-failing test that fails should not be counted as a
* passing test.
*
* One possible alternative is to expect the known exception, but without
* a clear message that it is a good thing to no longer get the expected
* exception once the test passes.
* {@literal @}Test(expected=UnsupportedOperationException.class)
* void knownFailingUnitTest() {
* assertEquals(2, add(1,1));
* }
*
* @param e the exception that was caught that will no longer
* be raised when the bug is fixed
*/
public static void skipTest(Throwable e) {
assumeTrue(e != null, "This test currently fails with");
}
/**
* @see #skipTest(Throwable)
*
* @param bug the bug number corresponding to a known bug in bugzilla
*/
public static void testPassesNow(int bug) {
fail("This test passes now. Please update the unit test and bug " + bug + ".");
}
public static void assertBetween(String message, int value, int min, int max) {
assertTrue(min <= value, message + ": " + value + " is less than the minimum value of " + min);
assertTrue(value <= max, message + ": " + value + " is greater than the maximum value of " + max);
}
/**
* Ensures that the temporary directory is defined and exists and

8
poi/src/test/java/org/apache/poi/ss/usermodel/BaseTestBugzillaIssues.java
View File

@ -1382,6 +1382,7 @@ public abstract class BaseTestBugzillaIssues {
}
@Test
@SuppressWarnings("java:S2699")
void test58896() throws IOException {
final int nrows = 160;
final int ncols = 139;
@ -1493,8 +1494,8 @@ public abstract class BaseTestBugzillaIssues {
// *******************************
// First cell of array formula, OK
int rowId = 0;
int cellId = 1;
final int rowId = 0;
final int cellId = 1;
Row row = sheet.getRow(rowId);
Cell cell = row.getCell(cellId);
@ -1507,9 +1508,6 @@ public abstract class BaseTestBugzillaIssues {
// *******************************
// Second cell of array formula, NOT OK for xlsx files
rowId = 1;
cellId = 1;
row = sheet.getRow(rowId);
cell = row.getCell(cellId);
assertEquals("A1", cell.getCellFormula());

11
poi/src/test/java/org/apache/poi/ss/usermodel/BaseTestSheet.java
View File

@ -17,7 +17,6 @@
package org.apache.poi.ss.usermodel;
import static org.apache.poi.POITestCase.assertBetween;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
@ -50,8 +49,7 @@ import org.junit.jupiter.api.Test;
/**
* Common superclass for testing {@link org.apache.poi.hssf.usermodel.HSSFCell},
* {@link org.apache.poi.xssf.usermodel.XSSFCell} and
* {@link org.apache.poi.xssf.streaming.SXSSFCell}
* XSSFCell and SXSSFCell
*/
public abstract class BaseTestSheet {
private static final int ROW_COUNT = 40000;
@ -430,7 +428,7 @@ public abstract class BaseTestSheet {
assertCollectionEquals(mergedRegions.values(), sheet.getMergedRegions());
Collection<Integer> removed = Arrays.asList(0, 2, 3, 6, 8);
mergedRegions.keySet().removeAll(removed);
removed.forEach(mergedRegions.keySet()::remove);
sheet.removeMergedRegions(removed);
assertCollectionEquals(mergedRegions.values(), sheet.getMergedRegions());
}
@ -1364,4 +1362,9 @@ public abstract class BaseTestSheet {
assertBetween("Date column width", s.getColumnWidth(1), 4750, 7300);
}
}
private static void assertBetween(String message, int value, int min, int max) {
assertTrue(min <= value, message + ": " + value + " is less than the minimum value of " + min);
assertTrue(value <= max, message + ": " + value + " is greater than the maximum value of " + max);
}
}

941
poi/src/test/java/org/apache/poi/ss/usermodel/BaseTestSheetShiftRows.java
View File

File diff suppressed because it is too large Load Diff

2
poi/src/test/java/org/apache/poi/ss/usermodel/BaseTestWorkbook.java
View File

@ -724,7 +724,7 @@ public abstract class BaseTestWorkbook {
}
@Test
void changeSheetNameWithSharedFormulas() throws IOException {
protected void changeSheetNameWithSharedFormulas() throws IOException {
String sampleFile = "shared_formulas.xls" + (getClass().getName().contains("xssf") ? "x" : "");
try (Workbook wb = _testDataProvider.openSampleWorkbook(sampleFile)) {