public void Test_DIFAT_CHECK()
{
CompoundFile f = null;
try
{
f = new CompoundFile();
CFStream st = f.RootStorage.AddStream("LargeStream");
st.Append(Helpers.GetBuffer(20000000, 0x0A)); //Forcing creation of two DIFAT sectors
byte[] b1 = Helpers.GetBuffer(3, 0x0B);
st.Append(b1); //Forcing creation of two DIFAT sectors
f.Save("$OpenMcdf$LargeFile.cfs");
f.Close();
int cnt = 3;
f = new CompoundFile("$OpenMcdf$LargeFile.cfs");
byte[] b2 = new byte[cnt];
cnt = f.RootStorage.GetStream("LargeStream").Read(b2, 20000000, cnt);
f.Close();
Assert.IsTrue(Helpers.CompareBuffer(b1, b2));
}
finally
{
if (f != null)
f.Close();
if (File.Exists("$OpenMcdf$LargeFile.cfs"))
File.Delete("$OpenMcdf$LargeFile.cfs");
}
}
public void Test_LAZY_LOAD_CHILDREN_()
{
CompoundFile cf = new CompoundFile();
cf.RootStorage.AddStorage("Level_1")
.AddStorage("Level_2")
.AddStream("Level2Stream")
.SetData(Helpers.GetBuffer(100));
cf.Save("$Hel1");
cf.Close();
cf = new CompoundFile("$Hel1");
IList <CFItem> i = cf.GetAllNamedEntries("Level2Stream");
Assert.IsNotNull(i[0]);
Assert.IsTrue(i[0] is CFStream);
Assert.IsTrue((i[0] as CFStream).GetData().Length == 100);
cf.Save("$Hel2");
cf.Close();
if (File.Exists("$Hel1"))
{
File.Delete("$Hel1");
}
if (File.Exists("$Hel2"))
{
File.Delete("$Hel2");
}
}
public void Test_WRITE_READ_CFS_VERSION_4_STREAM()
{
String filename = "WRITE_COMMIT_READ_CFS_V4.cfs";
CompoundFile cf = new CompoundFile(CFSVersion.Ver_4,
CFSConfiguration.SectorRecycle | CFSConfiguration.EraseFreeSectors);
CFStorage st = cf.RootStorage.AddStorage("MyStorage");
CFStream sm = st.AddStream("MyStream");
byte[] b = Helpers.GetBuffer(227);
sm.SetData(b);
cf.Save(filename);
cf.Close();
CompoundFile cf2 = new CompoundFile(filename);
CFStorage st2 = cf2.RootStorage.GetStorage("MyStorage");
CFStream sm2 = st2.GetStream("MyStream");
Assert.IsNotNull(sm2);
Assert.IsTrue(sm2.Size == b.Length);
cf2.Close();
}
public void Test_WRITE_STREAM_WITH_DIFAT()
{
//const int SIZE = 15388609; //Incredible condition of 'resonance' between FAT and DIFAT sec number
const int SIZE = 15345665; // 64 -> 65 NOT working (in the past ;-) )
byte[] b = Helpers.GetBuffer(SIZE, 0);
CompoundFile cf = new CompoundFile();
CFStream myStream = cf.RootStorage.AddStream("MyStream");
Assert.IsNotNull(myStream);
myStream.SetData(b);
cf.Save("WRITE_STREAM_WITH_DIFAT.cfs");
cf.Close();
CompoundFile cf2 = new CompoundFile("WRITE_STREAM_WITH_DIFAT.cfs");
CFStream st = cf2.RootStorage.GetStream("MyStream");
Assert.IsNotNull(cf2);
Assert.IsTrue(st.Size == SIZE);
Assert.IsTrue(Helpers.CompareBuffer(b, st.GetData()));
cf2.Close();
if (File.Exists("WRITE_STREAM_WITH_DIFAT.cfs"))
{
File.Delete("WRITE_STREAM_WITH_DIFAT.cfs");
}
}
public void Test_RESIZE_STREAM_TRANSITION_TO_NORMAL()
{
CompoundFile cf = null;
byte[] b = Helpers.GetBuffer(1024 * 2, 0xAA); //2MB buffer
cf = new CompoundFile(CFSVersion.Ver_3, CFSConfiguration.Default);
cf.RootStorage.AddStream("AStream").SetData(b);
cf.Save("$Test_RESIZE_STREAM_TRANSITION_TO_NORMAL.cfs");
cf.Save("$Test_RESIZE_STREAM_TRANSITION_TO_NORMAL2.cfs");
cf.Close();
cf = new CompoundFile("$Test_RESIZE_STREAM_TRANSITION_TO_NORMAL.cfs", CFSUpdateMode.Update,
CFSConfiguration.SectorRecycle | CFSConfiguration.EraseFreeSectors);
CFStream item = cf.RootStorage.GetStream("AStream");
item.Resize(5000);
cf.Commit();
cf.Close();
cf = new CompoundFile("$Test_RESIZE_STREAM_TRANSITION_TO_NORMAL.cfs", CFSUpdateMode.ReadOnly,
CFSConfiguration.Default);
item = cf.RootStorage.GetStream("AStream");
Assert.IsTrue(item != null);
Assert.IsTrue(item.Size == 5000);
byte[] buffer = new byte[2048];
item.Read(buffer, 0, 2048);
Assert.IsTrue(Helpers.CompareBuffer(b, buffer));
}
public void Test_APPEND_DATA_TO_CREATE_LARGE_STREAM()
{
byte[] b = Helpers.GetBuffer(1024 * 1024 * 50); //2GB buffer
byte[] cmp = new byte[] { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
CompoundFile cf = new CompoundFile(CFSVersion.Ver_4, false, false);
CFStream st = cf.RootStorage.AddStream("MySuperLargeStream");
cf.Save("MEGALARGESSIMUSFILE.cfs");
cf.Close();
cf = new CompoundFile("MEGALARGESSIMUSFILE.cfs", UpdateMode.Update, false, false);
CFStream cfst = cf.RootStorage.GetStream("MySuperLargeStream");
for (int i = 0; i < 42; i++)
{
cfst.AppendData(b);
cf.Commit(true);
}
cfst.AppendData(cmp);
cf.Commit(true);
cf.Close();
cf = new CompoundFile("MEGALARGESSIMUSFILE.cfs");
int count = 8;
byte[] data = cf.RootStorage.GetStream("MySuperLargeStream").GetData((long)b.Length * 42L, ref count);
Assert.IsTrue(Helpers.CompareBuffer(cmp, data));
cf.Close();
}
private void SingleWriteReadMatching(int size)
{
String filename = "INCREMENTAL_SIZE_MULTIPLE_WRITE_AND_READ_CFS.cfs";
if (File.Exists(filename))
{
File.Delete(filename);
}
CompoundFile cf = new CompoundFile();
CFStorage st = cf.RootStorage.AddStorage("MyStorage");
CFStream sm = st.AddStream("MyStream");
byte[] b = Helpers.GetBuffer(size);
sm.SetData(b);
cf.Save(filename);
cf.Close();
CompoundFile cf2 = new CompoundFile(filename);
CFStorage st2 = cf2.RootStorage.GetStorage("MyStorage");
CFStream sm2 = st2.GetStream("MyStream");
Assert.IsNotNull(sm2);
Assert.IsTrue(sm2.Size == size);
Assert.IsTrue(Helpers.CompareBuffer(sm2.GetData(), b));
cf2.Close();
}
public void Test_RESIZE_MINISTREAM_SECTOR_RECYCLE()
{
CompoundFile cf = null;
byte[] b = Helpers.GetBuffer(1024 * 2);
cf = new CompoundFile(CFSVersion.Ver_3, CFSConfiguration.Default);
cf.RootStorage.AddStream("MiniStream").SetData(b);
cf.Save("$Test_RESIZE_MINISTREAM_RECYCLE.cfs");
cf.Close();
cf = new CompoundFile("$Test_RESIZE_MINISTREAM_RECYCLE.cfs", CFSUpdateMode.Update,
CFSConfiguration.SectorRecycle | CFSConfiguration.EraseFreeSectors);
CFStream item = cf.RootStorage.GetStream("MiniStream");
item.Resize(item.Size / 2);
cf.Commit();
cf.Close();
cf = new CompoundFile("$Test_RESIZE_MINISTREAM_RECYCLE.cfs", CFSUpdateMode.ReadOnly,
CFSConfiguration.SectorRecycle | CFSConfiguration.EraseFreeSectors);
CFStream st = cf.RootStorage.AddStream("ANewStream");
st.SetData(Helpers.GetBuffer(400));
cf.Save("$Test_RESIZE_MINISTREAM_RECYCLE2.cfs");
cf.Close();
Assert.IsTrue(
new FileInfo("$Test_RESIZE_MINISTREAM_RECYCLE.cfs").Length
== new FileInfo("$Test_RESIZE_MINISTREAM_RECYCLE2.cfs").Length);
}
public void Test_LAZY_LOAD_CHILDREN_()
{
using (var cf = new CompoundFile())
{
cf.RootStorage.AddStorage("Level_1")
.AddStorage("Level_2")
.AddStream("Level2Stream")
.SetData(Helpers.GetBuffer(100));
cf.Save("$Hel1");
cf.Close();
}
using (var cf = new CompoundFile("$Hel1", CFSUpdateMode.ReadOnly, CFSConfiguration.Default))
{
IList <CFItem> i = cf.GetAllNamedEntries("Level2Stream");
Assert.IsNotNull(i[0]);
Assert.IsTrue(i[0] is CFStream);
Assert.IsTrue((i[0] as CFStream).GetData().Length == 100);
cf.Save("$Hel2");
cf.Close();
}
if (File.Exists("$Hel1"))
{
File.Delete("$Hel1");
}
if (File.Exists("$Hel2"))
{
File.Delete("$Hel2");
}
}
public void Test_WRITE_AND_READ_CFS()
{
String filename = "WRITE_AND_READ_CFS.cfs";
CompoundFile cf = new CompoundFile();
CFStorage st = cf.RootStorage.AddStorage("MyStorage");
CFStream sm = st.AddStream("MyStream");
byte[] b = Helpers.GetBuffer(220, 0x0A);
sm.SetData(b);
cf.Save(filename);
cf.Close();
CompoundFile cf2 = new CompoundFile(filename);
CFStorage st2 = cf2.RootStorage.GetStorage("MyStorage");
CFStream sm2 = st2.GetStream("MyStream");
cf2.Close();
Assert.IsNotNull(sm2);
Assert.IsTrue(sm2.Size == 220);
if (File.Exists(filename))
{
File.Delete(filename);
}
}
public void Test_TRANSACTED_ADD_MINISTREAM_TO_EXISTING_FILE()
{
String srcFilename = "report.xls";
String dstFilename = "reportOverwriteMultiple.xls";
File.Copy(srcFilename, dstFilename, true);
CompoundFile cf = new CompoundFile(dstFilename, CFSUpdateMode.Update,
CFSConfiguration.SectorRecycle | CFSConfiguration.EraseFreeSectors);
Random r = new Random();
byte[] buffer = Helpers.GetBuffer(31, 0x0A);
cf.RootStorage.AddStream("MyStream").SetData(buffer);
cf.Commit();
cf.Close();
FileStream larger = new FileStream(dstFilename, FileMode.Open);
FileStream smaller = new FileStream(srcFilename, FileMode.Open);
// Equal condition if minisector can be "allocated"
// within the existing standard sector border
Assert.IsTrue(larger.Length >= smaller.Length);
larger.Close();
smaller.Close();
if (File.Exists("reportOverwriteMultiple.xlsPP"))
{
File.Delete("reportOverwriteMultiple.xlsPP");
}
}
public void Test_TRANSACTED_REMOVE_MINI_STREAM_ADD_MINISTREAM_TO_EXISTING_FILE()
{
String srcFilename = "report.xls";
String dstFilename = "reportOverwrite2.xls";
File.Copy(srcFilename, dstFilename, true);
CompoundFile cf = new CompoundFile(dstFilename, CFSUpdateMode.Update,
CFSConfiguration.SectorRecycle | CFSConfiguration.EraseFreeSectors);
cf.RootStorage.Delete("\x05SummaryInformation");
byte[] buffer = Helpers.GetBuffer(2000);
CFStream addedStream = cf.RootStorage.AddStream("MyNewStream");
addedStream.SetData(buffer);
cf.Commit();
cf.Close();
if (File.Exists("reportOverwrite2.xlsPP"))
{
File.Delete("reportOverwrite2.xlsPP");
}
}
public void Test_ISSUE_2_WRONG_CUTOFF_SIZE()
{
FileStream fs = null;
try
{
if (File.Exists("TEST_ISSUE_2"))
{
File.Delete("TEST_ISSUE_2");
}
CompoundFile cf = new CompoundFile(CFSVersion.Ver_3, CFSConfiguration.Default);
var s = cf.RootStorage.AddStream("miniToNormal");
s.Append(Helpers.GetBuffer(4090, 0xAA));
cf.Save("TEST_ISSUE_2");
cf.Close();
var cf2 = new CompoundFile("TEST_ISSUE_2", CFSUpdateMode.Update, CFSConfiguration.Default);
cf2.RootStorage.GetStream("miniToNormal").Append(Helpers.GetBuffer(6, 0xBB));
cf2.Commit();
cf2.Close();
}
catch (Exception ex)
{
Assert.IsTrue(fs.CanRead && fs.CanSeek && fs.CanWrite);
}
}
public void Test_RE_WRITE_SMALLER_MINI_STREAM()
{
String filename = "report.xls";
CompoundFile cf = new CompoundFile(filename);
CFStream foundStream = cf.RootStorage.GetStream("\x05SummaryInformation");
int TEST_LENGTH = (int)foundStream.Size - 20;
byte[] b = Helpers.GetBuffer(TEST_LENGTH);
foundStream.SetData(b);
cf.Save("RE_WRITE_SMALLER_MINI_STREAM.xls");
cf.Close();
cf = new CompoundFile("RE_WRITE_SMALLER_MINI_STREAM.xls");
byte[] c = cf.RootStorage.GetStream("\x05SummaryInformation").GetData();
Assert.IsTrue(c.Length == TEST_LENGTH);
Assert.IsTrue(Helpers.CompareBuffer(c, b));
cf.Close();
if (File.Exists("RE_WRITE_SMALLER_MINI_STREAM.xls"))
{
File.Delete("RE_WRITE_SMALLER_MINI_STREAM.xls");
}
}
public void Test_RE_WRITE_SMALLER_STREAM()
{
const int BUFFER_LENGTH = 8000;
String filename = "report.xls";
byte[] b = Helpers.GetBuffer(BUFFER_LENGTH);
CompoundFile cf = new CompoundFile(filename);
CFStream foundStream = cf.RootStorage.GetStream("Workbook");
foundStream.SetData(b);
cf.Save("reportRW_SMALL.xls");
cf.Close();
cf = new CompoundFile("reportRW_SMALL.xls");
byte[] c = cf.RootStorage.GetStream("Workbook").GetData();
Assert.IsTrue(c.Length == BUFFER_LENGTH);
cf.Close();
if (File.Exists("reportRW_SMALL.xls"))
{
File.Delete("reportRW_SMALL.xls");
}
}
public void Test_RESIZE_MINISTREAM_NO_TRANSITION()
{
CompoundFile cf = null;
byte[] b = Helpers.GetBuffer(1024 * 2);
cf = new CompoundFile(CFSVersion.Ver_3, CFSConfiguration.Default);
cf.RootStorage.AddStream("MiniStream").SetData(b);
cf.Save("$Test_RESIZE_MINISTREAM.cfs");
cf.Close();
cf = new CompoundFile("$Test_RESIZE_MINISTREAM.cfs", CFSUpdateMode.Update,
CFSConfiguration.SectorRecycle | CFSConfiguration.EraseFreeSectors);
CFStream item = cf.RootStorage.GetStream("MiniStream");
item.Resize(item.Size / 2);
cf.Commit();
cf.Close();
cf = new CompoundFile("$Test_RESIZE_MINISTREAM.cfs", CFSUpdateMode.ReadOnly, CFSConfiguration.Default);
CFStream st = cf.RootStorage.GetStream("MiniStream");
Assert.IsNotNull(st);
Assert.IsTrue(st.Size == 1024);
byte[] buffer = new byte[1024];
st.Read(buffer, 0, 1024);
Assert.IsTrue(Helpers.CompareBuffer(b, buffer, 1024));
cf.Close();
}
public void Test_RESIZE_STREAM_TRANSITION_TO_MINI()
{
String FILE_NAME = "$Test_RESIZE_STREAM_TRANSITION_TO_MINI.cfs";
CompoundFile cf = null;
byte[] b = Helpers.GetBuffer(1024 * 1024 * 2); //2MB buffer
byte[] b100 = new byte[100];
for (int i = 0; i < 100; i++)
{
b100[i] = b[i];
}
cf = new CompoundFile(CFSVersion.Ver_3, CFSConfiguration.Default);
cf.RootStorage.AddStream("AStream").SetData(b);
cf.Save(FILE_NAME);
cf.Close();
cf = new CompoundFile(FILE_NAME, CFSUpdateMode.Update, CFSConfiguration.SectorRecycle);
CFStream item = cf.RootStorage.GetStream("AStream");
item.Resize(100);
cf.Commit();
cf.Close();
cf = new CompoundFile(FILE_NAME, CFSUpdateMode.ReadOnly, CFSConfiguration.Default);
Assert.IsTrue(Helpers.CompareBuffer(cf.RootStorage.GetStream("AStream").GetData(), b100));
cf.Close();
if (File.Exists(FILE_NAME))
{
File.Delete(FILE_NAME);
}
}
public void Test_AS_IOSTREAM_READ()
{
CompoundFile cf = new CompoundFile("MultipleStorage.cfs");
Stream s = cf.RootStorage.GetStorage("MyStorage").GetStream("MyStream").AsIoStream();
BinaryReader br = new BinaryReader(s);
byte[] result = br.ReadBytes(32);
Assert.IsTrue(Helpers.CompareBuffer(Helpers.GetBuffer(32, 1), result));
}
public void Test_ZERO_LENGTH_RE_WRITE_STREAM()
{
byte[] b = new byte[0];
CompoundFile cf = new CompoundFile();
CFStream myStream = cf.RootStorage.AddStream("MyStream");
Assert.IsNotNull(myStream);
try
{
myStream.SetData(b);
}
catch
{
Assert.Fail("Failed setting zero length stream");
}
cf.Save("ZERO_LENGTH_STREAM_RE.cfs");
cf.Close();
CompoundFile cfo = new CompoundFile("ZERO_LENGTH_STREAM_RE.cfs");
CFStream oStream = cfo.RootStorage.GetStream("MyStream");
Assert.IsNotNull(oStream);
Assert.IsTrue(oStream.Size == 0);
try
{
oStream.SetData(Helpers.GetBuffer(30));
cfo.Save("ZERO_LENGTH_STREAM_RE2.cfs");
}
catch
{
Assert.Fail("Failed re-writing zero length stream");
}
finally
{
cfo.Close();
}
if (File.Exists("ZERO_LENGTH_STREAM_RE.cfs"))
{
File.Delete("ZERO_LENGTH_STREAM_RE.cfs");
}
if (File.Exists("ZERO_LENGTH_STREAM_RE2.cfs"))
{
File.Delete("ZERO_LENGTH_STREAM_RE2.cfs");
}
}
public void Test_TRANSACTED_ADD_REMOVE_MULTIPLE_STREAM_TO_EXISTING_FILE()
{
String srcFilename = "report.xls";
String dstFilename = "reportOverwriteMultiple.xls";
File.Copy(srcFilename, dstFilename, true);
CompoundFile cf = new CompoundFile(dstFilename, CFSUpdateMode.ReadOnly, CFSConfiguration.SectorRecycle);
//CompoundFile cf = new CompoundFile();
Random r = new Random();
for (int i = 0; i < 254; i++)
{
//byte[] buffer = Helpers.GetBuffer(r.Next(100, 3500), (byte)i);
byte[] buffer = Helpers.GetBuffer(1995, 1);
//if (i > 0)
//{
// if (r.Next(0, 100) > 50)
// {
// cf.RootStorage.Delete("MyNewStream" + (i - 1).ToString());
// }
//}
CFStream addedStream = cf.RootStorage.AddStream("MyNewStream" + i.ToString());
Assert.IsNotNull(addedStream, "Stream not found");
addedStream.SetData(buffer);
Assert.IsTrue(Helpers.CompareBuffer(addedStream.GetData(), buffer), "Data buffer corrupted");
// Random commit, not on single addition
//if (r.Next(0, 100) > 50)
// cf.UpdateFile();
}
cf.Save(dstFilename + "PP");
cf.Close();
if (File.Exists("reportOverwriteMultiple.xls"))
{
File.Delete("reportOverwriteMultiple.xls");
}
if (File.Exists("reportOverwriteMultiple.xlsPP"))
{
File.Delete("reportOverwriteMultiple.xlsPP");
}
}
public void Test_FIX_BUG_GH_14()
{
String filename = "MyFile.dat";
String storageName = "MyStorage";
String streamName = "MyStream";
int BUFFER_SIZE = 800 * Mb;
int iterationCount = 3;
int streamCount = 3;
CompoundFile compoundFileInit = new CompoundFile(CFSVersion.Ver_4, CFSConfiguration.Default);
compoundFileInit.Save(filename);
compoundFileInit.Close();
CompoundFile compoundFile = new CompoundFile(filename, CFSUpdateMode.Update, CFSConfiguration.Default);
CFStorage st = compoundFile.RootStorage.AddStorage(storageName);
byte b = 0X0A;
for (int streamId = 0; streamId < streamCount; ++streamId)
{
CFStream sm = st.AddStream(streamName + streamId);
for (int iteration = 0; iteration < iterationCount; ++iteration)
{
sm.Append(Helpers.GetBuffer(BUFFER_SIZE, b));
compoundFile.Commit();
}
b++;
}
compoundFile.Close();
compoundFile = new CompoundFile(filename, CFSUpdateMode.ReadOnly, CFSConfiguration.Default);
byte[] testBuffer = new byte[100];
byte t = 0x0A;
for (int streamId = 0; streamId < streamCount; ++streamId)
{
compoundFile.RootStorage.GetStorage(storageName).GetStream(streamName + streamId).Read(testBuffer, BUFFER_SIZE / 2, 100);
Assert.IsTrue(testBuffer.All(g => g == t));
compoundFile.RootStorage.GetStorage(storageName).GetStream(streamName + streamId).Read(testBuffer, BUFFER_SIZE - 101, 100);
Assert.IsTrue(testBuffer.All(g => g == t));
compoundFile.RootStorage.GetStorage(storageName).GetStream(streamName + streamId).Read(testBuffer, 0, 100);
Assert.IsTrue(testBuffer.All(g => g == t));
t++;
}
compoundFile.Close();
}
public void Test_PR_GH_18()
{
try
{
var f = new CompoundFile("MultipleStorage4.cfs", CFSUpdateMode.Update, CFSConfiguration.Default);
var st = f.RootStorage.GetStorage("MyStorage").GetStorage("AnotherStorage").GetStream("MyStream");
st.Write(Helpers.GetBuffer(100, 0x02), 100);
f.Commit(true);
Assert.IsTrue(st.GetData().Count() == 31220);
f.Close();
}
catch (Exception ex)
{
Assert.Fail("Release Memory flag caused error");
}
}
public void Test_COMPARE_DIR_ENTRY_NAME_BUG_FIX_ID_3487353()
{
var f = new CompoundFile("report_name_fix.xls", CFSUpdateMode.Update, CFSConfiguration.SectorRecycle | CFSConfiguration.EraseFreeSectors);
CFStream cfs = f.RootStorage.AddStream("Poorbook");
cfs.Append(Helpers.GetBuffer(20));
f.Commit();
f.Close();
f = new CompoundFile("report_name_fix.xls", CFSUpdateMode.Update, CFSConfiguration.SectorRecycle | CFSConfiguration.EraseFreeSectors);
cfs = f.RootStorage.GetStream("Workbook");
Assert.IsTrue(cfs.Name == "Workbook");
f.RootStorage.Delete("PoorBook");
f.Commit();
f.Close();
}
public void Test_WRONG_CORRUPTED_EXCEPTION()
{
var cf = new CompoundFile();
for (int i = 0; i < 100; i++)
{
cf.RootStorage.AddStream("Stream" + i).SetData(Helpers.GetBuffer(100000, 0xAA));
}
cf.RootStorage.AddStream("BigStream").SetData(Helpers.GetBuffer(5250000, 0xAA));
using (var stream = new MemoryStream())
{
cf.Save(stream);
}
cf.Close();
}
public void Test_WRITE_MINI_STREAM()
{
const int BUFFER_LENGTH = 1023; // < 4096
byte[] b = Helpers.GetBuffer(BUFFER_LENGTH);
CompoundFile cf = new CompoundFile();
CFStream myStream = cf.RootStorage.AddStream("MyMiniStream");
Assert.IsNotNull(myStream);
Assert.IsTrue(myStream.Size == 0);
myStream.SetData(b);
Assert.IsTrue(myStream.Size == BUFFER_LENGTH, "Mini Stream size differs from buffer size");
cf.Close();
}
public void Test_COPY_FROM_STREAM()
{
byte[] b = Helpers.GetBuffer(100);
MemoryStream ms = new MemoryStream(b);
CompoundFile cf = new CompoundFile();
CFStream st = cf.RootStorage.AddStream("MyImportedStream");
st.CopyFrom(ms);
ms.Close();
cf.Save("COPY_FROM_STREAM.cfs");
cf.Close();
cf = new CompoundFile("COPY_FROM_STREAM.cfs");
byte[] data = cf.RootStorage.GetStream("MyImportedStream").GetData();
Assert.IsTrue(Helpers.CompareBuffer(b, data));
}
public void Test_ADD_LARGE_NUMBER_OF_ITEMS()
{
int ITEM_NUMBER = 10000;
CompoundFile f = null;
byte[] buffer = Helpers.GetBuffer(10, 0x0A);
try
{
f = new CompoundFile();
for (int i = 0; i < ITEM_NUMBER; i++)
{
CFStream st = f.RootStorage.AddStream("Stream" + i.ToString());
st.Append(buffer);
}
if (File.Exists("$ItemsLargeNumber.cfs"))
{
File.Delete("$ItemsLargeNumber.cfs");
}
f.Save("$ItemsLargeNumber.cfs");
f.Close();
f = new CompoundFile("$ItemsLargeNumber.cfs");
CFStream cfs = f.RootStorage.GetStream("Stream" + (ITEM_NUMBER / 2).ToString());
Assert.IsTrue(cfs != null, "Item is null");
Assert.IsTrue(Helpers.CompareBuffer(cfs.GetData(), buffer), "Items are different");
f.Close();
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
finally
{
//if (File.Exists("$ItemsLargeNumber.cfs"))
// File.Delete("$ItemsLargeNumber.cfs");
}
}
public void Test_RESIZE_STREAM_NO_TRANSITION()
{
CompoundFile cf = null;
//CFStream st = null;
byte[] b = Helpers.GetBuffer(1024 * 1024 * 2); //2MB buffer
cf = new CompoundFile(CFSVersion.Ver_3, CFSConfiguration.Default);
cf.RootStorage.AddStream("AStream").SetData(b);
cf.Save("$Test_RESIZE_STREAM.cfs");
cf.Close();
cf = new CompoundFile("$Test_RESIZE_STREAM.cfs", CFSUpdateMode.Update, CFSConfiguration.SectorRecycle);
CFStream item = cf.RootStorage.GetStream("AStream");
item.Resize(item.Size / 2);
//cf.RootStorage.AddStream("BStream").SetData(b);
cf.Commit(true);
cf.Close();
}
public void Test_DELETE_STREAM_SECTOR_REUSE()
{
CompoundFile cf = null;
CFStream st = null;
byte[] b = Helpers.GetBuffer(1024 * 1024 * 2); //2MB buffer
byte[] cmp = new byte[] { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
cf = new CompoundFile(CFSVersion.Ver_4, CFSConfiguration.Default);
st = cf.RootStorage.AddStream("AStream");
st.Append(b);
cf.Save("SectorRecycle.cfs");
cf.Close();
cf = new CompoundFile("SectorRecycle.cfs", CFSUpdateMode.Update, CFSConfiguration.SectorRecycle);
cf.RootStorage.Delete("AStream");
cf.Commit(true);
cf.Close();
cf = new CompoundFile("SectorRecycle.cfs", CFSUpdateMode.ReadOnly,
CFSConfiguration.Default); //No sector recycle
st = cf.RootStorage.AddStream("BStream");
st.Append(Helpers.GetBuffer(1024 * 1024 * 1));
cf.Save("SectorRecycleLarger.cfs");
cf.Close();
Assert.IsFalse((new FileInfo("SectorRecycle.cfs").Length) >=
(new FileInfo("SectorRecycleLarger.cfs").Length));
cf = new CompoundFile("SectorRecycle.cfs", CFSUpdateMode.ReadOnly, CFSConfiguration.SectorRecycle);
st = cf.RootStorage.AddStream("BStream");
st.Append(Helpers.GetBuffer(1024 * 1024 * 1));
cf.Save("SectorRecycleSmaller.cfs");
cf.Close();
long larger = (new FileInfo("SectorRecycle.cfs").Length);
long smaller = (new FileInfo("SectorRecycleSmaller.cfs").Length);
Assert.IsTrue(larger >= smaller,
"Larger size:" + larger.ToString() + " - Smaller size:" + smaller.ToString());
}
public void Test_FIX_GH_83()
{
try
{
byte[] bigDataBuffer = Helpers.GetBuffer(1024 * 1024 * 260);
using (FileStream fTest = new FileStream("BigFile.data", FileMode.Create))
{
fTest.Write(bigDataBuffer, 0, 1024 * 1024 * 260);
fTest.Flush();
fTest.Close();
var f = new CompoundFile();
var cfStream = f.RootStorage.AddStream("NewStream");
using (FileStream fs = new FileStream("BigFile.data", FileMode.Open))
{
cfStream.CopyFrom(fs);
}
f.Save("BigFile.cfs");
f.Close();
}
}
catch (Exception e)
{
Assert.Fail();
}
finally
{
if (File.Exists("BigFile.data"))
{
File.Delete("BigFile.data");
}
if (File.Exists("BigFile.cfs"))
{
File.Delete("BigFile.cfs");
}
}
}