package org.apache.poi.hssf.record.aggregates;
import java.util.Iterator;
+import java.util.NoSuchElementException;
import org.apache.poi.hssf.model.RecordStream;
import org.apache.poi.hssf.record.BlankRecord;
}
public CellValueRecordInterface next() {
- if (!hasNext())
- throw new IndexOutOfBoundsException("iterator has no next");
+ if (!hasNext()) {
+ throw new NoSuchElementException();
+ }
curRowIndex = nextRowIndex;
curColIndex = nextColIndex;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.NoSuchElementException;
import java.util.Set;
import org.apache.poi.hpsf.ClassID;
* A DirectoryEntry filter, which exposes another
* DirectoryEntry less certain parts.
* This is typically used when copying or comparing
- * Filesystems.
+ * Filesystems.
*/
public class FilteringDirectoryNode implements DirectoryEntry
{
* Excludes of our child directories
*/
private Map<String,List<String>> childExcludes;
-
+
private DirectoryEntry directory;
-
+
/**
* Creates a filter round the specified directory, which
* will exclude entries such as "MyNode" and "MyDir/IgnoreNode".
* The excludes can stretch into children, if they contain a /.
- *
+ *
* @param directory The Directory to filter
* @param excludes The Entries to exclude
* @throws IllegalArgumentException if directory is null
throw new IllegalArgumentException("directory cannot be null");
}
this.directory = directory;
-
+
// Process the excludes
this.excludes = new HashSet<>();
this.childExcludes = new HashMap<>();
public Iterator<Entry> iterator() {
return getEntries();
}
-
+
public int getEntryCount() {
int size = directory.getEntryCount();
for (String excl : excludes) {
}
return size;
}
-
+
public Set<String> getEntryNames() {
Set<String> names = new HashSet<>();
for (String name : directory.getEntryNames()) {
if (excludes.contains(name)) {
throw new FileNotFoundException(name);
}
-
+
Entry entry = directory.getEntry(name);
return wrapEntry(entry);
}
String name = entry.getName();
if (childExcludes.containsKey(name) && entry instanceof DirectoryEntry) {
return new FilteringDirectoryNode(
- (DirectoryEntry)entry, childExcludes.get(name));
+ (DirectoryEntry)entry, childExcludes.get(name));
}
return entry;
}
public boolean renameTo(String newName) {
return directory.renameTo(newName);
}
-
+
public String getName() {
return directory.getName();
}
public boolean isDocumentEntry() {
return false;
}
-
+
private class FilteringIterator implements Iterator<Entry> {
private Iterator<Entry> parent;
private Entry next;
-
+
private FilteringIterator() {
parent = directory.getEntries();
locateNext();
}
}
}
-
+
public boolean hasNext() {
return (next != null);
}
-
+
public Entry next() {
+ if (!hasNext()) {
+ throw new NoSuchElementException();
+ }
+
Entry e = next;
locateNext();
return e;
}
-
+
public void remove() {
throw new UnsupportedOperationException("Remove not supported");
}
import java.nio.ByteBuffer;
import java.util.Iterator;
import java.util.List;
+import java.util.NoSuchElementException;
import org.apache.poi.poifs.common.POIFSConstants;
import org.apache.poi.poifs.property.RootProperty;
this._sbat_blocks = sbats;
this._header = header;
this._root = root;
-
+
this._mini_stream = new POIFSStream(filesystem, root.getStartBlock());
}
-
+
/**
* Load the block at the given offset.
*/
int byteOffset = offset * POIFSConstants.SMALL_BLOCK_SIZE;
int bigBlockNumber = byteOffset / _filesystem.getBigBlockSize();
int bigBlockOffset = byteOffset % _filesystem.getBigBlockSize();
-
+
// Now locate the data block for it
Iterator<ByteBuffer> it = _mini_stream.getBlockIterator();
for(int i=0; i<bigBlockNumber; i++) {
it.next();
}
ByteBuffer dataBlock = it.next();
- if(dataBlock == null) {
- throw new IndexOutOfBoundsException("Big block " + bigBlockNumber + " outside stream");
- }
+ assert(dataBlock != null);
- // Position ourselves, and take a slice
+ // Position ourselves, and take a slice
dataBlock.position(
dataBlock.position() + bigBlockOffset
);
miniBuffer.limit(POIFSConstants.SMALL_BLOCK_SIZE);
return miniBuffer;
}
-
+
/**
* Load the block, extending the underlying stream if needed
*/
if (_mini_stream.getStartBlock() == POIFSConstants.END_OF_CHAIN) {
firstInStore = true;
}
-
+
// Try to get it without extending the stream
if (! firstInStore) {
try {
return getBlockAt(offset);
- } catch(IndexOutOfBoundsException e) {}
+ } catch(NoSuchElementException e) {}
}
-
+
// Need to extend the stream
// TODO Replace this with proper append support
// For now, do the extending by hand...
// Ask for another block
int newBigBlock = _filesystem.getFreeBlock();
_filesystem.createBlockIfNeeded(newBigBlock);
-
+
// If we are the first block to be allocated, initialise the stream
if (firstInStore) {
_filesystem._get_property_table().getRoot().setStartBlock(newBigBlock);
}
_filesystem.setNextBlock(block, newBigBlock);
}
-
+
// This is now the new end
_filesystem.setNextBlock(newBigBlock, POIFSConstants.END_OF_CHAIN);
// Now try again, to get the real small block
return createBlockIfNeeded(offset);
}
-
+
/**
* Returns the BATBlock that handles the specified offset,
* and the relative index within it
offset, _header, _sbat_blocks
);
}
-
+
/**
* Works out what block follows the specified one.
*/
BATBlockAndIndex bai = getBATBlockAndIndex(offset);
return bai.getBlock().getValueAt( bai.getIndex() );
}
-
+
/**
* Changes the record of what block follows the specified one.
*/
bai.getIndex(), nextBlock
);
}
-
+
/**
* Finds a free block, and returns its offset.
* This method will extend the file if needed, and if doing
*/
protected int getFreeBlock() throws IOException {
int sectorsPerSBAT = _filesystem.getBigBlockSizeDetails().getBATEntriesPerBlock();
-
+
// First up, do we have any spare ones?
int offset = 0;
for (BATBlock sbat : _sbat_blocks) {
// Move onto the next SBAT
offset += sectorsPerSBAT;
}
-
+
// If we get here, then there aren't any
// free sectors in any of the SBATs
// So, we need to extend the chain and add another
-
+
// Create a new BATBlock
BATBlock newSBAT = BATBlock.createEmptyBATBlock(_filesystem.getBigBlockSizeDetails(), false);
int batForSBAT = _filesystem.getFreeBlock();
newSBAT.setOurBlockIndex(batForSBAT);
-
+
// Are we the first SBAT?
if(_header.getSBATCount() == 0) {
// Tell the header that we've got our first SBAT there
}
batOffset = nextBat;
}
-
+
// Add it in at the end
_filesystem.setNextBlock(batOffset, batForSBAT);
-
+
// And update the count
_header.setSBATBlockCount(
_header.getSBATCount() + 1
);
}
-
+
// Finish allocating
_filesystem.setNextBlock(batForSBAT, POIFSConstants.END_OF_CHAIN);
_sbat_blocks.add(newSBAT);
-
+
// Return our first spot
return offset;
}
-
+
@Override
protected ChainLoopDetector getChainLoopDetector() {
return new ChainLoopDetector( _root.getSize() );
protected int getBlockStoreBlockSize() {
return POIFSConstants.SMALL_BLOCK_SIZE;
}
-
+
/**
* Writes the SBATs to their backing blocks, and updates
* the mini-stream size in the properties. Stream size is
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.util.Iterator;
+import java.util.NoSuchElementException;
import org.apache.poi.poifs.common.POIFSConstants;
import org.apache.poi.poifs.filesystem.BlockStore.ChainLoopDetector;
* {@link POIFSFileSystem}. It can supply an iterator
* to read blocks, and way to write out to existing and
* new blocks.
- * Most users will want a higher level version of this,
+ * Most users will want a higher level version of this,
* which deals with properties to track which stream
* this is.
* This only works on big block streams, it doesn't
* handle small block ones.
* This uses the new NIO code
- *
+ *
* TODO Implement a streaming write method, and append
*/
private BlockStore blockStore;
private int startBlock;
private OutputStream outStream;
-
+
/**
* Constructor for an existing stream. It's up to you
- * to know how to get the start block (eg from a
- * {@link HeaderBlock} or a {@link Property})
+ * to know how to get the start block (eg from a
+ * {@link HeaderBlock} or a {@link Property})
*/
public POIFSStream(BlockStore blockStore, int startBlock) {
this.blockStore = blockStore;
this.startBlock = startBlock;
}
-
+
/**
* Constructor for a new stream. A start block won't
* be allocated until you begin writing to it.
this.blockStore = blockStore;
this.startBlock = POIFSConstants.END_OF_CHAIN;
}
-
+
/**
* What block does this stream start at?
* Will be {@link POIFSConstants#END_OF_CHAIN} for a
public Iterator<ByteBuffer> iterator() {
return getBlockIterator();
}
-
+
Iterator<ByteBuffer> getBlockIterator() {
if(startBlock == POIFSConstants.END_OF_CHAIN) {
throw new IllegalStateException(
}
return outStream;
}
-
+
// TODO Streaming write support
// TODO then convert fixed sized write to use streaming internally
// TODO Append write support (probably streaming)
-
+
/**
* Frees all blocks in the stream
*/
}
this.startBlock = POIFSConstants.END_OF_CHAIN;
}
-
+
/**
* Class that handles a streaming read of one stream
*/
protected class StreamBlockByteBufferIterator implements Iterator<ByteBuffer> {
private ChainLoopDetector loopDetector;
private int nextBlock;
-
+
StreamBlockByteBufferIterator(int firstBlock) {
this.nextBlock = firstBlock;
try {
}
public ByteBuffer next() {
- if(nextBlock == POIFSConstants.END_OF_CHAIN) {
- throw new IndexOutOfBoundsException("Can't read past the end of the stream");
+ if (!hasNext()) {
+ throw new NoSuchElementException("Can't read past the end of the stream");
}
-
+
try {
loopDetector.claim(nextBlock);
ByteBuffer data = blockStore.getBlockAt(nextBlock);
throw new UnsupportedOperationException();
}
}
-
+
protected class StreamBlockByteBuffer extends OutputStream {
byte[] oneByte = new byte[1];
ByteBuffer buffer;
void createBlockIfNeeded() throws IOException {
if (buffer != null && buffer.hasRemaining()) return;
-
+
int thisBlock = nextBlock;
-
+
// Allocate a block if needed, otherwise figure
// out what the next block will be
if(thisBlock == POIFSConstants.END_OF_CHAIN) {
thisBlock = blockStore.getFreeBlock();
loopDetector.claim(thisBlock);
-
+
// We're on the end of the chain
nextBlock = POIFSConstants.END_OF_CHAIN;
-
+
// Mark the previous block as carrying on to us if needed
if(prevBlock != POIFSConstants.END_OF_CHAIN) {
blockStore.setNextBlock(prevBlock, thisBlock);
}
blockStore.setNextBlock(thisBlock, POIFSConstants.END_OF_CHAIN);
-
- // If we've just written the first block on a
+
+ // If we've just written the first block on a
// new stream, save the start block offset
if(startBlock == POIFSConstants.END_OF_CHAIN) {
startBlock = thisBlock;
}
buffer = blockStore.createBlockIfNeeded(thisBlock);
-
+
// Update pointers
prevBlock = thisBlock;
}
len -= writeBytes;
} while (len > 0);
}
-
+
public void close() throws IOException {
// If we're overwriting, free any remaining blocks
POIFSStream toFree = new POIFSStream(blockStore, nextBlock);
toFree.free(loopDetector);
-
+
// Mark the end of the stream, if we have any data
if (prevBlock != POIFSConstants.END_OF_CHAIN) {
blockStore.setNextBlock(prevBlock, POIFSConstants.END_OF_CHAIN);
package org.apache.poi.util;
import java.util.Iterator;
+import java.util.NoSuchElementException;
// based on https://gist.github.com/EmmanuelOga/48df70b27ead4d80234b
@Internal
@Override
public String next() {
+ if (!hasNext()) {
+ throw new NoSuchElementException();
+ }
int codePoint = StringCodepointsIterable.this.string.codePointAt(index);
index += Character.charCount(codePoint);
return new String(Character.toChars(codePoint));
package org.apache.poi.util;
+import static java.nio.charset.StandardCharsets.ISO_8859_1;
+
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
-import java.util.Iterator;
import java.util.Locale;
/**
*/
@Internal
public final class StringUtil {
- private static final Charset ISO_8859_1 = StandardCharsets.ISO_8859_1;
//arbitrarily selected; may need to increase
private static final int MAX_RECORD_LENGTH = 10000000;
return haystack.regionMatches(true, start, suffix, 0, length);
}
- /**
- * An Iterator over an array of Strings.
- */
- public static class StringsIterator implements Iterator<String> {
- private String[] strings = {};
- private int position;
-
- public StringsIterator(String[] strings) {
- if (strings != null) {
- this.strings = strings.clone();
- }
- }
-
- @Override
- public boolean hasNext() {
- return position < strings.length;
- }
-
- @Override
- public String next() {
- int ourPos = position++;
- if (ourPos >= strings.length) {
- throw new ArrayIndexOutOfBoundsException(ourPos);
- }
- return strings[ourPos];
- }
-
- @Override
- public void remove() {
- }
- }
-
@Internal
public static String toLowerCase(char c) {
return Character.toString(c).toLowerCase(Locale.ROOT);
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.NoSuchElementException;
import java.util.function.Supplier;
import org.apache.poi.common.usermodel.GenericRecord;
@Override
public EmfCommentData next() {
+ if (!hasNext()) {
+ throw new NoSuchElementException();
+ }
EmfCommentData toReturn = currentRecord;
final boolean isEOF = (limit == -1 || leis.getReadIndex() >= startIdx+limit);
// (currentRecord instanceof HemfPlusMisc.EmfEof)
import java.io.IOException;
import java.util.Iterator;
+import java.util.NoSuchElementException;
import org.apache.poi.util.LittleEndianConsts;
import org.apache.poi.util.LittleEndianInputStream;
@Override
public HemfRecord next() {
+ if (!hasNext()) {
+ throw new NoSuchElementException();
+ }
HemfRecord toReturn = currentRecord;
currentRecord = (currentRecord instanceof HemfMisc.EmfEof) ? null : _next();
return toReturn;
import java.io.IOException;
import java.util.Iterator;
+import java.util.NoSuchElementException;
import org.apache.poi.util.LittleEndianInputStream;
import org.apache.poi.util.RecordFormatException;
@Override
public HemfPlusRecord next() {
+ if (!hasNext()) {
+ throw new NoSuchElementException();
+ }
HemfPlusRecord toReturn = currentRecord;
// add the size for recordId/flags/recordSize/dataSize = 12 bytes
final boolean isEOF = (limit == -1 || (leis.getReadIndex()-startIdx)+12 > limit);
==================================================================== */
package org.apache.poi.hsmf.extractor;
+import static org.apache.poi.util.StringUtil.startsWithIgnoreCase;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Locale;
+
import org.apache.poi.extractor.POIOLE2TextExtractor;
import org.apache.poi.hsmf.MAPIMessage;
import org.apache.poi.hsmf.datatypes.AttachmentChunks;
import org.apache.poi.poifs.filesystem.DirectoryNode;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.util.LocaleUtil;
-import org.apache.poi.util.Removal;
-import org.apache.poi.util.StringUtil.StringsIterator;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.text.SimpleDateFormat;
-import java.util.Locale;
-
-import static org.apache.poi.util.StringUtil.startsWithIgnoreCase;
/**
* A text extractor for HSMF (Outlook) .msg files.
msg.guess7BitEncoding();
// Off we go
- StringsIterator emails;
+ Iterator<String> emails;
try {
- emails = new StringsIterator(
- msg.getRecipientEmailAddressList()
- );
+ emails = Arrays.asList(msg.getRecipientEmailAddressList()).iterator();
} catch (ChunkNotFoundException e) {
- emails = new StringsIterator(new String[0]);
+ emails = Collections.emptyIterator();
}
try {
* of emails, and does its best to return something like
* "Nick <nick@example.com>; Jim <jim@example.com>"
*/
- protected void handleEmails(StringBuilder s, String type, String displayText, StringsIterator emails) {
+ protected void handleEmails(StringBuilder s, String type, String displayText, Iterator<String> emails) {
if (displayText == null || displayText.length() == 0) {
return;
}
package org.apache.poi.poifs.filesystem;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
import java.io.ByteArrayInputStream;
import java.io.FileNotFoundException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
+import java.util.NoSuchElementException;
import org.junit.Before;
import org.junit.Test;
-import static org.junit.Assert.*;
-
/**
* Class to test FilteringDirectoryNode functionality
*/
assertFalse(d.getEntry(eRoot.getName()).isDirectoryEntry());
assertTrue(d.getEntry(eRoot.getName()).isDocumentEntry());
- Iterator<Entry> i = d.getEntries();
- assertEquals(dirA, i.next());
- assertEquals(dirB, i.next());
- assertEquals(eRoot, i.next());
- assertNull(i.next());
+ Iterator<Entry> i = d.getEntries();
+ assertEquals(dirA, i.next());
+ assertEquals(dirB, i.next());
+ assertEquals(eRoot, i.next());
+ try {
+ assertNull(i.next());
+ fail("Should throw NoSuchElementException when depleted");
+ } catch (NoSuchElementException ignored) {
+ }
}
@Test
public void testChildFiltering() throws Exception {
- List<String> excl = Arrays.asList(new String[]{"NotThere", "AlsoNotThere", eRoot.getName()});
+ List<String> excl = Arrays.asList("NotThere", "AlsoNotThere", eRoot.getName());
FilteringDirectoryNode d = new FilteringDirectoryNode(fs.getRoot(), excl);
assertEquals(2, d.getEntryCount());
Iterator<Entry> i = d.getEntries();
assertEquals(dirA, i.next());
assertEquals(dirB, i.next());
- assertNull(i.next());
+ try {
+ assertNull(i.next());
+ fail("Should throw NoSuchElementException when depleted");
+ } catch (NoSuchElementException ignored) {
+ }
// Filter more
- excl = Arrays.asList(new String[]{"NotThere", "AlsoNotThere", eRoot.getName(), dirA.getName()});
+ excl = Arrays.asList("NotThere", "AlsoNotThere", eRoot.getName(), dirA.getName());
d = new FilteringDirectoryNode(fs.getRoot(), excl);
assertEquals(1, d.getEntryCount());
i = d.getEntries();
assertEquals(dirB, i.next());
- assertNull(i.next());
+ try {
+ assertNull(i.next());
+ fail("Should throw NoSuchElementException when depleted");
+ } catch (NoSuchElementException ignored) {
+ }
// Filter everything
- excl = Arrays.asList(new String[]{"NotThere", eRoot.getName(), dirA.getName(), dirB.getName()});
+ excl = Arrays.asList("NotThere", eRoot.getName(), dirA.getName(), dirB.getName());
d = new FilteringDirectoryNode(fs.getRoot(), excl);
assertEquals(0, d.getEntryCount());
}
i = d.getEntries();
- assertNull(i.next());
+ try {
+ assertNull(i.next());
+ fail("Should throw NoSuchElementException when depleted");
+ } catch (NoSuchElementException ignored) {
+ }
}
@Test
public void testNestedFiltering() throws Exception {
- List<String> excl = Arrays.asList(new String[]{
- dirA.getName() + "/" + "MadeUp",
- dirA.getName() + "/" + eA.getName(),
- dirA.getName() + "/" + dirAA.getName() + "/Test",
- eRoot.getName()
- });
+ List<String> excl = Arrays.asList(dirA.getName() + "/" + "MadeUp",
+ dirA.getName() + "/" + eA.getName(),
+ dirA.getName() + "/" + dirAA.getName() + "/Test",
+ eRoot.getName());
FilteringDirectoryNode d = new FilteringDirectoryNode(fs.getRoot(), excl);
// Check main
import java.io.ByteArrayInputStream;
import java.nio.ByteBuffer;
import java.util.Iterator;
+import java.util.NoSuchElementException;
import org.apache.poi.POIDataSamples;
import org.apache.poi.poifs.common.POIFSConstants;
@SuppressWarnings("CatchMayIgnoreException")
public final class TestPOIFSMiniStore {
private static final POIDataSamples _inst = POIDataSamples.getPOIFSInstance();
-
+
/**
* Check that for a given mini block, we can correctly figure
* out what the next one is
POIFSFileSystem fsD = new POIFSFileSystem(_inst.openResourceAsStream("BlockSize4096.zvi"));
for(POIFSFileSystem fs : new POIFSFileSystem[] {fsA,fsB,fsC,fsD}) {
POIFSMiniStore ministore = fs.getMiniStore();
-
+
// 0 -> 51 is one stream
for(int i=0; i<50; i++) {
assertEquals(i+1, ministore.getNextBlock(i));
}
assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(50));
-
+
// 51 -> 103 is the next
for(int i=51; i<103; i++) {
assertEquals(i+1, ministore.getNextBlock(i));
}
assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(103));
-
+
// Then there are 3 one block ones
assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(104));
assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(105));
assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(106));
-
+
// 107 -> 154 is the next
for(int i=107; i<154; i++) {
assertEquals(i+1, ministore.getNextBlock(i));
assertEquals(i+1, ministore.getNextBlock(i));
}
assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(160));
-
+
// 161 -> 166 is the next
for(int i=161; i<166; i++) {
assertEquals(i+1, ministore.getNextBlock(i));
}
assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(166));
-
+
// 167 -> 172 is the next
for(int i=167; i<172; i++) {
assertEquals(i+1, ministore.getNextBlock(i));
}
assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(172));
-
+
// Now some short ones
assertEquals(174 , ministore.getNextBlock(173));
assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(174));
-
+
assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(175));
-
+
assertEquals(177 , ministore.getNextBlock(176));
assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(177));
-
+
assertEquals(179 , ministore.getNextBlock(178));
assertEquals(180 , ministore.getNextBlock(179));
assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(180));
-
+
// 181 onwards is free
for(int i=181; i<fs.getBigBlockSizeDetails().getBATEntriesPerBlock(); i++) {
assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(i));
for(POIFSFileSystem fs : new POIFSFileSystem[] {fsA,fsB,fsC,fsD}) {
// Mini stream should be at big block zero
assertEquals(0, fs._get_property_table().getRoot().getStartBlock());
-
+
// Grab the ministore
POIFSMiniStore ministore = fs.getMiniStore();
ByteBuffer b;
-
+
// Runs from the start of the data section in 64 byte chungs
b = ministore.getBlockAt(0);
assertEquals((byte)0x9e, b.get());
assertEquals((byte)0x21, b.get());
assertEquals((byte)0xd2, b.get());
assertEquals((byte)0x11, b.get());
-
+
// And the next block
b = ministore.getBlockAt(1);
assertEquals((byte)0x00, b.get());
assertEquals((byte)0x02, b.get());
assertEquals((byte)0x00, b.get());
assertEquals((byte)0x00, b.get());
-
+
// Check the last data block
b = ministore.getBlockAt(180);
assertEquals((byte)0x30, b.get());
assertEquals((byte)0x00, b.get());
assertEquals((byte)0x00, b.get());
assertEquals((byte)0x80, b.get());
-
+
// And the rest until the end of the big block is zeros
for(int i=181; i<184; i++) {
b = ministore.getBlockAt(i);
fsB.close();
fsA.close();
}
-
+
/**
* Ask for free blocks where there are some already
* to be had from the SFAT
public void testGetFreeBlockWithSpare() throws Exception {
POIFSFileSystem fs = new POIFSFileSystem(_inst.getFile("BlockSize512.zvi"));
POIFSMiniStore ministore = fs.getMiniStore();
-
+
// Our 2nd SBAT block has spares
assertFalse(ministore.getBATBlockAndIndex(0).getBlock().hasFreeSectors());
assertTrue(ministore.getBATBlockAndIndex(128).getBlock().hasFreeSectors());
-
+
// First free one at 181
assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(181));
assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(182));
assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(183));
assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(184));
-
+
// Ask, will get 181
assertEquals(181, ministore.getFreeBlock());
-
+
// Ask again, will still get 181 as not written to
assertEquals(181, ministore.getFreeBlock());
-
+
// Allocate it, then ask again
ministore.setNextBlock(181, POIFSConstants.END_OF_CHAIN);
assertEquals(182, ministore.getFreeBlock());
-
+
fs.close();
}
public void testGetFreeBlockWithNoneSpare() throws Exception {
POIFSFileSystem fs = new POIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
POIFSMiniStore ministore = fs.getMiniStore();
-
+
// We've spare ones from 181 to 255
for(int i=181; i<256; i++) {
assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(i));
}
-
+
// Check our SBAT free stuff is correct
assertFalse(ministore.getBATBlockAndIndex(0).getBlock().hasFreeSectors());
assertTrue(ministore.getBATBlockAndIndex(128).getBlock().hasFreeSectors());
-
+
// Allocate all the spare ones
for(int i=181; i<256; i++) {
ministore.setNextBlock(i, POIFSConstants.END_OF_CHAIN);
}
-
+
// SBAT are now full, but there's only the two
assertFalse(ministore.getBATBlockAndIndex(0).getBlock().hasFreeSectors());
assertFalse(ministore.getBATBlockAndIndex(128).getBlock().hasFreeSectors());
assertFalse(ministore.getBATBlockAndIndex(256).getBlock().hasFreeSectors());
fail("Should only be two SBATs");
} catch(IndexOutOfBoundsException e) {}
-
+
// Now ask for a free one, will need to extend the SBAT chain
assertEquals(256, ministore.getFreeBlock());
assertFalse(ministore.getBATBlockAndIndex(0).getBlock().hasFreeSectors());
assertFalse(ministore.getBATBlockAndIndex(128).getBlock().hasFreeSectors());
assertTrue(ministore.getBATBlockAndIndex(256).getBlock().hasFreeSectors());
- assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(254)); // 2nd SBAT
+ assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(254)); // 2nd SBAT
assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(255)); // 2nd SBAT
assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(256)); // 3rd SBAT
assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(257)); // 3rd SBAT
-
+
fs.close();
}
-
+
/**
- * Test that we will extend the underlying chain of
+ * Test that we will extend the underlying chain of
* big blocks that make up the ministream as needed
*/
@Test
public void testCreateBlockIfNeeded() throws Exception {
POIFSFileSystem fs = new POIFSFileSystem(_inst.openResourceAsStream("BlockSize512.zvi"));
POIFSMiniStore ministore = fs.getMiniStore();
-
+
// 178 -> 179 -> 180, 181+ is free
assertEquals(179 , ministore.getNextBlock(178));
assertEquals(180 , ministore.getNextBlock(179));
for(int i=181; i<256; i++) {
assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(i));
}
-
+
// However, the ministore data only covers blocks to 183
for(int i=0; i<=183; i++) {
ministore.getBlockAt(i);
try {
ministore.getBlockAt(184);
fail("No block at 184");
- } catch(IndexOutOfBoundsException e) {}
-
+ } catch(NoSuchElementException e) {}
+
// The ministore itself is made up of 23 big blocks
Iterator<ByteBuffer> it = new POIFSStream(fs, fs.getRoot().getProperty().getStartBlock()).getBlockIterator();
int count = 0;
it.next();
}
assertEquals(23, count);
-
+
// Ask it to get block 184 with creating, it will do
ministore.createBlockIfNeeded(184);
-
+
// The ministore should be one big block bigger now
it = new POIFSStream(fs, fs.getRoot().getProperty().getStartBlock()).getBlockIterator();
count = 0;
it.next();
}
assertEquals(24, count);
-
+
// The mini block block counts now run to 191
for(int i=0; i<=191; i++) {
ministore.getBlockAt(i);
try {
ministore.getBlockAt(192);
fail("No block at 192");
- } catch(IndexOutOfBoundsException e) {}
-
-
+ } catch(NoSuchElementException e) {}
+
+
// Now try writing through to 192, check that the SBAT and blocks are there
byte[] data = new byte[15*64];
POIFSStream stream = new POIFSStream(ministore, 178);
stream.updateContents(data);
-
+
// Check now
assertEquals(179 , ministore.getNextBlock(178));
assertEquals(180 , ministore.getNextBlock(179));
for(int i=193; i<256; i++) {
assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(i));
}
-
+
fs.close();
}
-
+
@Test
public void testCreateMiniStoreFirst() throws Exception {
POIFSFileSystem fs = new POIFSFileSystem();
try {
ministore.getNextBlock(0);
} catch (IndexOutOfBoundsException e) {}
-
+
// Write a very small new document, will populate the ministore for us
byte[] data = new byte[8];
for (int i=0; i<data.length; i++) {
data[i] = (byte)(i+42);
}
fs.getRoot().createDocument("mini", new ByteArrayInputStream(data));
-
+
// Should now have a mini-fat and a mini-stream
assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(0));
assertEquals(POIFSConstants.FAT_SECTOR_BLOCK,fs.getNextBlock(1));
assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(4));
assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(0));
assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(1));
-
+
// Re-fetch the mini store, and add it a second time
ministore = fs.getMiniStore();
fs.getRoot().createDocument("mini2", new ByteArrayInputStream(data));
-
+
// Main unchanged, ministore has a second
assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(0));
assertEquals(POIFSConstants.FAT_SECTOR_BLOCK,fs.getNextBlock(1));
assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(0));
assertEquals(POIFSConstants.END_OF_CHAIN, ministore.getNextBlock(1));
assertEquals(POIFSConstants.UNUSED_BLOCK, ministore.getNextBlock(2));
-
+
// Check the data is unchanged and the right length
entry = (DocumentEntry)fs.getRoot().getEntry("mini");
assertEquals(data.length, entry.getSize());
IOUtils.readFully(dis, rdata);
assertArrayEquals(data, rdata);
dis.close();
-
+
entry = (DocumentEntry)fs.getRoot().getEntry("mini2");
assertEquals(data.length, entry.getSize());
rdata = new byte[data.length];
// Done
fs.close();
}
-
+
@Test
public void testMultiBlockStream() throws Exception {
byte[] data1B = new byte[63];
for (int i=0; i<data2B.length; i++) {
data2B[i] = (byte)(i+4);
}
-
+
// New filesystem and store to use
POIFSFileSystem fs = new POIFSFileSystem();
assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(0));
assertEquals(POIFSConstants.FAT_SECTOR_BLOCK, fs.getNextBlock(1));
assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(2));
-
+
// Store the 2 block one, should use 2 mini blocks, and request
// the use of 2 big blocks
POIFSMiniStore ministore = fs.getMiniStore();
fs.getRoot().createDocument("mini2", new ByteArrayInputStream(data2B));
-
+
// Check
assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(0));
assertEquals(POIFSConstants.FAT_SECTOR_BLOCK, fs.getNextBlock(1));
assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(2)); // SBAT
assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(3)); // Mini
assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(4));
-
+
// First 2 Mini blocks will be used
assertEquals(2, ministore.getFreeBlock());
-
+
// Add one more mini-stream, and check
fs.getRoot().createDocument("mini1", new ByteArrayInputStream(data1B));
-
+
assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(0));
assertEquals(POIFSConstants.FAT_SECTOR_BLOCK, fs.getNextBlock(1));
assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(2)); // SBAT
assertEquals(POIFSConstants.END_OF_CHAIN, fs.getNextBlock(3)); // Mini
assertEquals(POIFSConstants.UNUSED_BLOCK, fs.getNextBlock(4));
-
+
// One more mini-block will be used
assertEquals(3, ministore.getFreeBlock());
-
+
// Check the contents too
byte[] r1 = new byte[data1B.length];
DocumentInputStream dis = fs.createDocumentInputStream("mini1");
IOUtils.readFully(dis, r1);
dis.close();
assertArrayEquals(data1B, r1);
-
+
byte[] r2 = new byte[data2B.length];
dis = fs.createDocumentInputStream("mini2");
IOUtils.readFully(dis, r2);
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.util.Iterator;
+import java.util.NoSuchElementException;
import org.apache.poi.POIDataSamples;
import org.apache.poi.hpsf.DocumentSummaryInformation;
POIFSStream stream = new POIFSStream(fs, 98);
Iterator<ByteBuffer> i = stream.getBlockIterator();
assertTrue(i.hasNext());
- assertTrue(i.hasNext());
- assertTrue(i.hasNext());
ByteBuffer b = i.next();
assertFalse(i.hasNext());
- assertFalse(i.hasNext());
- assertFalse(i.hasNext());
// Check the contents
assertEquals((byte)0x81, b.get());
POIFSStream stream = new POIFSStream(fs, 97);
Iterator<ByteBuffer> i = stream.getBlockIterator();
assertTrue(i.hasNext());
- assertTrue(i.hasNext());
- assertTrue(i.hasNext());
ByteBuffer b97 = i.next();
assertTrue(i.hasNext());
- assertTrue(i.hasNext());
ByteBuffer b98 = i.next();
assertFalse(i.hasNext());
- assertFalse(i.hasNext());
- assertFalse(i.hasNext());
// Check the contents of the 1st block
assertEquals((byte)0x01, b97.get());
// Check the contents
// 1st block is at 0
+ assertNotNull(b0);
assertEquals((byte)0x9e, b0.get());
assertEquals((byte)0x75, b0.get());
assertEquals((byte)0x97, b0.get());
assertEquals((byte)0xf6, b0.get());
// 2nd block is at 1
+ assertNotNull(b1);
assertEquals((byte)0x86, b1.get());
assertEquals((byte)0x09, b1.get());
assertEquals((byte)0x22, b1.get());
assertEquals((byte)0xfb, b1.get());
// last block is at 89
+ assertNotNull(b22);
assertEquals((byte)0xfe, b22.get());
assertEquals((byte)0xff, b22.get());
assertEquals((byte)0x00, b22.get());
POIFSStream stream = new POIFSStream(fs, 0);
Iterator<ByteBuffer> i = stream.getBlockIterator();
assertTrue(i.hasNext());
- assertTrue(i.hasNext());
- assertTrue(i.hasNext());
ByteBuffer b0 = i.next();
assertTrue(i.hasNext());
- assertTrue(i.hasNext());
ByteBuffer b1 = i.next();
assertTrue(i.hasNext());
- assertTrue(i.hasNext());
ByteBuffer b2 = i.next();
assertFalse(i.hasNext());
- assertFalse(i.hasNext());
- assertFalse(i.hasNext());
// Check the contents of the 1st block
assertEquals((byte)0x9E, b0.get());
POIFSStream stream = new POIFSStream(ministore, 178);
Iterator<ByteBuffer> i = stream.getBlockIterator();
assertTrue(i.hasNext());
- assertTrue(i.hasNext());
- assertTrue(i.hasNext());
ByteBuffer b178 = i.next();
assertTrue(i.hasNext());
- assertTrue(i.hasNext());
ByteBuffer b179 = i.next();
assertTrue(i.hasNext());
ByteBuffer b180 = i.next();
assertFalse(i.hasNext());
- assertFalse(i.hasNext());
- assertFalse(i.hasNext());
// Check the contents of the 1st block
assertEquals((byte)0xfe, b178.get());
try {
ministore.getBlockAt(184);
fail("Block 184 should be off the end of the list");
- } catch (IndexOutOfBoundsException e) {
+ } catch (NoSuchElementException e) {
}
data = new byte[64 * 6 + 12];
import java.nio.charset.Charset;
-import org.apache.poi.util.StringUtil.StringsIterator;
import org.junit.Test;
/**
}
}
- @Test
- public void testStringsIterator() {
- StringsIterator i;
-
-
- i = new StringsIterator(new String[0]);
- assertFalse(i.hasNext());
- try {
- i.next();
- fail();
- } catch(ArrayIndexOutOfBoundsException e) {
- // expected here
- }
-
-
- i = new StringsIterator(new String[] {"1"});
- assertTrue(i.hasNext());
- assertEquals("1", i.next());
-
- assertFalse(i.hasNext());
- try {
- i.next();
- fail();
- } catch(ArrayIndexOutOfBoundsException e) {
- // expected here
- }
-
-
- i = new StringsIterator(new String[] {"1","2","3"});
- assertTrue(i.hasNext());
- assertEquals("1", i.next());
- assertTrue(i.hasNext());
- assertEquals("2", i.next());
- assertTrue(i.hasNext());
- assertEquals("3", i.next());
-
- assertFalse(i.hasNext());
- try {
- i.next();
- fail();
- } catch(ArrayIndexOutOfBoundsException e) {
- // expected here
- }
- }
-
-
@Test
public void startsWithIgnoreCase() {
assertTrue("same string", StringUtil.startsWithIgnoreCase("Apache POI", "Apache POI"));
assertFalse("leading whitespace should not be ignored", StringUtil.startsWithIgnoreCase(" Apache POI project", "Apache POI"));
assertFalse("shorter string", StringUtil.startsWithIgnoreCase("Apache", "Apache POI"));
}
-
+
@Test
public void endsWithIgnoreCase() {
assertTrue("same string", StringUtil.endsWithIgnoreCase("Apache POI", "Apache POI"));
assertFalse("trailing whitespace should not be ignored", StringUtil.endsWithIgnoreCase("Apache POI project ", "Apache POI"));
assertFalse("shorter string", StringUtil.endsWithIgnoreCase("Apache", "Apache POI"));
}
-
+
@Test
public void join() {
assertEquals("", StringUtil.join(",")); // degenerate case: nothing to join
assertEquals("abc", StringUtil.join(",", "abc")); // degenerate case: one thing to join, no trailing comma
assertEquals("abc|def|ghi", StringUtil.join("|", "abc", "def", "ghi"));
assertEquals("5|8.5|true|string", StringUtil.join("|", 5, 8.5, true, "string")); //assumes Locale prints number decimal point as a period rather than a comma
-
+
String[] arr = new String[] { "Apache", "POI", "project" };
assertEquals("no separator", "ApachePOIproject", StringUtil.join(arr));
assertEquals("separator", "Apache POI project", StringUtil.join(arr, " "));
}
-
+
@Test
public void count() {
String test = "Apache POI project\n\u00a9 Copyright 2016";
// supports search in null or empty string
assertEquals("null", 0, StringUtil.countMatches(null, 'A'));
assertEquals("empty string", 0, StringUtil.countMatches("", 'A'));
-
+
assertEquals("normal", 2, StringUtil.countMatches(test, 'e'));
assertEquals("normal, should not find a in escaped copyright", 1, StringUtil.countMatches(test, 'a'));
-
+
// search for non-printable characters
assertEquals("null character", 0, StringUtil.countMatches(test, '\0'));
assertEquals("CR", 0, StringUtil.countMatches(test, '\r'));
assertEquals("LF", 1, StringUtil.countMatches(test, '\n'));
-
+
// search for unicode characters
assertEquals("Unicode", 1, StringUtil.countMatches(test, '\u00a9'));
}
projects / poi.git / commitdiff