public void correct_entry_is_returned()
{
var memTable = new HashListMemTable(maxSize: 10);
memTable.Add(0x11, 0x01, 0xffff);
memTable.Add(0x11, 0x02, 0xfff2);
using (var ptable = PTable.FromMemtable(memTable, Filename))
{
IndexEntry entry;
Assert.IsTrue(ptable.TryGetOldestEntry(0x11, out entry));
Assert.AreEqual(0x11, entry.Stream);
Assert.AreEqual(0x01, entry.Version);
Assert.AreEqual(0xffff, entry.Position);
}
}
public void throw_exception_if_index_entries_not_descending_during_ptable_get_latest_entry(byte version,
bool skipIndexVerify)
{
string ptableFileName = ConstructPTable(version);
CorruptPTableFile(ptableFileName, version, "zeroOutMiddleEntries");
//loading with a depth of 1 should load only 2 midpoints (first and last index entry)
PTable pTable = PTable.FromFile(ptableFileName, Constants.PTableInitialReaderCount, Constants.PTableMaxReaderCountDefault, 1, skipIndexVerify);
IndexEntry entry;
Assert.Throws <MaybeCorruptIndexException>(() =>
// changed 2 to 4 here because the corruption actually removes the stream at /2, so it isn't in the bloom filter
pTable.TryGetLatestEntry(GetOriginalHash(numIndexEntries / 4, version), out entry));
pTable.Dispose();
}
public void only_entry_with_largest_position_is_returned_when_triduplicated()
{
var memTable = new HashListMemTable(_ptableVersion, maxSize: 10);
memTable.Add(0x010100000000, 0x01, 0xfff1);
memTable.Add(0x010100000000, 0x01, 0xfff3);
memTable.Add(0x010100000000, 0x01, 0xfff5);
using (var ptable = PTable.FromMemtable(memTable, Filename, Constants.PTableInitialReaderCount, Constants.PTableMaxReaderCountDefault, skipIndexVerify: _skipIndexVerify)) {
IndexEntry entry;
Assert.IsTrue(ptable.TryGetLatestEntry(0x010100000000, out entry));
Assert.AreEqual(GetHash(0x010100000000), entry.Stream);
Assert.AreEqual(0x01, entry.Version);
Assert.AreEqual(0xfff5, entry.Position);
}
}
public void correct_entry_is_returned()
{
var memTable = new HashListMemTable(_ptableVersion, maxSize: 10);
memTable.Add(0x010100000000, 0x01, 0xffff);
memTable.Add(0x010100000000, 0x02, 0xfff2);
using (var ptable = PTable.FromMemtable(memTable, Filename, skipIndexVerify: _skipIndexVerify))
{
IndexEntry entry;
Assert.IsTrue(ptable.TryGetLatestEntry(0x010100000000, out entry));
Assert.AreEqual(GetHash(0x010100000000), entry.Stream);
Assert.AreEqual(0x02, entry.Version);
Assert.AreEqual(0xfff2, entry.Position);
}
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
var table = new HashListMemTable();
table.Add(0x0101, 0x0001, 0x0001);
table.Add(0x0105, 0x0001, 0x0002);
table.Add(0x0102, 0x0001, 0x0003);
table.Add(0x0102, 0x0002, 0x0004);
table.Add(0x0103, 0x0001, 0xFFF1);
table.Add(0x0103, 0x0003, 0xFFF3);
table.Add(0x0103, 0x0005, 0xFFF5);
_ptable = PTable.FromMemtable(table, Filename, cacheDepth: 0);
}
public void the_hash_of_file_is_valid()
{
var tmp = Path.GetRandomFileName();
var table = new HashListMemTable();
table.Add(0x0101, 0x0001, 0x0001);
table.Add(0x0105, 0x0001, 0x0002);
table.Add(0x0102, 0x0001, 0x0003);
table.Add(0x0102, 0x0002, 0x0003);
using (var sstable = PTable.FromMemtable(table, tmp))
{
Assert.DoesNotThrow(() => sstable.VerifyFileHash());
}
File.Delete(tmp);
}
public void the_largest_items_are_returned_in_descending_order()
{
var entries = PTable.GetRange(1, 0, 0).ToArray();
Assert.AreEqual(3, entries.Length);
Assert.AreEqual(1, entries[0].Stream);
Assert.AreEqual(0, entries[0].Version);
Assert.AreEqual(0x0005, entries[0].Position);
Assert.AreEqual(1, entries[1].Stream);
Assert.AreEqual(0, entries[1].Version);
Assert.AreEqual(0x0004, entries[1].Position);
Assert.AreEqual(1, entries[2].Stream);
Assert.AreEqual(0, entries[2].Version);
Assert.AreEqual(0x0003, entries[2].Position);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
var table = new HashListMemTable(_ptableVersion, maxSize: 50);
table.Add(0x010100000000, 0x0001, 0x0001);
table.Add(0x010500000000, 0x0001, 0x0002);
table.Add(0x010200000000, 0x0001, 0x0003);
table.Add(0x010200000000, 0x0002, 0x0004);
table.Add(0x010300000000, 0x0001, 0xFFF1);
table.Add(0x010300000000, 0x0003, 0xFFF3);
table.Add(0x010300000000, 0x0005, 0xFFF5);
_ptable = PTable.FromMemtable(table, Filename, cacheDepth: 0, skipIndexVerify: _skipIndexVerify);
}
public void the_file_gets_created_and_can_be_read()
{
var indexEntrySize = PTable.IndexEntryV4Size;
if (_ptableVersion == PTableVersions.IndexV1)
{
indexEntrySize = PTable.IndexEntryV1Size;
}
else if (_ptableVersion == PTableVersions.IndexV2)
{
indexEntrySize = PTable.IndexEntryV2Size;
}
else if (_ptableVersion == PTableVersions.IndexV3)
{
indexEntrySize = PTable.IndexEntryV3Size;
}
var table = new HashListMemTable(_ptableVersion, maxSize: 10);
table.Add(0x010100000000, 0x0001, 0x0001);
table.Add(0x010500000000, 0x0001, 0x0002);
table.Add(0x010200000000, 0x0001, 0x0003);
table.Add(0x010200000000, 0x0002, 0x0003);
using (var sstable = PTable.FromMemtable(table, Filename, Constants.PTableInitialReaderCount, Constants.PTableMaxReaderCountDefault,
skipIndexVerify: _skipIndexVerify,
useBloomFilter: true)) {
var fileinfo = new FileInfo(Filename);
var midpointsCached = PTable.GetRequiredMidpointCountCached(4, _ptableVersion);
Assert.AreEqual(
PTableHeader.Size + 4 * indexEntrySize + midpointsCached * indexEntrySize +
PTableFooter.GetSize(_ptableVersion) + PTable.MD5Size, fileinfo.Length);
var items = sstable.IterateAllInOrder().ToList();
Assert.AreEqual(GetHash(0x010500000000), items[0].Stream);
Assert.AreEqual(0x0001, items[0].Version);
Assert.AreEqual(GetHash(0x010200000000), items[1].Stream);
Assert.AreEqual(0x0002, items[1].Version);
Assert.AreEqual(GetHash(0x010200000000), items[2].Stream);
Assert.AreEqual(0x0001, items[2].Version);
Assert.AreEqual(GetHash(0x010100000000), items[3].Stream);
Assert.AreEqual(0x0001, items[3].Version);
var stream = (ulong)0x010200000000;
Assert.True(sstable.TryGetLatestEntry(stream, out var entry));
Assert.AreEqual(GetHash(stream), entry.Stream);
Assert.AreEqual(0x0002, entry.Version);
Assert.AreEqual(0x0003, entry.Position);
}
}
public void when_ptable_header_is_corrupted()
{
_ptable.Dispose();
_ptable = null;
using (var fs = File.Open(_ptableFileName, FileMode.Open))
{
fs.Position = new Random().Next(0, PTableHeader.Size);
var b = (byte)fs.ReadByte();
b ^= 1;
fs.Position -= 1;
fs.WriteByte(b);
}
Assert.Throws <CorruptIndexException>(() => IndexMap.FromFile(_indexMapFileName, maxTablesPerLevel: 2));
}
public void when_duplicated_entries_exist_the_one_with_oldest_position_is_returned()
{
var memTable = new HashListMemTable(_ptableVersion, maxSize: 10);
memTable.Add(0x010100000000, 0x01, 0xfff1);
memTable.Add(0x010100000000, 0x02, 0xfff2);
memTable.Add(0x010100000000, 0x01, 0xfff3);
memTable.Add(0x010100000000, 0x02, 0xfff4);
using (var ptable = PTable.FromMemtable(memTable, Filename, skipIndexVerify: _skipIndexVerify)) {
IndexEntry entry;
Assert.IsTrue(ptable.TryGetOldestEntry(0x010100000000, out entry));
Assert.AreEqual(GetHash(0x010100000000), entry.Stream);
Assert.AreEqual(0x01, entry.Version);
Assert.AreEqual(0xfff1, entry.Position);
}
}
public void when_ptable_data_is_corrupted()
{
_ptable.Dispose();
_ptable = null;
using (var fs = File.Open(_ptableFileName, FileMode.Open))
{
fs.Position = new Random().Next(PTableHeader.Size, (int)fs.Length);
var b = (byte)fs.ReadByte();
b ^= 1;
fs.Position -= 1;
fs.WriteByte(b);
}
Assert.Throws <CorruptIndexException>(() => IndexMap.FromFile(_indexMapFileName, x => false, 2));
}
public void for_a_fixed_number_of_index_entries_and_increasing_min_depth_midpoint_count_should_increase_monotonically()
{
for (long numIndexEntries = 0; numIndexEntries < MAX_INDEX_ENTRIES; numIndexEntries += getIncrement(numIndexEntries))
{
long prevMidpointCount = 0L;
for (int minDepth = 0; minDepth <= MAX_TEST_DEPTH; minDepth++)
{
string testCase = $"numIndexEntries: {numIndexEntries}, minDepth: {minDepth}";
var midpointCount = PTable.GetRequiredMidpointCountCached(numIndexEntries, PTableVersions.IndexV4, minDepth);
Assert.GreaterOrEqual(midpointCount, prevMidpointCount, testCase);
Assert.GreaterOrEqual(midpointCount, Math.Min(1 << Math.Min(MAX_DEPTH, minDepth), numIndexEntries), testCase);
Assert.LessOrEqual(midpointCount, Math.Max(2, numIndexEntries), testCase);
prevMidpointCount = midpointCount;
}
}
}
public void Setup()
{
for (int i = 0; i < 4; i++)
{
_files.Add(Path.GetRandomFileName());
var table = new HashListMemTable();
for (int j = 0; j < 10; j++)
{
table.Add((UInt32)j + 1, i + 1, i * j);
}
_tables.Add(PTable.FromMemtable(table, _files[i]));
}
_files.Add(Path.GetRandomFileName());
_newtable = PTable.MergeTo(_tables, _files[4], x => false);
}
public void only_entry_with_largest_position_is_returned_when_triduplicated()
{
var memTable = new HashListMemTable();
memTable.Add(0x11, 0x01, 0xfff1);
memTable.Add(0x11, 0x01, 0xfff3);
memTable.Add(0x11, 0x01, 0xfff5);
using (var ptable = PTable.FromMemtable(memTable, Filename))
{
IndexEntry entry;
Assert.IsTrue(ptable.TryGetLatestEntry(0x11, out entry));
Assert.AreEqual(0x11, entry.Stream);
Assert.AreEqual(0x01, entry.Version);
Assert.AreEqual(0xfff5, entry.Position);
}
}
public void when_ptable_hash_is_corrupted()
{
_ptable.Dispose();
_ptable = null;
using (var fs = File.Open(_ptableFileName, FileMode.Open))
{
fs.Seek(-PTable.MD5Size, SeekOrigin.End);
var b = (byte)fs.ReadByte();
b ^= 1;
fs.Seek(-PTable.MD5Size, SeekOrigin.End);
fs.WriteByte(b);
}
Assert.Throws <CorruptIndexException>(() => IndexMap.FromFile(_indexMapFileName, x => false, 2));
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
var header = new PTableHeader(1);
using (var f = File.Open(Filename, FileMode.OpenOrCreate)) {
f.Seek(0, SeekOrigin.Begin);
var bytes = header.AsByteArray();
f.Write(bytes, 0, bytes.Length);
var size = (long)(uint.MaxValue + 10000000L) * (long)PTable.IndexEntrySize + PTableHeader.Size + PTable.MD5Size;
Console.WriteLine("allocating file " + Filename + " size is " + size);
f.SetLength(size);
Console.WriteLine("file allocated");
}
_ptable = PTable.FromFile(Filename, 22);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_filename = GetTempFilePath();
_mergeFile = GetTempFilePath();
_map = IndexMap.FromFile(_filename, x => false, maxTablesPerLevel: 2);
var memtable = new HashListMemTable();
memtable.Add(0, 1, 0);
_result = _map.AddFile(PTable.FromMemtable(memtable, GetTempFilePath()), 123, 321, new GuidFilenameProvider(PathName));
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddFile(PTable.FromMemtable(memtable, GetTempFilePath()), 100, 400, new FakeFilenameProvider(_mergeFile));
_result.ToDelete.ForEach(x => x.MarkForDestruction());
}
public void only_entry_with_smallest_position_is_returned_when_triduplicated()
{
var memTable = new HashListMemTable(_ptableVersion, maxSize: 10);
memTable.Add(0x010100000000, 0x01, 0xfff1);
memTable.Add(0x010100000000, 0x01, 0xfff3);
memTable.Add(0x010100000000, 0x01, 0xfff5);
using (var ptable = PTable.FromMemtable(memTable, Filename))
{
IndexEntry entry;
Assert.IsTrue(ptable.TryGetOldestEntry(0x010100000000, out entry));
Assert.AreEqual(GetHash(0x010100000000), entry.Stream);
Assert.AreEqual(0x01, entry.Version);
Assert.AreEqual(0xfff1, entry.Position);
}
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_filename = GetTempFilePath();
_finalmergefile = GetTempFilePath();
_finalmergefile2 = GetTempFilePath();
_map = IndexMap.FromFile(_filename);
var memtable = new HashListMemTable(_ptableVersion, maxSize: 10);
memtable.Add(0, 1, 0);
var guidFilename = new GuidFilenameProvider(PathName);
_result = _map.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 1, 2, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), new FakeFilenameProvider(_finalmergefile, _finalmergefile2), _ptableVersion, 4, 0, skipIndexVerify: _skipIndexVerify);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_filename = GetTempFilePath();
_finalmergefile = GetTempFilePath();
_finalmergefile2 = GetTempFilePath();
_map = IndexMap.FromFile(_filename);
var memtable = new HashListMemTable(maxSize: 10);
memtable.Add(0, 1, 0);
var guidFilename = new GuidFilenameProvider(PathName);
_result = _map.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename);
_result.ToDelete.ForEach(x => x.MarkForDestruction());
_result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 1, 2, _ => true, new FakeFilenameProvider(_finalmergefile, _finalmergefile2));
_result.ToDelete.ForEach(x => x.MarkForDestruction());
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
for (int i = 0; i < 2; i++)
{
_files.Add(GetTempFilePath());
var table = new HashListMemTable(maxSize: 20);
for (int j = 0; j < 10; j++)
{
table.Add((UInt32)j + 1, i + 1, i * j);
}
_tables.Add(PTable.FromMemtable(table, _files[i]));
}
_files.Add(GetTempFilePath());
_newtable = PTable.MergeTo(_tables, _files[2], x => false);
}
public override void SetUp()
{
base.SetUp();
_indexMapFileName = Path.Combine(PathName, "index.map");
_ptableFileName = Path.Combine(PathName, "ptable");
var indexMap = IndexMap.FromFile(_indexMapFileName, x => false, maxTablesPerLevel: 2);
var memtable = new HashListMemTable();
memtable.Add(0, 0, 0);
memtable.Add(1, 1, 100);
_ptable = PTable.FromMemtable(memtable, _ptableFileName);
indexMap = indexMap.AddFile(_ptable, 0, 0, new GuidFilenameProvider(PathName)).MergedMap;
indexMap.SaveToFile(_indexMapFileName);
}
public override void SetUp()
{
base.SetUp();
_indexMapFileName = GetFilePathFor("index.map");
_ptableFileName = GetFilePathFor("ptable");
var indexMap = IndexMap.FromFile(_indexMapFileName, maxTablesPerLevel: 2);
var memtable = new HashListMemTable(maxSize: 10);
memtable.Add(0, 0, 0);
memtable.Add(1, 1, 100);
_ptable = PTable.FromMemtable(memtable, _ptableFileName);
indexMap = indexMap.AddPTable(_ptable, 0, 0, _ => true, new GuidFilenameProvider(PathName)).MergedMap;
indexMap.SaveToFile(_indexMapFileName);
}
public override async Task TestFixtureSetUp()
{
await base.TestFixtureSetUp();
_files.Add(GetTempFilePath());
var table = new HashListMemTable(_fromVersion, maxSize: 20);
if (_fromVersion == PTableVersions.IndexV1)
{
table.Add(0x010100000000, 0, 0x0101);
table.Add(0x010200000000, 0, 0x0102);
table.Add(0x010300000000, 0, 0x0103);
table.Add(0x010400000000, 0, 0x0104);
}
else
{
table.Add(0x0101, 0, 0x0101);
table.Add(0x0102, 0, 0x0102);
table.Add(0x0103, 0, 0x0103);
table.Add(0x0104, 0, 0x0104);
}
_tables.Add(PTable.FromMemtable(table, GetTempFilePath(), Constants.PTableInitialReaderCount, Constants.PTableMaxReaderCountDefault, skipIndexVerify: _skipIndexVerify));
table = new HashListMemTable(_fromVersion, maxSize: 20);
if (_fromVersion == PTableVersions.IndexV1)
{
table.Add(0x010500000000, 0, 0x0105);
table.Add(0x010600000000, 0, 0x0106);
table.Add(0x010700000000, 0, 0x0107);
table.Add(0x010800000000, 0, 0x0108);
}
else
{
table.Add(0x0105, 0, 0x0105);
table.Add(0x0106, 0, 0x0106);
table.Add(0x0107, 0, 0x0107);
table.Add(0x0108, 0, 0x0108);
}
_tables.Add(PTable.FromMemtable(table, GetTempFilePath(), Constants.PTableInitialReaderCount, Constants.PTableMaxReaderCountDefault, skipIndexVerify: _skipIndexVerify));
_newtableFile = GetTempFilePath();
_newtable = PTable.MergeTo(_tables, _newtableFile, (streamId, hash) => hash + 1, x => true,
x => new Tuple <string, bool>(x.Stream.ToString(), true), PTableVersions.IndexV4, Constants.PTableInitialReaderCount, Constants.PTableMaxReaderCountDefault,
skipIndexVerify: _skipIndexVerify);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_filename = GetTempFilePath();
_tablename = GetTempFilePath();
_mergeFile = GetFilePathFor("mergefile");
_map = IndexMap.FromFile(_filename, x => false);
var memtable = new HashListMemTable(maxSize: 10);
memtable.Add(0, 1, 0);
var table = PTable.FromMemtable(memtable, _tablename);
_result = _map.AddFile(table, 7, 11, new FakeFilenameProvider(_mergeFile));
table.MarkForDestruction();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
for (int i = 0; i < 4; i++)
{
_files.Add(GetTempFilePath());
var table = new HashListMemTable(_ptableVersion, maxSize: 30);
for (int j = 0; j < 10; j++)
{
table.Add((ulong)(0x010100000000 << i), j, i * 10 + j);
}
_tables.Add(PTable.FromMemtable(table, _files[i]));
}
_files.Add(GetTempFilePath());
_newtable = PTable.MergeTo(_tables, _files[4], (streamId, hash) => hash, x => x.Position % 2 == 0, x => new Tuple <string, bool>("", x.Position % 2 == 0), _ptableVersion);
}
public void when_duplicated_entries_exist_the_one_with_latest_position_is_returned()
{
var memTable = new HashListMemTable(maxSize: 2000);
memTable.Add(0x11, 0x01, 0xfff1);
memTable.Add(0x11, 0x02, 0xfff2);
memTable.Add(0x11, 0x01, 0xfff3);
memTable.Add(0x11, 0x02, 0xfff4);
using (var ptable = PTable.FromMemtable(memTable, Filename))
{
IndexEntry entry;
Assert.IsTrue(ptable.TryGetLatestEntry(0x11, out entry));
Assert.AreEqual(0x11, entry.Stream);
Assert.AreEqual(0x02, entry.Version);
Assert.AreEqual(0xfff4, entry.Position);
}
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_filename = GetTempFilePath();
_tablename = GetTempFilePath();
_mergeFile = GetFilePathFor("mergefile");
_map = IndexMap.FromFile(_filename);
var memtable = new HashListMemTable(_ptableVersion, maxSize: 10);
memtable.Add(0, 1, 0);
var table = PTable.FromMemtable(memtable, _tablename);
_result = _map.AddPTable(table, 7, 11, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), new FakeFilenameProvider(_mergeFile), _ptableVersion);
table.MarkForDestruction();
}
public override void SetUp()
{
base.SetUp();
_indexMapFileName = GetFilePathFor("index.map");
_ptableFileName = GetFilePathFor("ptable");
var indexMap = IndexMap.FromFile(_indexMapFileName, maxTablesPerLevel: 2);
var memtable = new HashListMemTable(_ptableVersion, maxSize: 10);
memtable.Add(0, 0, 0);
memtable.Add(1, 1, 100);
_ptable = PTable.FromMemtable(memtable, _ptableFileName);
indexMap = indexMap.AddPTable(_ptable, 0, 0, (streamId, hash) => hash, _ => true, _ => new Tuple <string, bool>("", true), new GuidFilenameProvider(PathName), _ptableVersion).MergedMap;
indexMap.SaveToFile(_indexMapFileName);
}
