IntelliJ warnings/suggestions git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@1808622 13f79535-47bb-0310-9956-ffa450edef68tags/REL_4_0_0_FINAL
@@ -23,6 +23,7 @@ import java.io.InputStream; | |||
import org.apache.poi.POIXMLDocument; | |||
import org.apache.poi.poifs.crypt.Decryptor; | |||
import org.apache.poi.poifs.filesystem.FileMagic; | |||
import org.apache.poi.poifs.filesystem.POIFSFileSystem; | |||
public final class POIXMLDocumentHandler { | |||
@@ -35,14 +36,11 @@ public final class POIXMLDocumentHandler { | |||
} | |||
protected static boolean isEncrypted(InputStream stream) throws IOException { | |||
if (POIFSFileSystem.hasPOIFSHeader(stream)) { | |||
POIFSFileSystem poifs = new POIFSFileSystem(stream); | |||
try { | |||
if (FileMagic.valueOf(stream) == FileMagic.OLE2) { | |||
try (POIFSFileSystem poifs = new POIFSFileSystem(stream)) { | |||
if (poifs.getRoot().hasEntry(Decryptor.DEFAULT_POIFS_ENTRY)) { | |||
return true; | |||
} | |||
} finally { | |||
poifs.close(); | |||
} | |||
throw new IOException("Wrong file format or file extension for OO XML file"); | |||
} |
@@ -40,10 +40,7 @@ import org.apache.poi.hssf.record.OldSheetRecord; | |||
import org.apache.poi.hssf.record.OldStringRecord; | |||
import org.apache.poi.hssf.record.RKRecord; | |||
import org.apache.poi.hssf.record.RecordInputStream; | |||
import org.apache.poi.poifs.filesystem.DirectoryNode; | |||
import org.apache.poi.poifs.filesystem.DocumentNode; | |||
import org.apache.poi.poifs.filesystem.NPOIFSFileSystem; | |||
import org.apache.poi.poifs.filesystem.NotOLE2FileException; | |||
import org.apache.poi.poifs.filesystem.*; | |||
import org.apache.poi.ss.usermodel.CellType; | |||
import org.apache.poi.util.IOUtils; | |||
@@ -80,16 +77,8 @@ public class OldExcelExtractor implements Closeable { | |||
open(poifs); | |||
toClose = poifs; | |||
return; | |||
} catch (OldExcelFormatException e) { | |||
} catch (OldExcelFormatException | NotOLE2FileException e) { | |||
// will be handled by workaround below | |||
} catch (NotOLE2FileException e) { | |||
// will be handled by workaround below | |||
} catch (IOException e) { | |||
// ensure streams are closed correctly | |||
throw e; | |||
} catch (RuntimeException e) { | |||
// ensure streams are closed correctly | |||
throw e; | |||
} finally { | |||
if (toClose == null) { | |||
IOUtils.closeQuietly(poifs); | |||
@@ -100,12 +89,7 @@ public class OldExcelExtractor implements Closeable { | |||
FileInputStream biffStream = new FileInputStream(f); // NOSONAR | |||
try { | |||
open(biffStream); | |||
} catch (IOException e) { | |||
// ensure that the stream is properly closed here if an Exception | |||
// is thrown while opening | |||
biffStream.close(); | |||
throw e; | |||
} catch (RuntimeException e) { | |||
} catch (IOException | RuntimeException e) { | |||
// ensure that the stream is properly closed here if an Exception | |||
// is thrown while opening | |||
biffStream.close(); | |||
@@ -126,12 +110,9 @@ public class OldExcelExtractor implements Closeable { | |||
? (BufferedInputStream)biffStream | |||
: new BufferedInputStream(biffStream, 8); | |||
if (NPOIFSFileSystem.hasPOIFSHeader(bis)) { | |||
NPOIFSFileSystem poifs = new NPOIFSFileSystem(bis); | |||
try { | |||
if (FileMagic.valueOf(bis) == FileMagic.OLE2) { | |||
try (NPOIFSFileSystem poifs = new NPOIFSFileSystem(bis)) { | |||
open(poifs); | |||
} finally { | |||
poifs.close(); | |||
} | |||
} else { | |||
ris = new RecordInputStream(bis); |
@@ -114,7 +114,7 @@ public class DirectoryNode | |||
while (iter.hasNext()) | |||
{ | |||
Property child = iter.next(); | |||
Entry childNode = null; | |||
Entry childNode; | |||
if (child.isDirectory()) | |||
{ | |||
@@ -586,16 +586,11 @@ public class DirectoryNode | |||
* @return an Iterator; may not be null, but may have an empty | |||
* back end store | |||
*/ | |||
public Iterator<Object> getViewableIterator() | |||
{ | |||
public Iterator<Object> getViewableIterator() { | |||
List<Object> components = new ArrayList<>(); | |||
components.add(getProperty()); | |||
Iterator<Entry> iter = _entries.iterator(); | |||
while (iter.hasNext()) | |||
{ | |||
components.add(iter.next()); | |||
} | |||
components.addAll(_entries); | |||
return components.iterator(); | |||
} | |||
@@ -19,7 +19,6 @@ | |||
package org.apache.poi.poifs.filesystem; | |||
import java.io.ByteArrayInputStream; | |||
import java.io.Closeable; | |||
import java.io.File; | |||
import java.io.FileInputStream; | |||
@@ -57,7 +56,6 @@ import org.apache.poi.util.IOUtils; | |||
import org.apache.poi.util.Internal; | |||
import org.apache.poi.util.POILogFactory; | |||
import org.apache.poi.util.POILogger; | |||
import org.apache.poi.util.Removal; | |||
/** | |||
* <p>This is the main class of the POIFS system; it manages the entire | |||
@@ -342,42 +340,6 @@ public class NPOIFSFileSystem extends BlockStore | |||
} | |||
} | |||
/** | |||
* Checks that the supplied InputStream (which MUST | |||
* support mark and reset) has a POIFS (OLE2) header at the start of it. | |||
* If unsure if your InputStream does support mark / reset, | |||
* use {@link FileMagic#prepareToCheckMagic(InputStream)} to wrap it and make | |||
* sure to always use that, and not the original! | |||
* | |||
* After the method call, the InputStream is at the | |||
* same position as of the time of entering the method. | |||
* | |||
* @param inp An InputStream which supports mark/reset | |||
* | |||
* @deprecated in 3.17-beta2, use {@link FileMagic#valueOf(InputStream)} == {@link FileMagic#OLE2} instead | |||
*/ | |||
@Deprecated | |||
@Removal(version="4.0") | |||
public static boolean hasPOIFSHeader(InputStream inp) throws IOException { | |||
return FileMagic.valueOf(inp) == FileMagic.OLE2; | |||
} | |||
/** | |||
* Checks if the supplied first 8 bytes of a stream / file | |||
* has a POIFS (OLE2) header. | |||
* | |||
* @deprecated in 3.17-beta2, use {@link FileMagic#valueOf(InputStream)} == {@link FileMagic#OLE2} instead | |||
*/ | |||
@Deprecated | |||
@Removal(version="4.0") | |||
public static boolean hasPOIFSHeader(byte[] header8Bytes) { | |||
try { | |||
return hasPOIFSHeader(new ByteArrayInputStream(header8Bytes)); | |||
} catch (IOException e) { | |||
throw new RuntimeException("invalid header check", e); | |||
} | |||
} | |||
/** | |||
* Read and process the PropertiesTable and the | |||
* FAT / XFAT blocks, so that we're ready to | |||
@@ -686,7 +648,6 @@ public class NPOIFSFileSystem extends BlockStore | |||
* | |||
* @exception IOException | |||
*/ | |||
public DocumentEntry createDocument(final String name, final int size, | |||
final POIFSWriterListener writer) | |||
throws IOException | |||
@@ -752,8 +713,7 @@ public class NPOIFSFileSystem extends BlockStore | |||
* | |||
* @exception IOException thrown on errors writing to the stream | |||
*/ | |||
public void writeFilesystem() throws IOException | |||
{ | |||
public void writeFilesystem() throws IOException { | |||
if(_data instanceof FileBackedDataSource) { | |||
// Good, correct type | |||
} else { | |||
@@ -779,10 +739,7 @@ public class NPOIFSFileSystem extends BlockStore | |||
* | |||
* @exception IOException thrown on errors writing to the stream | |||
*/ | |||
public void writeFilesystem(final OutputStream stream) | |||
throws IOException | |||
{ | |||
public void writeFilesystem(final OutputStream stream) throws IOException { | |||
// Have the datasource updated | |||
syncWithDataSource(); | |||
@@ -838,31 +795,19 @@ public class NPOIFSFileSystem extends BlockStore | |||
* | |||
* @exception IOException | |||
*/ | |||
public static void main(String args[]) | |||
throws IOException | |||
{ | |||
if (args.length != 2) | |||
{ | |||
public static void main(String args[]) throws IOException { | |||
if (args.length != 2) { | |||
System.err.println( | |||
"two arguments required: input filename and output filename"); | |||
System.exit(1); | |||
} | |||
FileInputStream istream = new FileInputStream(args[ 0 ]); | |||
try { | |||
FileOutputStream ostream = new FileOutputStream(args[ 1 ]); | |||
try { | |||
NPOIFSFileSystem fs = new NPOIFSFileSystem(istream); | |||
try { | |||
try (FileInputStream istream = new FileInputStream(args[0])) { | |||
try (FileOutputStream ostream = new FileOutputStream(args[1])) { | |||
try (NPOIFSFileSystem fs = new NPOIFSFileSystem(istream)) { | |||
fs.writeFilesystem(ostream); | |||
} finally { | |||
fs.close(); | |||
} | |||
} finally { | |||
ostream.close(); | |||
} | |||
} finally { | |||
istream.close(); | |||
} | |||
} | |||
@@ -871,8 +816,7 @@ public class NPOIFSFileSystem extends BlockStore | |||
* | |||
* @return the root entry | |||
*/ | |||
public DirectoryNode getRoot() | |||
{ | |||
public DirectoryNode getRoot() { | |||
if (_root == null) { | |||
_root = new DirectoryNode(_property_table.getRoot(), this, null); | |||
} | |||
@@ -889,11 +833,8 @@ public class NPOIFSFileSystem extends BlockStore | |||
* @exception IOException if the document does not exist or the | |||
* name is that of a DirectoryEntry | |||
*/ | |||
public DocumentInputStream createDocumentInputStream( | |||
final String documentName) | |||
throws IOException | |||
{ | |||
final String documentName) throws IOException { | |||
return getRoot().createDocumentInputStream(documentName); | |||
} | |||
@@ -902,8 +843,7 @@ public class NPOIFSFileSystem extends BlockStore | |||
* | |||
* @param entry to be removed | |||
*/ | |||
void remove(EntryNode entry) throws IOException | |||
{ | |||
void remove(EntryNode entry) throws IOException { | |||
// If it's a document, free the blocks | |||
if (entry instanceof DocumentEntry) { | |||
NPOIFSDocument doc = new NPOIFSDocument((DocumentProperty)entry.getProperty(), this); | |||
@@ -922,13 +862,11 @@ public class NPOIFSFileSystem extends BlockStore | |||
* | |||
* @return an array of Object; may not be null, but may be empty | |||
*/ | |||
public Object [] getViewableArray() | |||
{ | |||
if (preferArray()) | |||
{ | |||
public Object [] getViewableArray() { | |||
if (preferArray()) { | |||
return getRoot().getViewableArray(); | |||
} | |||
return new Object[ 0 ]; | |||
} | |||
@@ -940,12 +878,11 @@ public class NPOIFSFileSystem extends BlockStore | |||
* back end store | |||
*/ | |||
public Iterator<Object> getViewableIterator() | |||
{ | |||
if (!preferArray()) | |||
{ | |||
public Iterator<Object> getViewableIterator() { | |||
if (!preferArray()) { | |||
return getRoot().getViewableIterator(); | |||
} | |||
return Collections.emptyList().iterator(); | |||
} | |||
@@ -957,8 +894,7 @@ public class NPOIFSFileSystem extends BlockStore | |||
* a viewer should call getViewableIterator | |||
*/ | |||
public boolean preferArray() | |||
{ | |||
public boolean preferArray() { | |||
return getRoot().preferArray(); | |||
} | |||
@@ -969,8 +905,7 @@ public class NPOIFSFileSystem extends BlockStore | |||
* @return short description | |||
*/ | |||
public String getShortDescription() | |||
{ | |||
public String getShortDescription() { | |||
return "POIFS FileSystem"; | |||
} | |||
@@ -170,23 +170,22 @@ public class NPOIFSMiniStore extends BlockStore | |||
// First up, do we have any spare ones? | |||
int offset = 0; | |||
for(int i=0; i<_sbat_blocks.size(); i++) { | |||
// Check this one | |||
BATBlock sbat = _sbat_blocks.get(i); | |||
if(sbat.hasFreeSectors()) { | |||
// Claim one of them and return it | |||
for(int j=0; j<sectorsPerSBAT; j++) { | |||
int sbatValue = sbat.getValueAt(j); | |||
if(sbatValue == POIFSConstants.UNUSED_BLOCK) { | |||
// Bingo | |||
return offset + j; | |||
for (BATBlock sbat : _sbat_blocks) { | |||
// Check this one | |||
if (sbat.hasFreeSectors()) { | |||
// Claim one of them and return it | |||
for (int j = 0; j < sectorsPerSBAT; j++) { | |||
int sbatValue = sbat.getValueAt(j); | |||
if (sbatValue == POIFSConstants.UNUSED_BLOCK) { | |||
// Bingo | |||
return offset + j; | |||
} | |||
} | |||
} | |||
} | |||
// Move onto the next SBAT | |||
offset += sectorsPerSBAT; | |||
} | |||
} | |||
// Move onto the next SBAT | |||
offset += sectorsPerSBAT; | |||
} | |||
// If we get here, then there aren't any | |||
// free sectors in any of the SBATs |
@@ -384,11 +384,8 @@ public final class OPOIFSDocument implements BATManaged, BlockWritable, POIFSVie | |||
* @return short description | |||
*/ | |||
public String getShortDescription() { | |||
StringBuffer buffer = new StringBuffer(); | |||
buffer.append("Document: \"").append(_property.getName()).append("\""); | |||
buffer.append(" size = ").append(getSize()); | |||
return buffer.toString(); | |||
return "Document: \"" + _property.getName() + "\"" + | |||
" size = " + getSize(); | |||
} | |||
/* ********** END begin implementation of POIFSViewable ********** */ | |||
@@ -529,8 +526,8 @@ public final class OPOIFSDocument implements BATManaged, BlockWritable, POIFSVie | |||
dstream.writeFiller(countBlocks() * _bigBlockSize.getBigBlockSize(), | |||
DocumentBlock.getFillByte()); | |||
} else { | |||
for (int k = 0; k < bigBlocks.length; k++) { | |||
bigBlocks[k].writeBlocks(stream); | |||
for (DocumentBlock bigBlock : bigBlocks) { | |||
bigBlock.writeBlocks(stream); | |||
} | |||
} | |||
} |
@@ -49,7 +49,6 @@ import org.apache.poi.poifs.storage.SmallBlockTableWriter; | |||
import org.apache.poi.util.CloseIgnoringInputStream; | |||
import org.apache.poi.util.POILogFactory; | |||
import org.apache.poi.util.POILogger; | |||
import org.apache.poi.util.Removal; | |||
/** | |||
* <p>This is the main class of the POIFS system; it manages the entire | |||
@@ -196,38 +195,6 @@ public class OPOIFSFileSystem | |||
} | |||
} | |||
/** | |||
* Checks that the supplied InputStream (which MUST | |||
* support mark and reset) has a POIFS (OLE2) header at the start of it. | |||
* If unsure if your InputStream does support mark / reset, | |||
* use {@link FileMagic#prepareToCheckMagic(InputStream)} to wrap it and make | |||
* sure to always use that, and not the original! | |||
* | |||
* After the method call, the InputStream is at the | |||
* same position as of the time of entering the method. | |||
* | |||
* @param inp An InputStream which supports either mark/reset | |||
* | |||
* @deprecated in 3.17-beta2, use {@link FileMagic#valueOf(InputStream)} == {@link FileMagic#OLE2} instead | |||
*/ | |||
@Deprecated | |||
@Removal(version="4.0") | |||
public static boolean hasPOIFSHeader(InputStream inp) throws IOException { | |||
return NPOIFSFileSystem.hasPOIFSHeader(inp); | |||
} | |||
/** | |||
* Checks if the supplied first 8 bytes of a stream / file | |||
* has a POIFS (OLE2) header. | |||
* | |||
* @deprecated in 3.17-beta2, use {@link FileMagic#valueOf(InputStream)} == {@link FileMagic#OLE2} instead | |||
*/ | |||
@Deprecated | |||
@Removal(version="4.0") | |||
public static boolean hasPOIFSHeader(byte[] header8Bytes) { | |||
return NPOIFSFileSystem.hasPOIFSHeader(header8Bytes); | |||
} | |||
/** | |||
* Create a new document to be added to the root directory | |||
* | |||
@@ -259,7 +226,6 @@ public class OPOIFSFileSystem | |||
* | |||
* @exception IOException | |||
*/ | |||
public DocumentEntry createDocument(final String name, final int size, | |||
final POIFSWriterListener writer) | |||
throws IOException | |||
@@ -325,17 +291,13 @@ public class OPOIFSFileSystem | |||
BATManaged bmo = ( BATManaged ) iter.next(); | |||
int block_count = bmo.countBlocks(); | |||
if (block_count != 0) | |||
{ | |||
if (block_count != 0) { | |||
bmo.setStartBlock(bat.allocateSpace(block_count)); | |||
} | |||
else | |||
{ | |||
} /*else { | |||
// Either the BATManaged object is empty or its data | |||
// is composed of SmallBlocks; in either case, | |||
// allocating space in the BAT is inappropriate | |||
} | |||
}*/ | |||
} | |||
// allocate space for the block allocation table and take its | |||
@@ -370,10 +332,7 @@ public class OPOIFSFileSystem | |||
writers.add(sbtw); | |||
writers.add(sbtw.getSBAT()); | |||
writers.add(bat); | |||
for (int j = 0; j < xbat_blocks.length; j++) | |||
{ | |||
writers.add(xbat_blocks[ j ]); | |||
} | |||
Collections.addAll(writers, xbat_blocks); | |||
// now, write everything out | |||
iter = writers.iterator(); | |||
@@ -393,7 +352,6 @@ public class OPOIFSFileSystem | |||
* | |||
* @exception IOException | |||
*/ | |||
public static void main(String args[]) | |||
throws IOException | |||
{ | |||
@@ -513,7 +471,7 @@ public class OPOIFSFileSystem | |||
{ | |||
int startBlock = property.getStartBlock(); | |||
int size = property.getSize(); | |||
OPOIFSDocument document = null; | |||
OPOIFSDocument document; | |||
if (property.shouldUseSmallBlocks()) | |||
{ |
@@ -123,18 +123,11 @@ public class POIFSFileSystem | |||
* @return The created and opened {@link POIFSFileSystem} | |||
*/ | |||
public static POIFSFileSystem create(File file) throws IOException { | |||
// TODO Make this nicer! | |||
// Create a new empty POIFS in the file | |||
POIFSFileSystem tmp = new POIFSFileSystem(); | |||
try { | |||
OutputStream out = new FileOutputStream(file); | |||
try { | |||
try (POIFSFileSystem tmp = new POIFSFileSystem()) { | |||
try (OutputStream out = new FileOutputStream(file)) { | |||
tmp.writeFilesystem(out); | |||
} finally { | |||
out.close(); | |||
} | |||
} finally { | |||
tmp.close(); | |||
} | |||
// Open it up again backed by the file |
@@ -35,8 +35,8 @@ import org.apache.commons.math3.linear.MatrixUtils; | |||
public abstract class MatrixFunction implements Function{ | |||
public static void checkValues(double[] results) throws EvaluationException { | |||
for (int idx = 0; idx < results.length; idx++) { | |||
if (Double.isNaN(results[idx]) || Double.isInfinite(results[idx])) { | |||
for (double result : results) { | |||
if (Double.isNaN(result) || Double.isInfinite(result)) { | |||
throw new EvaluationException(ErrorEval.NUM_ERROR); | |||
} | |||
} | |||
@@ -56,15 +56,15 @@ public abstract class MatrixFunction implements Function{ | |||
} | |||
double[][] matrix = new double[rows][cols]; | |||
for (int idx = 0; idx < vector.length; idx++) { | |||
for (double aVector : vector) { | |||
if (j < matrix.length) { | |||
if (i == matrix[0].length) { | |||
i = 0; | |||
j++; | |||
} | |||
matrix[j][i++] = vector[idx]; | |||
} | |||
matrix[j][i++] = aVector; | |||
} | |||
} | |||
return matrix; | |||
@@ -79,10 +79,10 @@ public abstract class MatrixFunction implements Function{ | |||
} | |||
double[] vector = new double[matrix.length * matrix[0].length]; | |||
for (int j = 0; j < matrix.length; j++) { | |||
for (double[] aMatrix : matrix) { | |||
for (int i = 0; i < matrix[0].length; i++) { | |||
vector[idx++] = matrix[j][i]; | |||
vector[idx++] = aMatrix[i]; | |||
} | |||
} | |||
return vector; | |||
@@ -96,8 +96,8 @@ public abstract class MatrixFunction implements Function{ | |||
@Override | |||
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0) { | |||
if (arg0 instanceof AreaEval) { | |||
double result[] = null, resultArray[][]; | |||
int width = 1, height = 1; | |||
double result[], resultArray[][]; | |||
int width, height; | |||
try { | |||
double values[] = collectValues(arg0); | |||
@@ -130,7 +130,7 @@ public abstract class MatrixFunction implements Function{ | |||
} | |||
} | |||
else { | |||
double result[][] = null; | |||
double result[][]; | |||
try { | |||
double value = NumericFunction.singleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex); | |||
double temp[][] = {{value}}; | |||
@@ -157,7 +157,7 @@ public abstract class MatrixFunction implements Function{ | |||
@Override | |||
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1) { | |||
double result[]; | |||
int width = 1, height = 1; | |||
int width, height; | |||
try { | |||
double array0[][], array1[][], resultArray[][]; |
@@ -31,13 +31,10 @@ public class SLCommonUtils { | |||
/** a generic way to open a sample slideshow document **/ | |||
public static SlideShow<?,?> openSampleSlideshow(String sampleName) throws IOException { | |||
InputStream is = _slTests.openResourceAsStream(sampleName); | |||
try { | |||
try (InputStream is = _slTests.openResourceAsStream(sampleName)) { | |||
return SlideShowFactory.create(is); | |||
} catch (Exception e) { | |||
throw new RuntimeException(e); | |||
} finally { | |||
is.close(); | |||
} | |||
} | |||
@@ -50,8 +50,8 @@ public class TestOfficeXMLException extends TestCase { | |||
assertContains(e.getMessage(), "You are calling the part of POI that deals with OLE2 Office Documents"); | |||
} | |||
} | |||
public void test2003XMLException() throws IOException | |||
{ | |||
public void test2003XMLException() throws IOException { | |||
InputStream in = openSampleStream("SampleSS.xml"); | |||
try { | |||
@@ -87,18 +87,9 @@ public class TestOfficeXMLException extends TestCase { | |||
} | |||
private void confirmIsPOIFS(String sampleFileName, boolean expectedResult) throws IOException { | |||
InputStream in = FileMagic.prepareToCheckMagic(openSampleStream(sampleFileName)); | |||
try { | |||
boolean actualResult; | |||
try { | |||
actualResult = POIFSFileSystem.hasPOIFSHeader(in); | |||
} catch (IOException e) { | |||
throw new RuntimeException(e); | |||
} | |||
assertEquals(expectedResult, actualResult); | |||
} finally { | |||
in.close(); | |||
} | |||
try (InputStream in = FileMagic.prepareToCheckMagic(openSampleStream(sampleFileName))) { | |||
assertEquals(expectedResult, FileMagic.valueOf(in) == FileMagic.OLE2); | |||
} | |||
} | |||
public void testFileCorruption() throws Exception { | |||
@@ -109,11 +100,12 @@ public class TestOfficeXMLException extends TestCase { | |||
// detect header | |||
InputStream in = FileMagic.prepareToCheckMagic(testInput); | |||
assertFalse(POIFSFileSystem.hasPOIFSHeader(in)); | |||
assertFalse(FileMagic.valueOf(in) == FileMagic.OLE2); | |||
// check if InputStream is still intact | |||
byte[] test = new byte[3]; | |||
in.read(test); | |||
assertEquals(3, in.read(test)); | |||
assertTrue(Arrays.equals(testData, test)); | |||
assertEquals(-1, in.read()); | |||
} | |||
@@ -127,11 +119,12 @@ public class TestOfficeXMLException extends TestCase { | |||
// detect header | |||
InputStream in = FileMagic.prepareToCheckMagic(testInput); | |||
assertFalse(OPOIFSFileSystem.hasPOIFSHeader(in)); | |||
assertFalse(FileMagic.valueOf(in) == FileMagic.OLE2); | |||
assertEquals(FileMagic.UNKNOWN, FileMagic.valueOf(in)); | |||
// check if InputStream is still intact | |||
byte[] test = new byte[3]; | |||
in.read(test); | |||
assertEquals(3, in.read(test)); | |||
assertTrue(Arrays.equals(testData, test)); | |||
assertEquals(-1, in.read()); | |||
} |