public void CouldNotReadPagesThatWereFilteredOutByJournalApplicator_2()
{
var bytes = new byte[1000];
using (var txw = Env.WriteTransaction())
{
var tree = txw.CreateTree("foo");
tree.Add("bars/1", new MemoryStream(bytes));
tree.Add("bars/2", new MemoryStream(bytes));
tree.Add("bars/3", new MemoryStream(bytes));
tree.Add("bars/4", new MemoryStream(bytes));
txw.Commit();
DebugStuff.RenderAndShow(tree);
}
using (var txw = Env.WriteTransaction())
{
var tree = txw.CreateTree("foo");
tree.Add("bars/0", new MemoryStream());
tree.Add("bars/5", new MemoryStream());
txw.Commit();
DebugStuff.RenderAndShow(tree);
}
using (var txw = Env.WriteTransaction())
{
txw.CreateTree("bar");
txw.Commit();
}
using (var txw = Env.WriteTransaction())
{
txw.CreateTree("baz");
txw.Commit();
}
using (var txr = Env.ReadTransaction())
{
using (var txw = Env.WriteTransaction())
{
var tree = txw.CreateTree("foo");
tree.Add("bars/4", new MemoryStream());
txw.Commit();
}
Env.FlushLogToDataFile();
Assert.NotNull(txr.CreateTree("foo").Read("bars/5"));
}
}
public void DebugValidate(Transaction tx, long root)
{
if (NumberOfEntries == 0)
{
return;
}
var prev = GetNodeKey(0);
var pages = new HashSet <long>();
for (int i = 1; i < NumberOfEntries; i++)
{
var node = GetNode(i);
var current = GetNodeKey(i);
if (prev.Compare(current) >= 0)
{
DebugStuff.RenderAndShow(tx, root, 1);
throw new InvalidOperationException("The page " + PageNumber + " is not sorted");
}
if (node->Flags == (NodeFlags.PageRef))
{
if (pages.Add(node->PageNumber) == false)
{
DebugStuff.RenderAndShow(tx, root, 1);
throw new InvalidOperationException("The page " + PageNumber + " references same page multiple times");
}
}
prev = current;
}
}
public void DebugValidateTree(long rootPageNumber)
{
var pages = new HashSet <long>();
var stack = new Stack <Page>();
var root = _tx.GetReadOnlyPage(rootPageNumber);
stack.Push(root);
pages.Add(rootPageNumber);
while (stack.Count > 0)
{
var p = stack.Pop();
if (p.NumberOfEntries == 0 && p != root)
{
DebugStuff.RenderAndShow(_tx, rootPageNumber, 1);
throw new InvalidOperationException("The page " + p.PageNumber + " is empty");
}
p.DebugValidate(_tx, rootPageNumber);
if (p.IsBranch == false)
{
continue;
}
for (int i = 0; i < p.NumberOfEntries; i++)
{
var page = p.GetNode(i)->PageNumber;
if (pages.Add(page) == false)
{
DebugStuff.RenderAndShow(_tx, rootPageNumber, 1);
throw new InvalidOperationException("The page " + page + " already appeared in the tree!");
}
stack.Push(_tx.GetReadOnlyPage(page));
}
}
}
public void ShouldNotThrowPageFullExceptionDuringPageSplit()
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
Env.CreateTree(tx, "foo");
tx.Commit();
}
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = tx.ReadTree("foo");
var normal = new byte[150];
var small = new byte[0];
var large = new byte[366];
new Random(1).NextBytes(small);
tree.Add("01", small);
tree.Add("02", small);
tree.Add("03", small);
tree.Add("04", small);
tree.Add("05", small);
tree.Add("06", small);
tree.Add("07", small);
tree.Add("08", small);
tree.Add("09", small);
tree.Add("10", small);
tree.Add("11", large);
tree.Add("12", large);
tree.Add("13", large);
tree.Add("14", large);
tree.Add("15", large);
tree.Add("16", large);
tree.Add("17", large);
tree.Add("18", large);
tree.Add("19", large);
tree.Add("21", large);
tree.Add("22", large);
tree.Add("23", large);
tree.Add("24", normal);
tree.Add("25", normal);
tree.Add("26", normal);
tree.Add("27", normal);
tree.Add("28", normal);
tree.Add("29", normal);
tree.Add("30", normal);
DebugStuff.RenderAndShow(tx, tree.State.RootPageNumber);
const int toInsert = 230;
tree.Add("20", new byte[toInsert]);
DebugStuff.RenderAndShow(tx, tree.State.RootPageNumber);
}
}
protected void RenderAndShow(Transaction tx, Tree root)
{
if (Debugger.IsAttached == false)
{
return;
}
var rootPageNumber = tx.Environment.CreateTree(tx, root.Name).State.RootPageNumber;
DebugStuff.RenderAndShow(root);
}
public void SinglePageModificationDoNotCauseCopyingAllIntermediatePages()
{
var keySize = 1024;
using (var tx = Env.WriteTransaction())
{
var tree = tx.CreateTree("foo");
tree.Add(new string('9', keySize), new MemoryStream(new byte[3]));
DebugStuff.RenderAndShow(tree);
tree.Add(new string('1', keySize), new MemoryStream(new byte[3]));
DebugStuff.RenderAndShow(tree);
tree.Add(new string('4', 1000), new MemoryStream(new byte[2]));
DebugStuff.RenderAndShow(tree);
tree.Add(new string('5', keySize), new MemoryStream(new byte[2]));
DebugStuff.RenderAndShow(tree);
tree.Add(new string('8', keySize), new MemoryStream(new byte[3]));
DebugStuff.RenderAndShow(tree);
tree.Add(new string('2', keySize), new MemoryStream(new byte[2]));
DebugStuff.RenderAndShow(tree);
tree.Add(new string('6', keySize), new MemoryStream(new byte[2]));
DebugStuff.RenderAndShow(tree);
tree.Add(new string('0', keySize), new MemoryStream(new byte[4]));
DebugStuff.RenderAndShow(tree);
tree.Add(new string('3', 1000), new MemoryStream(new byte[1]));
DebugStuff.RenderAndShow(tree);
tree.Add(new string('7', keySize), new MemoryStream(new byte[1]));
tx.Commit();
}
var afterAdds = Env.NextPageNumber;
using (var tx = Env.WriteTransaction())
{
var tree = tx.CreateTree("foo");
tree.Delete(new string('0', keySize));
tree.Add(new string('4', 1000), new MemoryStream(new byte[21]));
tx.Commit();
}
Assert.Equal(afterAdds, Env.NextPageNumber);
// ensure changes were applied
using (var tx = Env.ReadTransaction())
{
var tree = tx.CreateTree("foo");
Assert.Null(tree.Read(new string('0', keySize)));
var readResult = tree.Read(new string('4', 1000));
Assert.Equal(21, readResult.Reader.Length);
}
}
public unsafe void MustNotCreateEmptyNonCompressedPageAfterPageSplit()
{
using (var tx = Env.WriteTransaction())
{
tx.CreateTree("tree", flags: TreeFlags.LeafsCompressed);
tx.Commit();
}
using (var tx = Env.WriteTransaction())
{
var tree = tx.ReadTree("tree");
Assert.True(tree.State.Flags.HasFlag(TreeFlags.LeafsCompressed));
var bytes = new byte[3070];
const int numberOfItems = 21;
for (int i = 0; i < numberOfItems; i++)
{
tree.Add("items/" + i, new MemoryStream(bytes));
}
for (int i = 1; i < numberOfItems; i++) // skipping one item here
{
tree.Delete("items/" + i);
}
// after the above deletions there is only one entry on the page - "items/0"
DebugStuff.RenderAndShow(tree);
// this is an _update_ (very important)
// the issue was that the updated entry was added to a new (right) page by TreePageSplitter
// while the previous entry was removed from compressed page - effectively making it empty
tree.Add("items/0", new MemoryStream(new byte[3700]));
foreach (var pageNumber in tree.AllPages())
{
var page = new TreePage(tx.LowLevelTransaction.GetPage(pageNumber).Pointer, Constants.Storage.PageSize);
if (page.IsCompressed == false)
{
Assert.NotEqual(0, page.NumberOfEntries);
}
}
Assert.Equal(1, tree.AllPages().Count);
}
}
public void ShouldNotThrowThatPageIsFullDuringTreeRebalancing()
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "rebalancing-issue");
var aKey = new string('a', 1024);
var bKey = new string('b', 1024);
var cKey = new string('c', 1024);
var dKey = new string('d', 1024);
var eKey = new string('e', 600);
var fKey = new string('f', 920);
tree.Add(aKey, new MemoryStream(new byte[1000]));
tree.Add(bKey, new MemoryStream(new byte[1000]));
tree.Add(cKey, new MemoryStream(new byte[1000]));
tree.Add(dKey, new MemoryStream(new byte[1000]));
tree.Add(eKey, new MemoryStream(new byte[800]));
tree.Add(fKey, new MemoryStream(new byte[10]));
DebugStuff.RenderAndShow(tx, 1);
// to expose the bug we need to delete the last item from the left most page
// tree rebalance will try to fix the first reference (the implicit ref page node) in the parent page which is almost full
// and will fail because there is no space to put a new node
tree.Delete(aKey); // this line throws "The page is full and cannot add an entry, this is probably a bug"
tx.Commit();
using (var iterator = tree.Iterate())
{
Assert.True(iterator.Seek(Slice.BeforeAllKeys));
Assert.Equal(bKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(cKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(dKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(eKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(fKey, iterator.CurrentKey);
Assert.False(iterator.MoveNext());
}
}
}
public void HasReducedTreeDepthValueAfterRemovingEntries()
{
const int numberOfItems = 1024;
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "test");
for (int i = 0; i < numberOfItems; i++)
{
tree.Add("test" + new string('-', 256) + i, new byte[256]);
}
DebugStuff.RenderAndShow(tx, tree.State.RootPageNumber);
Assert.Equal(4, tree.State.Depth);
tx.Commit();
}
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = tx.ReadTree("test");
for (int i = 0; i < numberOfItems * 0.75; i++)
{
tree.Delete("test" + new string('-', 256) + i);
}
DebugStuff.RenderAndShow(tx, tree.State.RootPageNumber);
Assert.Equal(3, tree.State.Depth);
tx.Commit();
}
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = tx.ReadTree("test");
for (int i = 0; i < numberOfItems; i++)
{
tree.Delete("test" + new string('-', 256) + i);
}
DebugStuff.RenderAndShow(tx, tree.State.RootPageNumber);
Assert.Equal(1, tree.State.Depth);
}
}
public void PageNotSorted_ValidateDebugOption()
{
using (var env = new StorageEnvironment(StorageEnvironmentOptions.CreateMemoryOnly()))
{
env.DebugJournal = DebugJournal.FromFile("Bugs/Data/mapped", env);
env.DebugJournal.Replay();
using (var tx = env.NewTransaction(TransactionFlags.Read))
{
var tree = tx.ReadTree("mapped_results_by_view_and_reduce_key");
DebugStuff.RenderAndShow(tx, tree.State.RootPageNumber, 1);
}
}
}
public void HasReducedNumberOfPagesAfterRemovingHalfOfEntries()
{
const int numberOfRegularItems = 256;
const int numberOfOverflowItems = 3;
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
for (int i = 0; i < numberOfRegularItems; i++)
{
tx.Root.Add("test" + new string('-', 128) + i, new byte[256]);
}
for (int i = 0; i < numberOfOverflowItems; i++)
{
tx.Root.Add("overflow" + new string('-', 128) + i, new byte[8192]);
}
tx.Commit();
Assert.Equal(50, tx.Root.State.PageCount);
Assert.Equal(38, tx.Root.State.LeafPages);
Assert.Equal(3, tx.Root.State.BranchPages);
Assert.Equal(9, tx.Root.State.OverflowPages);
Assert.Equal(3, tx.Root.State.Depth);
}
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
for (int i = 0; i < numberOfRegularItems / 2; i++)
{
tx.Root.Delete("test" + new string('-', 128) + i);
}
tx.Root.Delete("overflow" + new string('-', 128) + 0);
tx.Commit();
DebugStuff.RenderAndShow(tx.Root);
Assert.Equal(31, tx.Root.AllPages().Count);
Assert.Equal(31, tx.Root.State.PageCount);
Assert.Equal(22, tx.Root.State.LeafPages);
Assert.Equal(3, tx.Root.State.BranchPages);
Assert.Equal(6, tx.Root.State.OverflowPages);
Assert.Equal(3, tx.Root.State.Depth);
}
}
public void CouldNotReadPagesThatWereFilteredOutByJournalApplicator_1()
{
var bytes = new byte[1000];
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(txw, "foo");
tree.Add("bars/1", new MemoryStream(bytes));
txw.Commit();
DebugStuff.RenderAndShow(tree);
}
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
Env.CreateTree(txw, "bar");
txw.Commit();
}
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
Env.CreateTree(txw, "baz");
txw.Commit();
}
using (var txr = Env.NewTransaction(TransactionFlags.Read))
{
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(txw, "foo");
tree.Add("bars/1", new MemoryStream());
txw.Commit();
DebugStuff.RenderAndShow(txw, 1);
}
Env.FlushLogToDataFile();
Assert.NotNull(Env.CreateTree(txr, "foo").Read("bars/1"));
}
}
public void CanMergeRight()
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
tx.Root.Add("1", new MemoryStream(new byte[1472]));
tx.Root.Add("2", new MemoryStream(new byte[992]));
tx.Root.Add("3", new MemoryStream(new byte[1632]));
tx.Root.Add("4", new MemoryStream(new byte[632]));
tx.Root.Add("5", new MemoryStream(new byte[824]));
tx.Root.Delete("3");
tx.Root.Add("6", new MemoryStream(new byte[1096]));
DebugStuff.RenderAndShow(tx, 1);
tx.Root.Delete("6");
tx.Root.Delete("4");
DebugStuff.RenderAndShow(tx, 1);
tx.Commit();
}
}
public void CanMergeLeft()
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
tx.Root.Add("1", new MemoryStream(new byte[1524]));
tx.Root.Add("2", new MemoryStream(new byte[1524]));
tx.Root.Add("3", new MemoryStream(new byte[1024]));
tx.Root.Add("4", new MemoryStream(new byte[64]));
DebugStuff.RenderAndShow(tx, 1);
tx.Root.Delete("2");
DebugStuff.RenderAndShow(tx, 1);
tx.Root.Delete("3");
DebugStuff.RenderAndShow(tx, 1);
tx.Commit();
}
}
public void StressTest()
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
for (int i = 0; i < 80; ++i)
{
tx.Root.Add(string.Format("{0}1", i), new MemoryStream(new byte[1472]));
tx.Root.Add(string.Format("{0}2", i), new MemoryStream(new byte[992]));
tx.Root.Add(string.Format("{0}3", i), new MemoryStream(new byte[1632]));
tx.Root.Add(string.Format("{0}4", i), new MemoryStream(new byte[632]));
tx.Root.Add(string.Format("{0}5", i), new MemoryStream(new byte[824]));
tx.Root.Add(string.Format("{0}6", i), new MemoryStream(new byte[1096]));
tx.Root.Add(string.Format("{0}7", i), new MemoryStream(new byte[2048]));
tx.Root.Add(string.Format("{0}8", i), new MemoryStream(new byte[1228]));
tx.Root.Add(string.Format("{0}9", i), new MemoryStream(new byte[8192]));
}
DebugStuff.RenderAndShow(tx, 1);
for (int i = 79; i >= 0; --i)
{
tx.Root.Delete(string.Format("{0}1", i));
tx.Root.Delete(string.Format("{0}2", i));
tx.Root.Delete(string.Format("{0}3", i));
tx.Root.Delete(string.Format("{0}4", i));
tx.Root.Delete(string.Format("{0}5", i));
tx.Root.Delete(string.Format("{0}6", i));
tx.Root.Delete(string.Format("{0}7", i));
tx.Root.Delete(string.Format("{0}8", i));
tx.Root.Delete(string.Format("{0}9", i));
}
tx.Commit();
}
}
public void ShouldCorrectlyFindSmallValueMergingByTwoSectionsInFreeSpaceHandling()
{
var dataSize = 905048; // never change this
const int itemsCount = 10;
for (int i = 0; i < itemsCount; i++)
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
tx.Root.Add("items/" + i, new byte[dataSize]);
tx.Commit();
}
if (i % (itemsCount / 3) == 0 || i % (itemsCount / 2) == 0)
{
Env.FlushLogToDataFile();
}
}
using (var tx = Env.NewTransaction(TransactionFlags.Read))
{
for (int i = 0; i < itemsCount; i++)
{
var readResult = tx.Root.Read("items/" + i);
Assert.Equal(dataSize, readResult.Reader.Length);
}
}
for (int i = 0; i < itemsCount; i++)
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
tx.Root.Delete("items/" + i);
tx.Commit();
}
if (i % (itemsCount / 3) == 0 || i % (itemsCount / 2) == 0)
{
Env.FlushLogToDataFile();
}
}
for (int i = 0; i < itemsCount; i++)
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
tx.Root.Add("items/" + i, new byte[dataSize]);
DebugStuff.RenderAndShow(tx, tx.Root.State.RootPageNumber);
tx.Commit();
}
if (i % (itemsCount / 3) == 0 || i % (itemsCount / 2) == 0)
{
Env.FlushLogToDataFile();
}
}
using (var tx = Env.NewTransaction(TransactionFlags.Read))
{
for (int i = 0; i < itemsCount; i++)
{
var readResult = tx.Root.Read("items/" + i);
Assert.Equal(dataSize, readResult.Reader.Length);
}
}
}
public void MissingScratchPagesInPageTable()
{
var bytes = new byte[1000];
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree1 = Env.CreateTree(txw, "foo");
var tree2 = Env.CreateTree(txw, "bar");
var tree3 = Env.CreateTree(txw, "baz");
tree1.Add("foos/1", new MemoryStream(bytes));
txw.Commit();
DebugStuff.RenderAndShow(txw, 1);
}
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(txw, "bar");
tree.Add("bars/1", new MemoryStream(bytes));
txw.Commit();
DebugStuff.RenderAndShow(txw, 1);
}
var bytesToFillFirstJournalCompletely = new byte[8 * AbstractPager.PageSize];
new Random().NextBytes(bytesToFillFirstJournalCompletely);
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(txw, "baz");
// here we have to put a big value to be sure that in next transaction we will put the
// updated value into a new journal file - this is the key to expose the issue
tree.Add("bazs/1", new MemoryStream(bytesToFillFirstJournalCompletely));
txw.Commit();
DebugStuff.RenderAndShow(txw, 1);
}
using (var txr = Env.NewTransaction(TransactionFlags.Read))
{
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(txw, "foo");
tree.Add("foos/1", new MemoryStream());
txw.Commit();
DebugStuff.RenderAndShow(txw, 1);
}
Env.FlushLogToDataFile();
Assert.NotNull(Env.CreateTree(txr, "foo").Read("foos/1"));
}
}
public void CanForceToFlushPagesOlderThanOldestActiveTransactionToFreePagesFromScratch()
{
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(txw, "foo");
tree.Add("bars/1", new string('a', 1000));
txw.Commit();
DebugStuff.RenderAndShow(txw, 1);
}
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
Env.CreateTree(txw, "bar");
txw.Commit();
}
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(txw, "foo");
tree.Add("bars/1", new string('b', 1000));
txw.Commit();
DebugStuff.RenderAndShow(txw, 1);
}
var txr = Env.NewTransaction(TransactionFlags.Read);
{
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(txw, "foo");
tree.Add("bars/1", new string('c', 1000));
txw.Commit();
DebugStuff.RenderAndShow(txw, 1);
}
Env.FlushLogToDataFile();
txr.Dispose();
using (var txr2 = Env.NewTransaction(TransactionFlags.Read))
{
var allocated1 = Env.ScratchBufferPool.GetNumberOfAllocations(0);
Env.FlushLogToDataFile();
var allocated2 = Env.ScratchBufferPool.GetNumberOfAllocations(0);
Assert.Equal(allocated1, allocated2);
Env.FlushLogToDataFile(allowToFlushOverwrittenPages: true);
var allocated3 = Env.ScratchBufferPool.GetNumberOfAllocations(0);
Assert.True(allocated3 < allocated2);
var read = Env.CreateTree(txr2, "foo").Read("bars/1");
Assert.NotNull(read);
Assert.Equal(new string('c', 1000), read.Reader.AsSlice().ToString());
}
}
}
public void DebugRenderAndShow()
{
DebugStuff.RenderAndShow(this);
}
public void RavenDB_2543_CouldNotEnsureThatWeHaveEnoughSpace_When_MovingLeafNode()
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "rebalancing-issue");
var aKey = new string('a', 1000);
var bKey = new string('b', 1000);
var cKey = new string('c', 1000);
var dKey = new string('d', 1020);
var eKey = new string('e', 1020);
var fKey = new string('f', 1020);
var gKey = new string('g', 1000);
var hKey = new string('h', 1000);
var iKey = new string('i', 1000);
var jKey = new string('j', 1000);
var kKey = new string('k', 1000);
var lKey = new string('l', 1000);
var mKey = new string('m', 820);
var nKey = new string('n', 102);
tree.Add(aKey, new MemoryStream(new byte[100]));
tree.Add(bKey, new MemoryStream(new byte[100]));
tree.Add(cKey, new MemoryStream(new byte[100]));
tree.Add(dKey, new MemoryStream(new byte[100]));
tree.Add(eKey, new MemoryStream(new byte[100]));
tree.Add(fKey, new MemoryStream(new byte[100]));
tree.Add(gKey, new MemoryStream(new byte[100]));
tree.Add(hKey, new MemoryStream(new byte[100]));
tree.Add(iKey, new MemoryStream(new byte[100]));
tree.Add(jKey, new MemoryStream(new byte[100]));
tree.Add(kKey, new MemoryStream(new byte[100]));
tree.Add(lKey, new MemoryStream(new byte[100]));
tree.Add(mKey, new MemoryStream(new byte[100]));
tree.Add(nKey, new MemoryStream(new byte[1000]));
DebugStuff.RenderAndShow(tx, 1);
tree.Delete(nKey); // this line throws "The page is full and cannot add an entry, this is probably a bug"
DebugStuff.RenderAndShow(tx, 1);
tx.Commit();
using (var iterator = tree.Iterate())
{
Assert.True(iterator.Seek(Slice.BeforeAllKeys));
Assert.Equal(aKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(bKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(cKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(dKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(eKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(fKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(gKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(hKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(iKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(jKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(kKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(lKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(mKey, iterator.CurrentKey);
Assert.False(iterator.MoveNext());
}
}
}