public void Test53475()
{
try
{
Biff8EncryptionKey.CurrentUserPassword = (/*setter*/"solrcell");
FileStream file = POIDataSamples.GetDocumentInstance().GetFile("bug53475-password-is-solrcell.docx");
NPOIFSFileSystem filesystem = new NPOIFSFileSystem(file, true);
/*
// Check the encryption details
EncryptionInfo info = new EncryptionInfo(filesystem);
Assert.AreEqual(128, info.Header.KeySize);
Assert.AreEqual(EncryptionHeader.ALGORITHM_AES_128, info.Header.Algorithm);
Assert.AreEqual(EncryptionHeader.HASH_SHA1, info.Header.HashAlgorithm);
// Check it can be decoded
Decryptor d = Decryptor.GetInstance(info);
Assert.IsTrue("Unable to Process: document is encrypted", d.VerifyPassword("solrcell"));
// Check we can read the word document in that
InputStream dataStream = d.GetDataStream(filesystem);
OPCPackage opc = OPCPackage.Open(dataStream);
XWPFDocument doc = new XWPFDocument(opc);
XWPFWordExtractor ex = new XWPFWordExtractor(doc);
String text = ex.Text;
Assert.IsNotNull(text);
Assert.AreEqual("This is password protected Word document.", text.Trim());
ex.Close();
*/
}
finally
{
Biff8EncryptionKey.CurrentUserPassword = (/*setter*/null);
}
}
public NPOIFSDocument(String name, int size, NPOIFSFileSystem filesystem, POIFSWriterListener Writer)
{
this._filesystem = filesystem;
if (size < POIFSConstants.BIG_BLOCK_MINIMUM_DOCUMENT_SIZE)
{
_stream = new NPOIFSStream(filesystem.GetMiniStore());
_block_size = _filesystem.GetMiniStore().GetBlockStoreBlockSize();
}
else
{
_stream = new NPOIFSStream(filesystem);
_block_size = _filesystem.GetBlockStoreBlockSize();
}
Stream innerOs = _stream.GetOutputStream();
DocumentOutputStream os = new DocumentOutputStream(innerOs, size);
POIFSDocumentPath path = new POIFSDocumentPath(name.Split(new string[] { "\\\\" }, StringSplitOptions.RemoveEmptyEntries));
String docName = path.GetComponent(path.Length - 1);
POIFSWriterEvent event1 = new POIFSWriterEvent(os, path, docName, size);
Writer.ProcessPOIFSWriterEvent(event1);
innerOs.Close();
// And build the property for it
this._property = new DocumentProperty(name, size);
_property.StartBlock = (/*setter*/ _stream.GetStartBlock());
}
public NPropertyTable(HeaderBlock headerBlock, NPOIFSFileSystem fileSystem)
:base(headerBlock,
BuildProperties( (new NPOIFSStream(fileSystem, headerBlock.PropertyStart)).GetEnumerator(),headerBlock.BigBlockSize)
)
{
_bigBigBlockSize = headerBlock.BigBlockSize;
}
/**
* Copies nodes from one POIFS to the other, minus the excepts.
* This delegates the filtering work to {@link FilteringDirectoryNode},
* so excepts can be of the form "NodeToExclude" or
* "FilteringDirectory/ExcludedChildNode"
*
* @param source is the source POIFS to copy from
* @param target is the target POIFS to copy to
* @param excepts is a list of Entry Names to be excluded from the copy
*/
public static void CopyNodes(NPOIFSFileSystem source,
NPOIFSFileSystem target, List <String> excepts)
{
CopyNodes(
new FilteringDirectoryNode(source.Root, excepts),
new FilteringDirectoryNode(target.Root, excepts)
);
}
/**
* Returns test files with 512 byte and 4k block sizes, loaded
* both from InputStreams and Files
*/
protected NPOIFSFileSystem[] get512and4kFileAndInput()
{
NPOIFSFileSystem fsA = new NPOIFSFileSystem(_inst.GetFile("BlockSize512.zvi"));
NPOIFSFileSystem fsB = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi"));
NPOIFSFileSystem fsC = new NPOIFSFileSystem(_inst.GetFile("BlockSize4096.zvi"));
NPOIFSFileSystem fsD = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize4096.zvi"));
return new NPOIFSFileSystem[] { fsA, fsB, fsC, fsD };
}
public NPOIFSMiniStore(NPOIFSFileSystem filesystem, RootProperty root,
List<BATBlock> sbats, HeaderBlock header)
{
this._filesystem = filesystem;
this._sbat_blocks = sbats;
this._header = header;
this._root = root;
this._mini_stream = new NPOIFSStream(filesystem, root.StartBlock);
}
/**
* Constructor for a new Document
*
* @param name the name of the POIFSDocument
* @param stream the InputStream we read data from
*/
public NPOIFSDocument(String name, NPOIFSFileSystem filesystem, Stream stream)
{
this._filesystem = filesystem;
// sotre it
int length = Store(stream);
// Build the property for it
this._property = new DocumentProperty(name, length);
_property.StartBlock = _stream.GetStartBlock();
}
public NPOIFSMiniStore(NPOIFSFileSystem filesystem, RootProperty root,
List <BATBlock> sbats, HeaderBlock header)
{
this._filesystem = filesystem;
this._sbat_blocks = sbats;
this._header = header;
this._root = root;
this._mini_stream = new NPOIFSStream(filesystem, root.StartBlock);
}
/**
* Constructor for a new Document
*
* @param name the name of the POIFSDocument
* @param stream the InputStream we read data from
*/
public NPOIFSDocument(String name, NPOIFSFileSystem filesystem, Stream stream)
{
this._filesystem = filesystem;
// sotre it
int length = Store(stream);
// Build the property for it
this._property = new DocumentProperty(name, length);
_property.StartBlock = _stream.GetStartBlock();
}
/**
* Constructor for an existing Document
*/
public NPOIFSDocument(DocumentProperty property, NPOIFSFileSystem filesystem)
{
this._property = property;
this._filesystem = filesystem;
if (property.Size < POIFSConstants.BIG_BLOCK_MINIMUM_DOCUMENT_SIZE)
{
_stream = new NPOIFSStream(_filesystem.GetMiniStore(), property.StartBlock);
_block_size = _filesystem.GetMiniStore().GetBlockStoreBlockSize();
}
else
{
_stream = new NPOIFSStream(_filesystem, property.StartBlock);
_block_size = _filesystem.GetBlockStoreBlockSize();
}
}
/**
* Constructor for an existing Document
*/
public NPOIFSDocument(DocumentProperty property, NPOIFSFileSystem filesystem)
{
this._property = property;
this._filesystem = filesystem;
if (property.Size < POIFSConstants.BIG_BLOCK_MINIMUM_DOCUMENT_SIZE)
{
_stream = new NPOIFSStream(_filesystem.GetMiniStore(), property.StartBlock);
_block_size = _filesystem.GetMiniStore().GetBlockStoreBlockSize();
}
else
{
_stream = new NPOIFSStream(_filesystem, property.StartBlock);
_block_size = _filesystem.GetBlockStoreBlockSize();
}
}
private DirectoryNode(DirectoryProperty property,
DirectoryNode parent,
POIFSFileSystem oFileSystem,
NPOIFSFileSystem nFileSystem)
: base(property, parent)
{
this._oFilesSystem = oFileSystem;
this._nFilesSystem = nFileSystem;
if (parent == null)
{
_path = new POIFSDocumentPath();
}
else
{
_path = new POIFSDocumentPath(parent._path, new string[] { property.Name });
}
_byname = new Dictionary <string, Entry>();
_entries = new List <Entry>();
IEnumerator <Property> iter = property.Children;
while (iter.MoveNext())
{
Property child = iter.Current;
Entry childNode = null;
if (child.IsDirectory)
{
DirectoryProperty childDir = (DirectoryProperty)child;
if (_oFilesSystem != null)
{
childNode = new DirectoryNode(childDir, _oFilesSystem, this);
}
else
{
childNode = new DirectoryNode(childDir, _nFilesSystem, this);
}
}
else
{
childNode = new DocumentNode((DocumentProperty)child, this);
}
_entries.Add(childNode);
_byname.Add(childNode.Name, childNode);
}
}
protected static void assertBATCount(NPOIFSFileSystem fs, int expectedBAT, int expectedXBAT)
{
int foundBAT = 0;
int foundXBAT = 0;
int sz = (int)(fs.Size / fs.GetBigBlockSize());
for (int i = 0; i < sz; i++)
{
if (fs.GetNextBlock(i) == POIFSConstants.FAT_SECTOR_BLOCK)
{
foundBAT++;
}
if (fs.GetNextBlock(i) == POIFSConstants.DIFAT_SECTOR_BLOCK)
{
foundXBAT++;
}
}
Assert.AreEqual(expectedBAT, foundBAT, "Wrong number of BATs");
Assert.AreEqual(expectedXBAT, foundXBAT, "Wrong number of XBATs with " + expectedBAT + " BATs");
}
public void TestBasicOpen()
{
NPOIFSFileSystem fsA, fsB;
fsA = new NPOIFSFileSystem(_inst.GetFile("BlockSize512.zvi"));
fsB = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi"));
foreach (NPOIFSFileSystem fs in new NPOIFSFileSystem[] { fsA, fsB })
{
Assert.AreEqual(512, fs.GetBigBlockSize());
}
fsA = new NPOIFSFileSystem(_inst.GetFile("BlockSize4096.zvi"));
fsB = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize4096.zvi"));
foreach (NPOIFSFileSystem fs in new NPOIFSFileSystem[] { fsA, fsB })
{
Assert.AreEqual(4096, fs.GetBigBlockSize());
}
}
protected DirectoryNode[] openSamples(Stream[] inps, bool oldFails)
{
NPOIFSFileSystem nfs = new NPOIFSFileSystem(inps[0]);
if (openedFSs == null) openedFSs = new List<NPOIFSFileSystem>();
openedFSs.Add(nfs);
POIFSFileSystem ofs = null;
try
{
ofs = new POIFSFileSystem(inps[1]);
if (oldFails) Assert.Fail("POIFSFileSystem should have failed but didn't");
}
catch (Exception e)
{
if (!oldFails) throw e;
}
if (ofs == null) return new DirectoryNode[] { nfs.Root };
return new DirectoryNode[] { ofs.Root, nfs.Root };
}
public void TestReadTinyStream()
{
NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.GetFile("BlockSize512.zvi"));
// 98 is actually the last block in a two block stream...
NPOIFSStream stream = new NPOIFSStream(fs, 98);
IEnumerator<ByteBuffer> i = stream.GetBlockIterator();
Assert.AreEqual(true, i.MoveNext());
ByteBuffer b = i.Current;
Assert.AreEqual(false, i.MoveNext());
// Check the contents
Assert.AreEqual((byte)0x81, b[0]);
Assert.AreEqual((byte)0x00, b[1]);
Assert.AreEqual((byte)0x00, b[2]);
Assert.AreEqual((byte)0x00, b[3]);
Assert.AreEqual((byte)0x82, b[4]);
Assert.AreEqual((byte)0x00, b[5]);
Assert.AreEqual((byte)0x00, b[6]);
Assert.AreEqual((byte)0x00, b[7]);
}
public void TestReadShortStream()
{
NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.GetFile("BlockSize512.zvi"));
// 97 -> 98 -> end
NPOIFSStream stream = new NPOIFSStream(fs, 97);
IEnumerator<ByteBuffer> i = stream.GetBlockIterator();
Assert.AreEqual(true, i.MoveNext());
// i.MoveNext();
ByteBuffer b97 = i.Current;
Assert.AreEqual(true, i.MoveNext());
//i.MoveNext();
ByteBuffer b98 = i.Current;
Assert.AreEqual(false, i.MoveNext());
// Check the contents of the 1st block
Assert.AreEqual((byte)0x01, b97[0]);
Assert.AreEqual((byte)0x00, b97[1]);
Assert.AreEqual((byte)0x00, b97[2]);
Assert.AreEqual((byte)0x00, b97[3]);
Assert.AreEqual((byte)0x02, b97[4]);
Assert.AreEqual((byte)0x00, b97[5]);
Assert.AreEqual((byte)0x00, b97[6]);
Assert.AreEqual((byte)0x00, b97[7]);
// Check the contents of the 2nd block
Assert.AreEqual((byte)0x81, b98[0]);
Assert.AreEqual((byte)0x00, b98[1]);
Assert.AreEqual((byte)0x00, b98[2]);
Assert.AreEqual((byte)0x00, b98[3]);
Assert.AreEqual((byte)0x82, b98[4]);
Assert.AreEqual((byte)0x00, b98[5]);
Assert.AreEqual((byte)0x00, b98[6]);
Assert.AreEqual((byte)0x00, b98[7]);
fs.Close();
}
public void TestReadFailsOnLoop()
{
NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.GetFile("BlockSize512.zvi"));
// Hack the FAT so that it goes 0->1->2->0
fs.SetNextBlock(0, 1);
fs.SetNextBlock(1, 2);
fs.SetNextBlock(2, 0);
// Now try to read
NPOIFSStream stream = new NPOIFSStream(fs, 0);
IEnumerator<ByteBuffer> i = stream.GetBlockIterator();
//1st read works
Assert.AreEqual(true, i.MoveNext());
// 1st read works
// i.MoveNext();
// 2nd read works
Assert.AreEqual(true, i.MoveNext());
// i.MoveNext();
// Assert.AreEqual(true, i.MoveNext());
// 3rd read works
//i.MoveNext();
Assert.AreEqual(true, i.MoveNext());
// 4th read blows up as it loops back to 0
try
{
i.MoveNext();
Assert.AreEqual(true, i.MoveNext());
Assert.Fail("Loop should have been detected but wasn't!");
}
catch (Exception)
{
// Good, it was detected
}
// Assert.AreEqual(true, i.MoveNext());
}
/**
* Constructor for a new Document
*
* @param name the name of the POIFSDocument
* @param stream the InputStream we read data from
*/
public NPOIFSDocument(String name, NPOIFSFileSystem filesystem, Stream stream)
{
this._filesystem = filesystem;
// Buffer the contents into memory. This is a bit icky...
// TODO Replace with a buffer up to the mini stream size, then streaming write
byte[] contents;
if (stream is MemoryStream)
{
MemoryStream bais = (MemoryStream)stream;
contents = new byte[bais.Length];
bais.Read(contents, 0, contents.Length);
}
else
{
MemoryStream baos = new MemoryStream();
IOUtils.Copy(stream, baos);
contents = baos.ToArray();
}
// Do we need to store as a mini stream or a full one?
if (contents.Length <= POIFSConstants.BIG_BLOCK_MINIMUM_DOCUMENT_SIZE)
{
_stream = new NPOIFSStream(filesystem.GetMiniStore());
_block_size = _filesystem.GetMiniStore().GetBlockStoreBlockSize();
}
else
{
_stream = new NPOIFSStream(filesystem);
_block_size = _filesystem.GetBlockStoreBlockSize();
}
// Store it
_stream.UpdateContents(contents);
// And build the property for it
this._property = new DocumentProperty(name, contents.Length);
_property.StartBlock = _stream.GetStartBlock();
}
/**
* Constructor for a new Document
*
* @param name the name of the POIFSDocument
* @param stream the InputStream we read data from
*/
public NPOIFSDocument(String name, NPOIFSFileSystem filesystem, Stream stream)
{
this._filesystem = filesystem;
// Buffer the contents into memory. This is a bit icky...
// TODO Replace with a buffer up to the mini stream size, then streaming write
byte[] contents;
if (stream is MemoryStream)
{
MemoryStream bais = (MemoryStream)stream;
contents = new byte[bais.Length];
bais.Read(contents, 0, contents.Length);
}
else
{
MemoryStream baos = new MemoryStream();
IOUtils.Copy(stream, baos);
contents = baos.ToArray();
}
// Do we need to store as a mini stream or a full one?
if (contents.Length <= POIFSConstants.BIG_BLOCK_MINIMUM_DOCUMENT_SIZE)
{
_stream = new NPOIFSStream(filesystem.GetMiniStore());
_block_size = _filesystem.GetMiniStore().GetBlockStoreBlockSize();
}
else
{
_stream = new NPOIFSStream(filesystem);
_block_size = _filesystem.GetBlockStoreBlockSize();
}
// Store it
_stream.UpdateContents(contents);
// And build the property for it
this._property = new DocumentProperty(name, contents.Length);
_property.StartBlock = _stream.GetStartBlock();
}
/// <summary>
/// Wrap the OLE2 data in the NPOIFSFileSystem into a decrypted stream by using the given password.
/// </summary>
/// <param name="fs">The OLE2 stream for the document</param>
/// <param name="password">The password, null if the default password should be used</param>
/// <returns>A stream for reading the decrypted data</returns>
/// <exception cref="System.IO.IOException">If an error occurs while decrypting or if the password does not match</exception>
public static InputStream GetDecryptedStream(NPOIFSFileSystem fs, String password)
{
EncryptionInfo info = new EncryptionInfo(fs);
Decryptor d = Decryptor.GetInstance(info);
try
{
bool passwordCorrect = false;
if (password != null && d.VerifyPassword(password))
{
passwordCorrect = true;
}
if (!passwordCorrect && d.VerifyPassword(Decryptor.DEFAULT_PASSWORD))
{
passwordCorrect = true;
}
if (passwordCorrect)
{
return(new FilterInputStream1(d.GetDataStream(fs.Root), fs));
}
else
{
if (password != null)
{
throw new EncryptedDocumentException("Password incorrect");
}
else
{
throw new EncryptedDocumentException("The supplied spreadsheet is protected, but no password was supplied");
}
}
}
catch (Exception e)
{
throw new IOException("password does not match", e);
}
}
public void TestFiles()
{
FileStream[] files = {
// bug 51891
POIDataSamples.GetPOIFSInstance().GetFile("multimedia.doc"),
// tika bug 1072
POIDataSamples.GetPOIFSInstance().GetFile("20-Force-on-a-current-S00.doc"),
// other files Containing ole10native records ...
POIDataSamples.GetDocumentInstance().GetFile("Bug53380_3.doc"),
POIDataSamples.GetDocumentInstance().GetFile("Bug47731.doc")
};
foreach (FileStream f in files)
{
NPOIFSFileSystem fs = new NPOIFSFileSystem(f,null, true, true);
List<Entry> entries = new List<Entry>();
FindOle10(entries, fs.Root, "/", "");
foreach (Entry e in entries)
{
MemoryStream bosExp = new MemoryStream();
Stream is1 = ((DirectoryNode)e.Parent).CreateDocumentInputStream(e);
IOUtils.Copy(is1, bosExp);
is1.Close();
Ole10Native ole = Ole10Native.CreateFromEmbeddedOleObject((DirectoryNode)e.Parent);
MemoryStream bosAct = new MemoryStream();
ole.WriteOut(bosAct);
//assertThat(bosExp.ToByteArray(), EqualTo(bosAct.ToByteArray()));
Assert.IsTrue(Arrays.Equals(bosExp.ToArray(), bosAct.ToArray()));
}
fs.Close();
}
}
/// <summary>
/// Create a DirectoryNode. This method Is not public by design; it
/// Is intended strictly for the internal use of this package
/// </summary>
/// <param name="property">the DirectoryProperty for this DirectoryEntry</param>
/// <param name="nFileSystem">the POIFSFileSystem we belong to</param>
/// <param name="parent">the parent of this entry</param>
public DirectoryNode(DirectoryProperty property,
NPOIFSFileSystem nFileSystem,
DirectoryNode parent)
: this(property, parent, (POIFSFileSystem)null, nFileSystem)
{
}
public void TestReadLongerStream()
{
NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.GetFile("BlockSize512.zvi"));
ByteBuffer b0 = null;
ByteBuffer b1 = null;
ByteBuffer b22 = null;
// The stream at 0 has 23 blocks in it
NPOIFSStream stream = new NPOIFSStream(fs, 0);
IEnumerator<ByteBuffer> i = stream.GetBlockIterator();
int count = 0;
while (i.MoveNext())
{
ByteBuffer b = i.Current;
if (count == 0)
{
b0 = b;
}
if (count == 1)
{
b1 = b;
}
if (count == 22)
{
b22 = b;
}
count++;
}
Assert.AreEqual(23, count);
// Check the contents
// 1st block is at 0
Assert.AreEqual((byte)0x9e, b0[0]);
Assert.AreEqual((byte)0x75, b0[1]);
Assert.AreEqual((byte)0x97, b0[2]);
Assert.AreEqual((byte)0xf6, b0[3]);
// 2nd block is at 1
Assert.AreEqual((byte)0x86, b1[0]);
Assert.AreEqual((byte)0x09, b1[1]);
Assert.AreEqual((byte)0x22, b1[2]);
Assert.AreEqual((byte)0xfb, b1[3]);
// last block is at 89
Assert.AreEqual((byte)0xfe, b22[0]);
Assert.AreEqual((byte)0xff, b22[1]);
Assert.AreEqual((byte)0x00, b22[2]);
Assert.AreEqual((byte)0x00, b22[3]);
Assert.AreEqual((byte)0x05, b22[4]);
Assert.AreEqual((byte)0x01, b22[5]);
Assert.AreEqual((byte)0x02, b22[6]);
Assert.AreEqual((byte)0x00, b22[7]);
}
public EncryptionInfo(NPOIFSFileSystem fs)
: this(fs.Root)
{
}
public void TestReplaceStream()
{
NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi"));
byte[] data = new byte[512];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)(i % 256);
}
// 98 is actually the last block in a two block stream...
NPOIFSStream stream = new NPOIFSStream(fs, 98);
stream.UpdateContents(data);
// Check the reading of blocks
IEnumerator<ByteBuffer> it = stream.GetBlockIterator();
Assert.AreEqual(true, it.MoveNext());
// it.MoveNext();
ByteBuffer b = it.Current;
Assert.AreEqual(false, it.MoveNext());
// Now check the contents
data = new byte[512];
b.Read(data);
for (int i = 0; i < data.Length; i++)
{
byte exp = (byte)(i % 256);
Assert.AreEqual(exp, data[i]);
}
}
public void TestWriteStream4096()
{
NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize4096.zvi"));
// 0 -> 1 -> 2 -> end
Assert.AreEqual(1, fs.GetNextBlock(0));
Assert.AreEqual(2, fs.GetNextBlock(1));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(2));
Assert.AreEqual(4, fs.GetNextBlock(3));
// First free one is at 15
Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, fs.GetNextBlock(14));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(15));
// Write a 5 block file
byte[] data = new byte[4096 * 5];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)(i % 256);
}
NPOIFSStream stream = new NPOIFSStream(fs, 0);
stream.UpdateContents(data);
// Check it
Assert.AreEqual(1, fs.GetNextBlock(0));
Assert.AreEqual(2, fs.GetNextBlock(1));
Assert.AreEqual(15, fs.GetNextBlock(2)); // Jumps
Assert.AreEqual(4, fs.GetNextBlock(3)); // Next stream
Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, fs.GetNextBlock(14));
Assert.AreEqual(16, fs.GetNextBlock(15)); // Continues
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(16)); // Ends
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(17)); // Free
// Check the contents too
IEnumerator<ByteBuffer> it = stream.GetBlockIterator();
int count = 0;
while (it.MoveNext())
{
ByteBuffer b = it.Current;
data = new byte[512];
// b.get(data);
// Array.Copy(b, 0, data, 0, b.Length);
b.Read(data);
for (int i = 0; i < data.Length; i++)
{
byte exp = (byte)(i % 256);
Assert.AreEqual(exp, data[i]);
}
count++;
}
Assert.AreEqual(5, count);
}
public void TestWriteMiniStreams()
{
NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi"));
NPOIFSMiniStore ministore = fs.GetMiniStore();
NPOIFSStream stream = new NPOIFSStream(ministore, 178);
// 178 -> 179 -> 180 -> end
Assert.AreEqual(179, ministore.GetNextBlock(178));
Assert.AreEqual(180, ministore.GetNextBlock(179));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, ministore.GetNextBlock(180));
// Try writing 3 full blocks worth
byte[] data = new byte[64 * 3];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)i;
}
stream = new NPOIFSStream(ministore, 178);
stream.UpdateContents(data);
// Check
Assert.AreEqual(179, ministore.GetNextBlock(178));
Assert.AreEqual(180, ministore.GetNextBlock(179));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, ministore.GetNextBlock(180));
stream = new NPOIFSStream(ministore, 178);
IEnumerator<ByteBuffer> it = stream.GetBlockIterator();
it.MoveNext();
ByteBuffer b178 = it.Current;
it.MoveNext();
ByteBuffer b179 = it.Current;
it.MoveNext();
ByteBuffer b180 = it.Current;
Assert.AreEqual(false, it.MoveNext());
Assert.AreEqual((byte)0x00, b178.Read());
Assert.AreEqual((byte)0x01, b178.Read());
Assert.AreEqual((byte)0x40, b179.Read());
Assert.AreEqual((byte)0x41, b179.Read());
Assert.AreEqual((byte)0x80, b180.Read());
Assert.AreEqual((byte)0x81, b180.Read());
// Try writing just into 3 blocks worth
data = new byte[64 * 2 + 12];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)(i + 4);
}
stream = new NPOIFSStream(ministore, 178);
stream.UpdateContents(data);
// Check
Assert.AreEqual(179, ministore.GetNextBlock(178));
Assert.AreEqual(180, ministore.GetNextBlock(179));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, ministore.GetNextBlock(180));
stream = new NPOIFSStream(ministore, 178);
it = stream.GetBlockIterator();
it.MoveNext();
b178 = it.Current;
it.MoveNext();
b179 = it.Current;
it.MoveNext();
b180 = it.Current;
Assert.AreEqual(false, it.MoveNext());
Assert.AreEqual((byte)0x04, b178.Read());
Assert.AreEqual((byte)0x05, b178.Read());
Assert.AreEqual((byte)0x44, b179.Read());
Assert.AreEqual((byte)0x45, b179.Read());
Assert.AreEqual((byte)0x84, b180.Read());
Assert.AreEqual((byte)0x85, b180.Read());
// Try writing 1, should truncate
data = new byte[12];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)(i + 9);
}
stream = new NPOIFSStream(ministore, 178);
stream.UpdateContents(data);
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, ministore.GetNextBlock(178));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(179));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(180));
stream = new NPOIFSStream(ministore, 178);
it = stream.GetBlockIterator();
it.MoveNext();
b178 = it.Current;
Assert.AreEqual(false, it.MoveNext());
Assert.AreEqual((byte)0x09, b178[0]);
Assert.AreEqual((byte)0x0a, b178[1]);
// Try writing 5, should extend
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, ministore.GetNextBlock(178));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(179));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(180));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(181));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(182));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(183));
data = new byte[64 * 4 + 12];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)(i + 3);
}
stream = new NPOIFSStream(ministore, 178);
stream.UpdateContents(data);
Assert.AreEqual(179, ministore.GetNextBlock(178));
Assert.AreEqual(180, ministore.GetNextBlock(179));
Assert.AreEqual(181, ministore.GetNextBlock(180));
Assert.AreEqual(182, ministore.GetNextBlock(181));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, ministore.GetNextBlock(182));
stream = new NPOIFSStream(ministore, 178);
it = stream.GetBlockIterator();
it.MoveNext();
b178 = it.Current;
it.MoveNext();
b179 = it.Current;
it.MoveNext();
b180 = it.Current;
it.MoveNext();
ByteBuffer b181 = it.Current;
it.MoveNext();
ByteBuffer b182 = it.Current;
Assert.AreEqual(false, it.MoveNext());
Assert.AreEqual((byte)0x03, b178[0]);
Assert.AreEqual((byte)0x04, b178[1]);
Assert.AreEqual((byte)0x43, b179[0]);
Assert.AreEqual((byte)0x44, b179[1]);
Assert.AreEqual((byte)0x83, b180[0]);
Assert.AreEqual((byte)0x84, b180[1]);
Assert.AreEqual((byte)0xc3, b181[0]);
Assert.AreEqual((byte)0xc4, b181[1]);
Assert.AreEqual((byte)0x03, b182[0]);
Assert.AreEqual((byte)0x04, b182[1]);
// Write lots, so it needs another big block
ministore.GetBlockAt(183);
try
{
ministore.GetBlockAt(184);
Assert.Fail("Block 184 should be off the end of the list");
}
// catch (ArgumentOutOfRangeException e)
catch(Exception)
{
}
data = new byte[64 * 6 + 12];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)(i + 1);
}
stream = new NPOIFSStream(ministore, 178);
stream.UpdateContents(data);
// Should have added 2 more blocks to the chain
Assert.AreEqual(179, ministore.GetNextBlock(178));
Assert.AreEqual(180, ministore.GetNextBlock(179));
Assert.AreEqual(181, ministore.GetNextBlock(180));
Assert.AreEqual(182, ministore.GetNextBlock(181));
Assert.AreEqual(183, ministore.GetNextBlock(182));
Assert.AreEqual(184, ministore.GetNextBlock(183));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, ministore.GetNextBlock(184));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(185));
// Block 184 should exist
ministore.GetBlockAt(183);
ministore.GetBlockAt(184);
ministore.GetBlockAt(185);
// Check contents
stream = new NPOIFSStream(ministore, 178);
it = stream.GetBlockIterator();
it.MoveNext();
b178 = it.Current;
it.MoveNext();
b179 = it.Current;
it.MoveNext();
b180 = it.Current;
it.MoveNext();
b181 = it.Current;
it.MoveNext();
b182 = it.Current;
it.MoveNext();
ByteBuffer b183 = it.Current;
it.MoveNext();
ByteBuffer b184 = it.Current;
Assert.AreEqual(false, it.MoveNext());
Assert.AreEqual((byte)0x01, b178[0]);
Assert.AreEqual((byte)0x02, b178[1]);
Assert.AreEqual((byte)0x41, b179[0]);
Assert.AreEqual((byte)0x42, b179[1]);
Assert.AreEqual((byte)0x81, b180[0]);
Assert.AreEqual((byte)0x82, b180[1]);
Assert.AreEqual((byte)0xc1, b181[0]);
Assert.AreEqual((byte)0xc2, b181[1]);
Assert.AreEqual((byte)0x01, b182[0]);
Assert.AreEqual((byte)0x02, b182[1]);
Assert.AreEqual((byte)0x41, b183[0]);
Assert.AreEqual((byte)0x42, b183[1]);
Assert.AreEqual((byte)0x81, b184[0]);
Assert.AreEqual((byte)0x82, b184[1]);
}
/**
* Checks if the supplied first 8 bytes of a stream / file
* has a POIFS (OLE2) header.
*/
public static new bool HasPOIFSHeader(byte[] header8Bytes)
{
return(NPOIFSFileSystem.HasPOIFSHeader(header8Bytes));
}
public void TestReadStream4096()
{
NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.GetFile("BlockSize4096.zvi"));
// 0 -> 1 -> 2 -> end
NPOIFSStream stream = new NPOIFSStream(fs, 0);
IEnumerator<ByteBuffer> i = stream.GetBlockIterator();
Assert.AreEqual(true, i.MoveNext());
// i.MoveNext();
ByteBuffer b0 = i.Current;
Assert.AreEqual(true, i.MoveNext());
// i.MoveNext();
ByteBuffer b1 = i.Current;
Assert.AreEqual(true, i.MoveNext());
// i.MoveNext();
ByteBuffer b2 = i.Current;
Assert.AreEqual(false, i.MoveNext());
// Check the contents of the 1st block
Assert.AreEqual((byte)0x9E, b0[0]);
Assert.AreEqual((byte)0x75, b0[1]);
Assert.AreEqual((byte)0x97, b0[2]);
Assert.AreEqual((byte)0xF6, b0[3]);
Assert.AreEqual((byte)0xFF, b0[4]);
Assert.AreEqual((byte)0x21, b0[5]);
Assert.AreEqual((byte)0xD2, b0[6]);
Assert.AreEqual((byte)0x11, b0[7]);
// Check the contents of the 2nd block
Assert.AreEqual((byte)0x00, b1[0]);
Assert.AreEqual((byte)0x00, b1[1]);
Assert.AreEqual((byte)0x03, b1[2]);
Assert.AreEqual((byte)0x00, b1[3]);
Assert.AreEqual((byte)0x00, b1[4]);
Assert.AreEqual((byte)0x00, b1[5]);
Assert.AreEqual((byte)0x00, b1[6]);
Assert.AreEqual((byte)0x00, b1[7]);
// Check the contents of the 3rd block
Assert.AreEqual((byte)0x6D, b2[0]);
Assert.AreEqual((byte)0x00, b2[1]);
Assert.AreEqual((byte)0x00, b2[2]);
Assert.AreEqual((byte)0x00, b2[3]);
Assert.AreEqual((byte)0x03, b2[4]);
Assert.AreEqual((byte)0x00, b2[5]);
Assert.AreEqual((byte)0x46, b2[6]);
Assert.AreEqual((byte)0x00, b2[7]);
}
public void TestWriteNewStream()
{
NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi"));
// 100 is our first free one
Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, fs.GetNextBlock(99));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(100));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(101));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(102));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(103));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(104));
// Add a single block one
byte[] data = new byte[512];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)(i % 256);
}
NPOIFSStream stream = new NPOIFSStream(fs);
stream.UpdateContents(data);
// Check it was allocated properly
Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, fs.GetNextBlock(99));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(100));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(101));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(102));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(103));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(104));
// And check the contents
IEnumerator<ByteBuffer> it = stream.GetBlockIterator();
int count = 0;
while (it.MoveNext())
{
ByteBuffer b = it.Current;
data = new byte[512];
//b.get(data);
//Array.Copy(b, 0, data, 0, b.Length);
b.Read(data);
for (int i = 0; i < data.Length; i++)
{
byte exp = (byte)(i % 256);
Assert.AreEqual(exp, data[i]);
}
count++;
}
Assert.AreEqual(1, count);
// And a multi block one
data = new byte[512 * 3];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)(i % 256);
}
stream = new NPOIFSStream(fs);
stream.UpdateContents(data);
// Check it was allocated properly
Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, fs.GetNextBlock(99));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(100));
Assert.AreEqual(102, fs.GetNextBlock(101));
Assert.AreEqual(103, fs.GetNextBlock(102));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(103));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(104));
// And check the contents
it = stream.GetBlockIterator();
count = 0;
while (it.MoveNext())
{
ByteBuffer b = it.Current;
data = new byte[512];
//b.get(data);
// Array.Copy(b, 0, data, 0, b.Length);
b.Read(data);
for (int i = 0; i < data.Length; i++)
{
byte exp = (byte)(i % 256);
Assert.AreEqual(exp, data[i]);
}
count++;
}
Assert.AreEqual(3, count);
// Free it
stream.free();
Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, fs.GetNextBlock(99));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(100));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(101));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(102));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(103));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(104));
}
public void TestReplaceStreamWithMore()
{
NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi"));
byte[] data = new byte[512 * 3];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)(i % 256);
}
// 97 -> 98 -> end
Assert.AreEqual(98, fs.GetNextBlock(97));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(98));
// 100 is our first free one
Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, fs.GetNextBlock(99));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(100));
// Create a 2 block stream, will become a 3 block one
NPOIFSStream stream = new NPOIFSStream(fs, 97);
stream.UpdateContents(data);
// 97 -> 98 -> 100 -> end
Assert.AreEqual(98, fs.GetNextBlock(97));
Assert.AreEqual(100, fs.GetNextBlock(98));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(100));
// Check the reading of blocks
IEnumerator<ByteBuffer> it = stream.GetBlockIterator();
int count = 0;
while (it.MoveNext())
{
ByteBuffer b = it.Current;
data = new byte[512];
//b.get(data);
//Array.Copy(b, 0, data, 0, b.Length);
b.Read(data);
for (int i = 0; i < data.Length; i++)
{
byte exp = (byte)(i % 256);
Assert.AreEqual(exp, data[i]);
}
count++;
}
Assert.AreEqual(3, count);
}
/// <summary>
/// Checks that the supplied Stream(which MUST
/// support mark and reset, or be a PushbackInputStream)
/// has a POIFS (OLE2) header at the start of it.
/// If your Streamdoes not support mark / reset,
/// then wrap it in a PushBackInputStream, then be
/// sure to always use that, and not the original!
/// </summary>
/// <param name="inp">An Streamwhich supports either mark/reset, or is a PushbackStream</param>
/// <returns>
/// <c>true</c> if [has POIFS header] [the specified inp]; otherwise, <c>false</c>.
/// </returns>
public static new bool HasPOIFSHeader(Stream inp)
{
return(NPOIFSFileSystem.HasPOIFSHeader(inp));
}
public HPSFPropertiesExtractor(NPOIFSFileSystem fs)
: base(new HPSFPropertiesOnlyDocument(fs))
{
}
public void TestWriteFailsOnLoop()
{
NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.GetFile("BlockSize512.zvi"));
// Hack the FAT so that it goes 0->1->2->0
fs.SetNextBlock(0, 1);
fs.SetNextBlock(1, 2);
fs.SetNextBlock(2, 0);
// Try to write a large amount, should fail on the write
byte[] data = new byte[512 * 4];
NPOIFSStream stream = new NPOIFSStream(fs, 0);
try
{
stream.UpdateContents(data);
Assert.Fail("Loop should have been detected but wasn't!");
}
catch (Exception) { }
// Now reset, and try on a small bit
// Should fail during the freeing set
fs.SetNextBlock(0, 1);
fs.SetNextBlock(1, 2);
fs.SetNextBlock(2, 0);
data = new byte[512];
stream = new NPOIFSStream(fs, 0);
try
{
stream.UpdateContents(data);
Assert.Fail("Loop should have been detected but wasn't!");
}
catch (Exception) { }
}
public void TestCreateBlockIfNeeded()
{
NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi"));
NPOIFSMiniStore ministore = fs.GetMiniStore();
// 178 -> 179 -> 180, 181+ is free
Assert.AreEqual(179, ministore.GetNextBlock(178));
Assert.AreEqual(180, ministore.GetNextBlock(179));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, ministore.GetNextBlock(180));
for (int i = 181; i < 256; i++)
{
Assert.AreEqual(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);
Assert.Fail("No block at 184");
}
catch (IndexOutOfRangeException) { }
// The ministore itself is made up of 23 big blocks
IEnumerator<ByteBuffer> it = new NPOIFSStream(fs, fs.Root.Property.StartBlock).GetBlockIterator();
int count = 0;
while (it.MoveNext())
{
count++;
//it.MoveNext();
}
Assert.AreEqual(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 NPOIFSStream(fs, fs.Root.Property.StartBlock).GetBlockIterator();
count = 0;
while (it.MoveNext())
{
count++;
//it.MoveNext();
}
Assert.AreEqual(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);
Assert.Fail("No block at 192");
}
catch (IndexOutOfRangeException) { }
// Now try writing through to 192, check that the SBAT and blocks are there
byte[] data = new byte[15 * 64];
NPOIFSStream stream = new NPOIFSStream(ministore, 178);
stream.UpdateContents(data);
// Check now
Assert.AreEqual(179, ministore.GetNextBlock(178));
Assert.AreEqual(180, ministore.GetNextBlock(179));
Assert.AreEqual(181, ministore.GetNextBlock(180));
Assert.AreEqual(182, ministore.GetNextBlock(181));
Assert.AreEqual(183, ministore.GetNextBlock(182));
Assert.AreEqual(184, ministore.GetNextBlock(183));
Assert.AreEqual(185, ministore.GetNextBlock(184));
Assert.AreEqual(186, ministore.GetNextBlock(185));
Assert.AreEqual(187, ministore.GetNextBlock(186));
Assert.AreEqual(188, ministore.GetNextBlock(187));
Assert.AreEqual(189, ministore.GetNextBlock(188));
Assert.AreEqual(190, ministore.GetNextBlock(189));
Assert.AreEqual(191, ministore.GetNextBlock(190));
Assert.AreEqual(192, ministore.GetNextBlock(191));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, ministore.GetNextBlock(192));
for (int i = 193; i < 256; i++)
{
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(i));
}
}
public void TestReadWriteNewStream()
{
NPOIFSFileSystem fs = new NPOIFSFileSystem();
NPOIFSStream stream = new NPOIFSStream(fs);
// Check our filesystem has a BAT and the Properties
Assert.AreEqual(2, fs.GetFreeBlock());
BATBlock bat = fs.GetBATBlockAndIndex(0).Block;
Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, bat.GetValueAt(0));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, bat.GetValueAt(1));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, bat.GetValueAt(2));
// Check the stream as-is
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, stream.GetStartBlock());
try
{
stream.GetBlockIterator();
Assert.Fail("Shouldn't be able to get an iterator before writing");
}
catch (Exception) { }
// Write in two blocks
byte[] data = new byte[512 + 20];
for (int i = 0; i < 512; i++)
{
data[i] = (byte)(i % 256);
}
for (int i = 512; i < data.Length; i++)
{
data[i] = (byte)(i % 256 + 100);
}
stream.UpdateContents(data);
// Check now
Assert.AreEqual(4, fs.GetFreeBlock());
bat = fs.GetBATBlockAndIndex(0).Block;
Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, bat.GetValueAt(0));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, bat.GetValueAt(1));
Assert.AreEqual(3, bat.GetValueAt(2));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, bat.GetValueAt(3));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, bat.GetValueAt(4));
IEnumerator<ByteBuffer> it = stream.GetBlockIterator();
Assert.AreEqual(true, it.MoveNext());
ByteBuffer b = it.Current;
byte[] read = new byte[512];
//b.get(read);
// Array.Copy(b, 0, read, 0, b.Length);
b.Read(read);
for (int i = 0; i < read.Length; i++)
{
//Assert.AreEqual("Wrong value at " + i, data[i], read[i]);
Assert.AreEqual(data[i], read[i], "Wrong value at " + i);
}
Assert.AreEqual(true, it.MoveNext());
b = it.Current;
read = new byte[512];
//b.get(read);
//Array.Copy(b, 0, read, 0, b.Length);
b.Read(read);
for (int i = 0; i < 20; i++)
{
Assert.AreEqual(data[i + 512], read[i]);
}
for (int i = 20; i < read.Length; i++)
{
Assert.AreEqual(0, read[i]);
}
Assert.AreEqual(false, it.MoveNext());
}
public void TestWriteWorkbookFromNPOIFS()
{
//throw new NotImplementedException("class NPOIFSFileSystem is not implemented");
Stream is1 = HSSFTestDataSamples.OpenSampleFileStream("WithEmbeddedObjects.xls");
NPOIFSFileSystem fs = new NPOIFSFileSystem(is1);
// Start as NPOIFS
HSSFWorkbook wb = new HSSFWorkbook(fs.Root, true);
Assert.AreEqual(3, wb.NumberOfSheets);
Assert.AreEqual("Root xls", wb.GetSheetAt(0).GetRow(0).GetCell(0).StringCellValue);
// Will switch to POIFS
wb = HSSFTestDataSamples.WriteOutAndReadBack(wb);
Assert.AreEqual(3, wb.NumberOfSheets);
Assert.AreEqual("Root xls", wb.GetSheetAt(0).GetRow(0).GetCell(0).StringCellValue);
fs.Close();
}
/**
* Copies all nodes from one POIFS to the other
*
* @param source
* is the source POIFS to copy from
* @param target
* is the target POIFS to copy to
*/
public static void CopyNodes(NPOIFSFileSystem source,
NPOIFSFileSystem target)
{
CopyNodes(source.Root, target.Root);
}
public FilterInputStream1(InputStream input, NPOIFSFileSystem fs)
: base(input)
{
this.fs = fs;
}
public void TestReadMiniStreams()
{
NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi"));
NPOIFSMiniStore ministore = fs.GetMiniStore();
// 178 -> 179 -> 180 -> end
NPOIFSStream stream = new NPOIFSStream(ministore, 178);
IEnumerator<ByteBuffer> i = stream.GetBlockIterator();
Assert.AreEqual(true, i.MoveNext());
// Assert.AreEqual(true, i.MoveNext());
// Assert.AreEqual(true, i.MoveNext());
// i.MoveNext();
ByteBuffer b178 = i.Current;
Assert.AreEqual(true, i.MoveNext());
// Assert.AreEqual(true, i.MoveNext());
// i.MoveNext();
ByteBuffer b179 = i.Current;
Assert.AreEqual(true, i.MoveNext());
// i.MoveNext();
ByteBuffer b180 = i.Current;
Assert.AreEqual(false, i.MoveNext());
// Assert.AreEqual(false, i.MoveNext());
// Assert.AreEqual(false, i.MoveNext());
// Check the contents of the 1st block
Assert.AreEqual((byte)0xfe, b178[0]);
Assert.AreEqual((byte)0xff, b178[1]);
Assert.AreEqual((byte)0x00, b178[2]);
Assert.AreEqual((byte)0x00, b178[3]);
Assert.AreEqual((byte)0x05, b178[4]);
Assert.AreEqual((byte)0x01, b178[5]);
Assert.AreEqual((byte)0x02, b178[6]);
Assert.AreEqual((byte)0x00, b178[7]);
// And the 2nd
Assert.AreEqual((byte)0x6c, b179[0]);
Assert.AreEqual((byte)0x00, b179[1]);
Assert.AreEqual((byte)0x00, b179[2]);
Assert.AreEqual((byte)0x00, b179[3]);
Assert.AreEqual((byte)0x28, b179[4]);
Assert.AreEqual((byte)0x00, b179[5]);
Assert.AreEqual((byte)0x00, b179[6]);
Assert.AreEqual((byte)0x00, b179[7]);
// And the 3rd
Assert.AreEqual((byte)0x30, b180[0]);
Assert.AreEqual((byte)0x00, b180[1]);
Assert.AreEqual((byte)0x00, b180[2]);
Assert.AreEqual((byte)0x00, b180[3]);
Assert.AreEqual((byte)0x00, b180[4]);
Assert.AreEqual((byte)0x00, b180[5]);
Assert.AreEqual((byte)0x00, b180[6]);
Assert.AreEqual((byte)0x80, b180[7]);
}
public void TestReplaceStreamWithLess()
{
NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi"));
byte[] data = new byte[512];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)(i % 256);
}
// 97 -> 98 -> end
Assert.AreEqual(98, fs.GetNextBlock(97));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(98));
// Create a 2 block stream, will become a 1 block one
NPOIFSStream stream = new NPOIFSStream(fs, 97);
stream.UpdateContents(data);
// 97 should now be the end, and 98 free
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(97));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(98));
// Check the reading of blocks
IEnumerator<ByteBuffer> it = stream.GetBlockIterator();
Assert.AreEqual(true, it.MoveNext());
ByteBuffer b = it.Current;
Assert.AreEqual(false, it.MoveNext());
// Now check the contents
data = new byte[512];
// b.get(data);
//for (int i = 0; i < b.Length; i++)
// data[i] = b[i];
//Array.Copy(b, 0, data, 0, b.Length);
b.Read(data);
for (int i = 0; i < data.Length; i++)
{
byte exp = (byte)(i % 256);
Assert.AreEqual(exp, data[i]);
}
}
public void TestWriteNewStreamExtraFATs()
{
NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi"));
// Allocate almost all the blocks
Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, fs.GetNextBlock(99));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(100));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(127));
for (int i = 100; i < 127; i++)
{
fs.SetNextBlock(i, POIFSConstants.END_OF_CHAIN);
}
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(127));
Assert.AreEqual(true, fs.GetBATBlockAndIndex(0).Block.HasFreeSectors);
// Write a 3 block stream
byte[] data = new byte[512 * 3];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)(i % 256);
}
NPOIFSStream stream = new NPOIFSStream(fs);
stream.UpdateContents(data);
// Check we got another BAT
Assert.AreEqual(false, fs.GetBATBlockAndIndex(0).Block.HasFreeSectors);
Assert.AreEqual(true, fs.GetBATBlockAndIndex(128).Block.HasFreeSectors);
// the BAT will be in the first spot of the new block
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(126));
Assert.AreEqual(129, fs.GetNextBlock(127));
Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, fs.GetNextBlock(128));
Assert.AreEqual(130, fs.GetNextBlock(129));
Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(130));
Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(131));
}
