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);
ICFStream 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_WRITE_AND_READ_CFS()
{
String filename = "WRITE_AND_READ_CFS.cfs";
CompoundFile cf = new CompoundFile();
ICFStorage st = cf.RootStorage.AddStorage("MyStorage");
ICFStream sm = st.AddStream("MyStream");
byte[] b = Helpers.GetBuffer(220, 0x0A);
sm.SetData(b);
cf.Save(filename);
cf.Close();
CompoundFile cf2 = new CompoundFile(filename);
ICFStorage st2 = cf2.RootStorage.GetStorage("MyStorage");
ICFStream sm2 = st2.GetStream("MyStream");
cf2.Close();
Assert.IsNotNull(sm2);
Assert.IsTrue(sm2.Size == 220);
if (File.Exists(filename))
{
File.Delete(filename);
}
}
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();
ICFStream 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");
ICFStream 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_ZERO_LENGTH_WRITE_STREAM()
{
byte[] b = new byte[0];
CompoundFile cf = new CompoundFile();
ICFStream myStream = cf.RootStorage.AddStream("MyStream");
Assert.IsNotNull(myStream);
try
{
myStream.SetData(b); cf.Save("ZERO_LENGTH_STREAM.cfs");
}
catch
{
Assert.Fail("Failed setting zero length stream");
}
finally
{
if (cf != null)
{
cf.Close();
}
}
if (File.Exists("ZERO_LENGTH_STREAM.cfs"))
{
File.Delete("ZERO_LENGTH_STREAM.cfs");
}
}
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();
ICFStorage st = cf.RootStorage.AddStorage("MyStorage");
ICFStream sm = st.AddStream("MyStream");
byte[] b = Helpers.GetBuffer(size);
sm.SetData(b);
cf.Save(filename);
cf.Close();
CompoundFile cf2 = new CompoundFile(filename);
ICFStorage st2 = cf2.RootStorage.GetStorage("MyStorage");
ICFStream sm2 = st2.GetStream("MyStream");
Assert.IsNotNull(sm2);
Assert.IsTrue(sm2.Size == size);
Assert.IsTrue(Helpers.CompareBuffer(sm2.GetData(), b));
cf2.Close();
}
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, UpdateMode.Update, true, true);
cf.RootStorage.Delete("\x05SummaryInformation");
byte[] buffer = Helpers.GetBuffer(2000);
ICFStream addedStream = cf.RootStorage.AddStream("MyNewStream");
addedStream.SetData(buffer);
cf.Commit();
cf.Close();
if (File.Exists("reportOverwrite2.xlsPP"))
{
File.Delete("reportOverwrite2.xlsPP");
}
}
public void Test_ZERO_LENGTH_RE_WRITE_STREAM()
{
byte[] b = new byte[0];
CompoundFile cf = new CompoundFile();
ICFStream 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");
ICFStream 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, UpdateMode.ReadOnly, true, false);
//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());
// }
//}
ICFStream 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_DELETE_ZERO_LENGTH_STREAM()
{
byte[] b = new byte[0];
CompoundFile cf = new CompoundFile();
string zeroLengthName = "MyZeroStream";
ICFStream myStream = cf.RootStorage.AddStream(zeroLengthName);
Assert.IsNotNull(myStream);
try
{
myStream.SetData(b);
}
catch
{
Assert.Fail("Failed setting zero length stream");
}
string filename = "DeleteZeroLengthStream.cfs";
cf.Save(filename);
cf.Close();
CompoundFile cf2 = new CompoundFile(filename);
// Execption in next line!
cf2.RootStorage.Delete(zeroLengthName);
ICFStream zeroStream2 = null;
try
{
zeroStream2 = cf2.RootStorage.GetStream(zeroLengthName);
}
catch (Exception ex)
{
Assert.IsNull(zeroStream2);
Assert.IsInstanceOfType(ex, typeof(CFItemNotFound));
}
cf2.Save("MultipleDeleteMiniStream.cfs");
cf2.Close();
}
public void Test_WRITE_STREAM()
{
const int BUFFER_LENGTH = 10000;
byte[] b = Helpers.GetBuffer(BUFFER_LENGTH);
CompoundFile cf = new CompoundFile();
ICFStream myStream = cf.RootStorage.AddStream("MyStream");
Assert.IsNotNull(myStream);
Assert.IsTrue(myStream.Size == 0);
myStream.SetData(b);
Assert.IsTrue(myStream.Size == BUFFER_LENGTH, "Stream size differs from buffer size");
cf.Close();
}
public static void TestMultipleStreamCommit()
{
String srcFilename = Directory.GetCurrentDirectory() + @"\testfile\report.xls";
String dstFilename = Directory.GetCurrentDirectory() + @"\testfile\reportOverwriteMultiple.xls";
//Console.WriteLine(Directory.GetCurrentDirectory());
//Console.ReadKey();
File.Copy(srcFilename, dstFilename, true);
CompoundFile cf = new CompoundFile(dstFilename, UpdateMode.Update, true, false);
Random r = new Random();
DateTime start = DateTime.Now;
for (int i = 0; i < 1000; i++)
{
byte[] buffer = GetBuffer(r.Next(100, 3500), 0x0A);
if (i > 0)
{
if (r.Next(0, 100) > 50)
{
cf.RootStorage.Delete("MyNewStream" + (i - 1).ToString());
}
}
ICFStream addedStream = cf.RootStorage.AddStream("MyNewStream" + i.ToString());
addedStream.SetData(buffer);
// Random commit, not on single addition
if (r.Next(0, 100) > 50)
{
cf.Commit();
}
}
cf.Close();
TimeSpan sp = (DateTime.Now - start);
Console.WriteLine(sp.TotalMilliseconds);
}
public void Test_APPEND_DATA_TO_STREAM()
{
MemoryStream ms = new MemoryStream();
byte[] b = new byte[] { 0x0, 0x1, 0x2, 0x3 };
byte[] b2 = new byte[] { 0x4, 0x5, 0x6, 0x7 };
CompoundFile cf = new CompoundFile();
ICFStream st = cf.RootStorage.AddStream("MyLargeStream");
st.SetData(b);
st.AppendData(b2);
cf.Save(ms);
cf.Close();
byte[] cmp = new byte[] { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 };
cf = new CompoundFile(ms);
byte[] data = cf.RootStorage.GetStream("MyLargeStream").GetData();
Assert.IsTrue(Helpers.CompareBuffer(cmp, data));
}
public void Test_RE_WRITE_SMALLER_MINI_STREAM()
{
String filename = "report.xls";
CompoundFile cf = new CompoundFile(filename);
ICFStream 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);
cf.Close();
if (File.Exists("RE_WRITE_SMALLER_MINI_STREAM.xls"))
{
File.Delete("RE_WRITE_SMALLER_MINI_STREAM.xls");
}
}
private void SingleWriteReadMatchingSTREAMED(int size)
{
MemoryStream ms = new MemoryStream(size);
CompoundFile cf = new CompoundFile();
ICFStorage st = cf.RootStorage.AddStorage("MyStorage");
ICFStream sm = st.AddStream("MyStream");
byte[] b = Helpers.GetBuffer(size);
sm.SetData(b);
cf.Save(ms);
cf.Close();
CompoundFile cf2 = new CompoundFile(ms);
ICFStorage st2 = cf2.RootStorage.GetStorage("MyStorage");
ICFStream sm2 = st2.GetStream("MyStream");
Assert.IsNotNull(sm2);
Assert.IsTrue(sm2.Size == size);
Assert.IsTrue(Helpers.CompareBuffer(sm2.GetData(), b));
cf2.Close();
}
public void Test_WRITE_READ_CFS_VERSION_4_STREAM()
{
String filename = "WRITE_COMMIT_READ_CFS_V4.cfs";
CompoundFile cf = new CompoundFile(CFSVersion.Ver_4, true, true);
ICFStorage st = cf.RootStorage.AddStorage("MyStorage");
ICFStream sm = st.AddStream("MyStream");
byte[] b = Helpers.GetBuffer(227);
sm.SetData(b);
cf.Save(filename);
cf.Close();
CompoundFile cf2 = new CompoundFile(filename);
ICFStorage st2 = cf2.RootStorage.GetStorage("MyStorage");
ICFStream sm2 = st2.GetStream("MyStream");
Assert.IsNotNull(sm2);
Assert.IsTrue(sm2.Size == b.Length);
cf2.Close();
}
public void Test_WRITE_AND_READ_CFS_VERSION_4()
{
String filename = "WRITE_AND_READ_CFS_V4.cfs";
CompoundFile cf = new CompoundFile(CFSVersion.Ver_4, true, true);
ICFStorage st = cf.RootStorage.AddStorage("MyStorage");
ICFStream sm = st.AddStream("MyStream");
byte[] b = new byte[220];
sm.SetData(b);
cf.Save(filename);
cf.Close();
CompoundFile cf2 = new CompoundFile(filename);
ICFStorage st2 = cf2.RootStorage.GetStorage("MyStorage");
ICFStream sm2 = st2.GetStream("MyStream");
Assert.IsNotNull(sm2);
Assert.IsTrue(sm2.Size == 220);
cf2.Close();
}
public void Test_WRITE_MINISTREAM_READ_REWRITE_STREAM()
{
const int BIGGER_SIZE = 350;
//const int SMALLER_SIZE = 290;
const int MEGA_SIZE = 18000000;
byte[] ba1 = Helpers.GetBuffer(BIGGER_SIZE, 1);
byte[] ba2 = Helpers.GetBuffer(BIGGER_SIZE, 2);
byte[] ba3 = Helpers.GetBuffer(BIGGER_SIZE, 3);
byte[] ba4 = Helpers.GetBuffer(BIGGER_SIZE, 4);
byte[] ba5 = Helpers.GetBuffer(BIGGER_SIZE, 5);
//WRITE 5 (mini)streams in a compound file --
CompoundFile cfa = new CompoundFile();
ICFStream myStream = cfa.RootStorage.AddStream("MyFirstStream");
Assert.IsNotNull(myStream);
myStream.SetData(ba1);
Assert.IsTrue(myStream.Size == BIGGER_SIZE);
ICFStream myStream2 = cfa.RootStorage.AddStream("MySecondStream");
Assert.IsNotNull(myStream2);
myStream2.SetData(ba2);
Assert.IsTrue(myStream2.Size == BIGGER_SIZE);
ICFStream myStream3 = cfa.RootStorage.AddStream("MyThirdStream");
Assert.IsNotNull(myStream3);
myStream3.SetData(ba3);
Assert.IsTrue(myStream3.Size == BIGGER_SIZE);
ICFStream myStream4 = cfa.RootStorage.AddStream("MyFourthStream");
Assert.IsNotNull(myStream4);
myStream4.SetData(ba4);
Assert.IsTrue(myStream4.Size == BIGGER_SIZE);
ICFStream myStream5 = cfa.RootStorage.AddStream("MyFifthStream");
Assert.IsNotNull(myStream5);
myStream5.SetData(ba5);
Assert.IsTrue(myStream5.Size == BIGGER_SIZE);
cfa.Save("WRITE_MINISTREAM_READ_REWRITE_STREAM.cfs");
cfa.Close();
// Now get the second stream and rewrite it smaller
byte[] bb = Helpers.GetBuffer(MEGA_SIZE);
CompoundFile cfb = new CompoundFile("WRITE_MINISTREAM_READ_REWRITE_STREAM.cfs");
ICFStream myStreamB = cfb.RootStorage.GetStream("MySecondStream");
Assert.IsNotNull(myStreamB);
myStreamB.SetData(bb);
Assert.IsTrue(myStreamB.Size == MEGA_SIZE);
byte[] bufferB = myStreamB.GetData();
cfb.Save("WRITE_MINISTREAM_READ_REWRITE_STREAM_2ND.cfs");
cfb.Close();
CompoundFile cfc = new CompoundFile("WRITE_MINISTREAM_READ_REWRITE_STREAM_2ND.cfs");
ICFStream myStreamC = cfc.RootStorage.GetStream("MySecondStream");
Assert.IsTrue(myStreamC.Size == MEGA_SIZE, "DATA SIZE FAILED");
byte[] bufferC = myStreamC.GetData();
Assert.IsTrue(Helpers.CompareBuffer(bufferB, bufferC), "DATA INTEGRITY FAILED");
cfc.Close();
if (File.Exists("WRITE_MINISTREAM_READ_REWRITE_STREAM.cfs"))
{
File.Delete("WRITE_MINISTREAM_READ_REWRITE_STREAM.cfs");
}
if (File.Exists("WRITE_MINISTREAM_READ_REWRITE_STREAM_2ND.cfs"))
{
File.Delete("WRITE_MINISTREAM_READ_REWRITE_STREAM_2ND.cfs");
}
}