private void PageBorderOperations <T>(bool enableMma, int pageSize)
where T : IEquatable <T>
{
DeleteTempFiles();
string fileName = GetBinFileName();
using (
BinIndexedFile <T> f = AllowCreate
? new BinIndexedFile <T>(fileName)
: (BinIndexedFile <T>)
BinaryFile.Open(fileName, false, LegacyResolver))
{
if (AllowCreate)
{
f.InitializeNewFile();
f.EnableMemMappedAccessOnRead = enableMma;
f.EnableMemMappedAccessOnWrite = enableMma;
}
int itemsPerPage = pageSize / Marshal.SizeOf(typeof(T));
int headerSizeAsItemCount = f.HeaderSize / f.ItemSize;
int items1StPg = (int)TestUtils.RoundUpToMultiple(headerSizeAsItemCount, itemsPerPage) -
headerSizeAsItemCount;
if (items1StPg == 0)
{
items1StPg = itemsPerPage;
}
T[] dataMinusOne = TestUtils.GenerateData <T>(items1StPg - 1, 0);
T[] dataZero = TestUtils.GenerateData <T>(items1StPg, 0);
T[] dataPlusOne = TestUtils.GenerateData <T>(items1StPg + 1, 0);
if (AllowCreate)
{
f.WriteData(0, new ArraySegment <T>(dataMinusOne));
Assert.AreEqual(f.HeaderSize + (items1StPg - 1) * f.ItemSize, new FileInfo(fileName).Length);
ReadAndAssert(dataMinusOne, f, 0, dataMinusOne.Length);
f.WriteData(0, new ArraySegment <T>(dataZero));
Assert.AreEqual(f.HeaderSize + items1StPg * f.ItemSize, new FileInfo(fileName).Length);
ReadAndAssert(dataZero, f, 0, dataZero.Length);
f.WriteData(0, new ArraySegment <T>(dataPlusOne));
}
Assert.AreEqual(f.HeaderSize + (items1StPg + 1) * f.ItemSize, new FileInfo(fileName).Length);
ReadAndAssert(dataPlusOne, f, 0, dataPlusOne.Length);
ReadAndAssert(TestUtils.GenerateData <T>(1, items1StPg - 1), f, items1StPg - 1, 1);
ReadAndAssert(TestUtils.GenerateData <T>(1, items1StPg), f, items1StPg, 1);
ReadAndAssert(TestUtils.GenerateData <T>(2, items1StPg - 1), f, items1StPg - 1, 2);
}
}
public void StreamingTest()
{
string fileName = GetBinFileName();
byte[] data = TestUtils.GenerateData <byte>(10000, 0);
if (AllowCreate)
{
using (var b = new BinIndexedFile <byte>(fileName))
{
b.InitializeNewFile();
b.WriteData(0, new ArraySegment <byte>(data));
}
}
byte[] bytes = File.ReadAllBytes(fileName);
using (var b = (BinIndexedFile <byte>)BinaryFile.Open(fileName, false, LegacyResolver))
{
var ms = new MemoryStream(bytes);
var cs = new ConfigurableStream(ms);
var data2 = new byte[data.Length / 2];
cs.AllowSeek = cs.AllowWrite = false;
var b2 = (BinIndexedFile <byte>)BinaryFile.Open(cs, LegacyResolver);
Assert.IsTrue(b2.IsOpen);
Assert.AreEqual(b.ItemSize, b2.ItemSize);
b2.ReadData(0, new ArraySegment <byte>(data2));
TestUtils.CollectionAssertEqual(TestUtils.GenerateData <byte>(data.Length / 2, 0), data2);
b2.ReadData(0, new ArraySegment <byte>(data2));
TestUtils.CollectionAssertEqual(TestUtils.GenerateData <byte>(data.Length / 2, data.Length / 2), data2);
}
}
public void StreamingTest()
{
string fileName = GetBinFileName();
byte[] data = TestUtils.GenerateData<byte>(10000, 0);
if (AllowCreate)
{
using (var b = new BinIndexedFile<byte>(fileName))
{
b.InitializeNewFile();
b.WriteData(0, new ArraySegment<byte>(data));
}
}
byte[] bytes = File.ReadAllBytes(fileName);
using (var b = (BinIndexedFile<byte>) BinaryFile.Open(fileName, false, LegacyResolver))
{
var ms = new MemoryStream(bytes);
var cs = new ConfigurableStream(ms);
var data2 = new byte[data.Length/2];
cs.AllowSeek = cs.AllowWrite = false;
var b2 = (BinIndexedFile<byte>) BinaryFile.Open(cs, LegacyResolver);
Assert.IsTrue(b2.IsOpen);
Assert.AreEqual(b.ItemSize, b2.ItemSize);
b2.ReadData(0, new ArraySegment<byte>(data2));
TestUtils.CollectionAssertEqual(TestUtils.GenerateData<byte>(data.Length/2, 0), data2);
b2.ReadData(0, new ArraySegment<byte>(data2));
TestUtils.CollectionAssertEqual(TestUtils.GenerateData<byte>(data.Length/2, data.Length/2), data2);
}
}
public void Test()
{
const int blockSize = 100;
var data = new TradesBlock[1000];
for (int i = 0; i < data.Length; i++)
{
data[i] = new TradesBlock(i, blockSize);
}
string fileName = GetBinFileName();
if (AllowCreate)
{
using (var f = new BinIndexedFile <TradesBlock>(fileName))
{
((IBinBlockSerializer)f.Serializer).ItemCount = blockSize;
f.InitializeNewFile();
f.WriteData(0, new ArraySegment <TradesBlock>(data));
VerifyData(f, data);
}
}
using (var bf = (BinIndexedFile <TradesBlock>)BinaryFile.Open(fileName, false, LegacyResolver))
{
VerifyData(bf, data);
}
}
public void MappingTest()
{
string fileName = GetBinFileName();
_DatetimeByte_SeqPk1[] data = TestUtils.GenerateData <_DatetimeByte_SeqPk1>(1, 10);
if (AllowCreate)
{
using (var f = new BinIndexedFile <_DatetimeByte_SeqPk1>(fileName))
{
f.InitializeNewFile();
f.WriteData(0, new ArraySegment <_DatetimeByte_SeqPk1>(data));
}
}
Type oldT = typeof(_DatetimeByte_SeqPk1);
string oldAn = oldT.Assembly.GetName().Name;
using (BinaryFile f = BinaryFile.Open(
fileName, false,
tn =>
TypeUtils.ParseAndResolve(
tn,
ts2 => TypeSpec.DefaultFullTypeResolver(
ts2,
(ts, an) =>
an != null && an.Name == oldAn && ts.Name == oldT.FullName ? typeof(_LongByte_SeqPk1) : null,
TypeResolver, LegacySupport.TypeResolver, TypeUtils.ResolverFromAnyAssemblyVersion))))
{
var p = (BinIndexedFile <_LongByte_SeqPk1>)f;
var data2 = new _LongByte_SeqPk1[1];
p.ReadData(0, new ArraySegment <_LongByte_SeqPk1>(data2));
Assert.AreEqual(data[0].a.Ticks, data2[0].a);
Assert.AreEqual(data[0].b, data2[0].b);
}
}
private static void WriteData <T>(BinIndexedFile <T> f, long firstItemIndex, T[] buffer)
{
f.WriteData(firstItemIndex, new ArraySegment <T>(buffer));
}
private void FileIncrementalAddition <T>() where T : IEquatable <T>
{
const string testName = "FileIncrementalAddition";
try
{
Stopwatch sw = TestStart();
T[] data0 = TestUtils.GenerateData <T>(1, 10);
T[] data1 = TestUtils.GenerateData <T>(2, 20);
T[] data2 = TestUtils.GenerateData <T>(3, 30);
string fileName = GetBinFileName();
if (AllowCreate)
{
using (var f = new BinIndexedFile <T>(fileName))
{
f.InitializeNewFile();
f.WriteData(0, new ArraySegment <T>(data0));
Assert.AreEqual(true, f.CanWrite);
Assert.AreEqual(1, f.Count);
Assert.IsFalse(f.IsEmpty);
ReadAndAssert(data0, f, 0, f.Count);
}
}
using (BinaryFile file = BinaryFile.Open(fileName, AllowCreate, LegacyResolver))
{
Assert.IsInstanceOf <BinIndexedFile <T> >(file);
var f = (BinIndexedFile <T>)file;
Assert.AreEqual(AllowCreate, f.CanWrite);
if (AllowCreate)
{
Assert.AreEqual(1, f.Count);
ReadAndAssert(data0, f, 0, f.Count);
// Replace with buff2 starting at 0
WriteData(f, 0, data1);
Assert.AreEqual(2, f.Count);
ReadAndAssert(data1, f, 0, f.Count);
// Append buff1
WriteData(f, f.Count, data0);
Assert.AreEqual(3, f.Count);
ReadAndAssert(data0, f, 2, 1);
// Write buff3 instead of buff1
WriteData(f, data1.Length, data2);
}
Assert.AreEqual(data1.Length + data2.Length, f.Count);
ReadAndAssert(TestUtils.Concatenate(data1, data2), f, 0, f.Count);
}
TestStop <T>(testName, sw);
}
catch
{
Console.WriteLine("Error in " + testName);
throw;
}
}
public void MappingTest()
{
string fileName = GetBinFileName();
_DatetimeByte_SeqPk1[] data = TestUtils.GenerateData<_DatetimeByte_SeqPk1>(1, 10);
if (AllowCreate)
{
using (var f = new BinIndexedFile<_DatetimeByte_SeqPk1>(fileName))
{
f.InitializeNewFile();
f.WriteData(0, new ArraySegment<_DatetimeByte_SeqPk1>(data));
}
}
Type oldT = typeof (_DatetimeByte_SeqPk1);
string oldAn = oldT.Assembly.GetName().Name;
using (BinaryFile f = BinaryFile.Open(
fileName, false,
tn =>
TypeUtils.ParseAndResolve(
tn,
ts2 => TypeSpec.DefaultFullTypeResolver(
ts2,
(ts, an) =>
an != null && an.Name == oldAn && ts.Name == oldT.FullName ? typeof (_LongByte_SeqPk1) : null,
TypeResolver, LegacySupport.TypeResolver, TypeUtils.ResolverFromAnyAssemblyVersion))))
{
var p = (BinIndexedFile<_LongByte_SeqPk1>) f;
var data2 = new _LongByte_SeqPk1[1];
p.ReadData(0, new ArraySegment<_LongByte_SeqPk1>(data2));
Assert.AreEqual(data[0].a.Ticks, data2[0].a);
Assert.AreEqual(data[0].b, data2[0].b);
}
}
