public void Write(NPOIFSStream stream)
{
try
{
//Leon ByteArrayOutputStream -->MemoryStream
MemoryStream ms = new MemoryStream();
foreach (Property property in _properties)
{
if (property != null)
{
property.WriteData(ms);
}
}
stream.UpdateContents(ms.ToArray());
// Update the start position if needed
if (StartBlock != stream.GetStartBlock())
{
StartBlock = stream.GetStartBlock();
}
}
catch (System.IO.IOException ex)
{
throw ex;
}
}
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 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 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);
fs.Close();
}
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);
fs.Close();
}
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]);
}
fs.Close();
}
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));
fs.Close();
}
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 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 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 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]);
}
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 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));
}
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);
}
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));
fs.Close();
}
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));
}
fs.Close();
}
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));
}
fs.Close();
}
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());
fs.Close();
}
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]);
fs.Close();
}
public void Write(NPOIFSStream stream)
{
try
{
//Leon ByteArrayOutputStream -->MemoryStream
MemoryStream ms = new MemoryStream();
foreach(Property property in _properties)
{
if(property != null)
property.WriteData(ms);
}
stream.UpdateContents(ms.ToArray());
// Update the start position if needed
if(StartBlock != stream.GetStartBlock())
{
StartBlock = stream.GetStartBlock();
}
}
catch(System.IO.IOException ex)
{
throw ex;
}
}
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]);
}
}
