From 2db8796f3b70c58f389ae529d46c00167a96f192 Mon Sep 17 00:00:00 2001
From: Mattias Persson <mattias@neotechnology.com>
Date: Wed, 21 Dec 2016 09:48:44 +0100
Subject: [PATCH] GB+Tree tests runs with access checking page cache

ConsistencyChecker was changed to do proper shouldRetry-access as part of this.
---
 .../index/gbptree/ConsistencyChecker.java     | 191 ++++++++++++------
 .../neo4j/index/gbptree/RightmostInChain.java |  69 +++----
 .../index/gbptree/ByteArrayPageCursor.java    |  17 +-
 .../index/gbptree/ConsistencyCheckerTest.java |   4 +-
 .../org/neo4j/index/gbptree/GBPTreeIT.java    |   2 +-
 .../index/gbptree/GBPTreeRecoveryTest.java    |   3 +-
 .../org/neo4j/index/gbptree/GBPTreeTest.java  |   2 +-
 .../index/gbptree/InternalTreeLogicTest.java  |  12 +-
 8 files changed, 190 insertions(+), 110 deletions(-)

diff --git a/community/index/src/main/java/org/neo4j/index/gbptree/ConsistencyChecker.java b/community/index/src/main/java/org/neo4j/index/gbptree/ConsistencyChecker.java
index 4c3aca801f28..a2a2b41a6946 100644
--- a/community/index/src/main/java/org/neo4j/index/gbptree/ConsistencyChecker.java
+++ b/community/index/src/main/java/org/neo4j/index/gbptree/ConsistencyChecker.java
@@ -24,14 +24,15 @@
 import java.util.BitSet;
 import java.util.Comparator;
 import java.util.List;
-
 import org.neo4j.collection.primitive.PrimitiveLongIterator;
+import org.neo4j.io.pagecache.CursorException;
 import org.neo4j.io.pagecache.PageCursor;
 
 import static java.lang.Math.toIntExact;
 import static java.lang.String.format;
 
 import static org.neo4j.index.gbptree.GenSafePointerPair.pointer;
+import static org.neo4j.index.gbptree.PageCursorUtil.checkOutOfBounds;
 
 /**
  * <ul>
@@ -48,7 +49,7 @@ class ConsistencyChecker<KEY>
     private final KEY readKey;
     private final Comparator<KEY> comparator;
     private final Layout<KEY,?> layout;
-    private final List<RightmostInChain<KEY>> rightmostPerLevel = new ArrayList<>();
+    private final List<RightmostInChain> rightmostPerLevel = new ArrayList<>();
     private final long stableGeneration;
     private final long unstableGeneration;
 
@@ -195,14 +196,25 @@ private static void addToSeenList( BitSet target, long id, long lastId )
         target.set( index );
     }
 
-    private void assertOnTreeNode( PageCursor cursor )
+    private void assertOnTreeNode( PageCursor cursor ) throws IOException
     {
-        if ( TreeNode.nodeType( cursor ) != TreeNode.NODE_TYPE_TREE_NODE )
+        byte nodeType;
+        boolean isInternal;
+        boolean isLeaf;
+        do
+        {
+            nodeType = TreeNode.nodeType( cursor );
+            isInternal = node.isInternal( cursor );
+            isLeaf = node.isLeaf( cursor );
+        }
+        while ( cursor.shouldRetry() );
+
+        if ( nodeType != TreeNode.NODE_TYPE_TREE_NODE )
         {
             throw new IllegalArgumentException( "Cursor is not pinned to a tree node page. pageId:" +
                     cursor.getCurrentPageId() );
         }
-        if ( !node.isInternal( cursor ) && !node.isLeaf( cursor ) )
+        if ( !isInternal && !isLeaf )
         {
             throw new IllegalArgumentException( "Cursor is not pinned to a page containing a tree node. pageId:" +
                     cursor.getCurrentPageId() );
@@ -212,56 +224,95 @@ private void assertOnTreeNode( PageCursor cursor )
     private boolean checkSubtree( PageCursor cursor, KeyRange<KEY> range, long expectedGen, int level )
             throws IOException
     {
-        // check header pointers
-        assertNoCrashOrBrokenPointerInGSPP(
-                cursor, stableGeneration, unstableGeneration, "LeftSibling", TreeNode.BYTE_POS_LEFTSIBLING, node );
-        assertNoCrashOrBrokenPointerInGSPP(
-                cursor, stableGeneration, unstableGeneration, "RightSibling", TreeNode.BYTE_POS_RIGHTSIBLING, node );
-        assertNoCrashOrBrokenPointerInGSPP(
-                cursor, stableGeneration, unstableGeneration, "NewGen", TreeNode.BYTE_POS_NEWGEN, node );
+        boolean isInternal = false;
+        boolean isLeaf = false;
+        int keyCount;
+        long newGen;
+        long newGenGen;
 
-        long pageId = assertSiblings( cursor, level );
-
-        checkNewGenPointerGen( cursor );
-
-        assertPointerGenMatchesGen( cursor, expectedGen );
+        long leftSibling;
+        long rightSibling;
+        long leftSiblingGen;
+        long rightSiblingGen;
+        long gen;
 
-        if ( node.isInternal( cursor ) )
-        {
-            assertKeyOrderAndSubtrees( cursor, pageId, range, level );
-        }
-        else if ( node.isLeaf( cursor ) )
+        do
         {
-            assertKeyOrder( cursor, range );
+            // check header pointers
+            assertNoCrashOrBrokenPointerInGSPP(
+                    cursor, stableGeneration, unstableGeneration, "LeftSibling", TreeNode.BYTE_POS_LEFTSIBLING, node );
+            assertNoCrashOrBrokenPointerInGSPP(
+                    cursor, stableGeneration, unstableGeneration, "RightSibling", TreeNode.BYTE_POS_RIGHTSIBLING, node );
+            assertNoCrashOrBrokenPointerInGSPP(
+                    cursor, stableGeneration, unstableGeneration, "NewGen", TreeNode.BYTE_POS_NEWGEN, node );
+
+            // for assertSiblings
+            leftSibling = node.leftSibling( cursor, stableGeneration, unstableGeneration );
+            rightSibling = node.rightSibling( cursor, stableGeneration, unstableGeneration );
+            leftSiblingGen = node.pointerGen( cursor, leftSibling );
+            rightSiblingGen = node.pointerGen( cursor, rightSibling );
+            leftSibling = pointer( leftSibling );
+            rightSibling = pointer( rightSibling );
+            gen = node.gen( cursor );
+
+            newGen = node.newGen( cursor, stableGeneration, unstableGeneration );
+            newGenGen = node.pointerGen( cursor, newGen );
+
+            keyCount = node.keyCount( cursor );
+            if ( keyCount > node.internalMaxKeyCount() && keyCount > node.leafMaxKeyCount() )
+            {
+                cursor.setCursorException( "Unexpected keyCount:" + keyCount );
+                continue;
+            }
+            assertKeyOrder( cursor, range, keyCount );
+            isInternal = node.isInternal( cursor );
+            isLeaf = node.isLeaf( cursor );
         }
-        else
+        while ( cursor.shouldRetry() );
+        checkAfterShouldRetry( cursor );
+
+        if ( !isInternal && !isLeaf )
         {
             throw new TreeInconsistencyException( "Page:" + cursor.getCurrentPageId() + " at level:" + level +
                     " isn't a tree node, parent expected range " + range );
         }
+
+        assertPointerGenMatchesGen( cursor, gen, expectedGen );
+        assertSiblings( cursor, gen, leftSibling, leftSiblingGen, rightSibling, rightSiblingGen, level );
+        checkNewGenPointerGen( cursor, newGen, newGenGen );
+
+        if ( isInternal )
+        {
+            assertSubtrees( cursor, range, keyCount, level );
+        }
         return true;
     }
 
-    private void assertPointerGenMatchesGen( PageCursor cursor, long expectedGen )
+    private static void assertPointerGenMatchesGen( PageCursor cursor, long nodeGen, long expectedGen )
     {
-        long nodeGen = node.gen( cursor );
         assert nodeGen <= expectedGen : "Expected node:" + cursor.getCurrentPageId() + " gen:" + nodeGen +
                 " to be ≤ pointer gen:" + expectedGen;
     }
 
-    private void checkNewGenPointerGen( PageCursor cursor ) throws IOException
+    private void checkNewGenPointerGen( PageCursor cursor, long newGen, long newGenGen )
+            throws IOException
     {
-        long newGen = node.newGen( cursor, stableGeneration, unstableGeneration );
         if ( TreeNode.isNode( newGen ) )
         {
-            System.err.println( "WARNING: we ended up on an old generation " + cursor.getCurrentPageId() +
+            cursor.setCursorException( "WARNING: we ended up on an old generation " + cursor.getCurrentPageId() +
                     " which had newGen:" + pointer( newGen ) );
-            long newGenGen = node.pointerGen( cursor, newGen );
             long origin = cursor.getCurrentPageId();
             node.goTo( cursor, "newGen", newGen );
             try
             {
-                assertPointerGenMatchesGen( cursor, newGenGen );
+                long nodeGen;
+                do
+                {
+                    nodeGen = node.gen( cursor );
+                }
+                while ( cursor.shouldRetry() );
+
+                assertPointerGenMatchesGen( cursor, nodeGen, newGenGen );
             }
             finally
             {
@@ -271,49 +322,50 @@ private void checkNewGenPointerGen( PageCursor cursor ) throws IOException
     }
 
     // Assumption: We traverse the tree from left to right on every level
-    private long assertSiblings( PageCursor cursor, int level )
+    private void assertSiblings( PageCursor cursor, long gen, long leftSibling, long leftSiblingGen,
+            long rightSibling, long rightSiblingGen, int level )
     {
         // If this is the first time on this level, we will add a new entry
         for ( int i = rightmostPerLevel.size(); i <= level; i++ )
         {
-            RightmostInChain<KEY> first = new RightmostInChain<>( node, stableGeneration, unstableGeneration );
-            rightmostPerLevel.add( i, first );
+            rightmostPerLevel.add( i, new RightmostInChain() );
         }
-        RightmostInChain<KEY> rightmost = rightmostPerLevel.get( level );
+        RightmostInChain rightmost = rightmostPerLevel.get( level );
 
-        return rightmost.assertNext( cursor );
+        rightmost.assertNext( cursor, gen, leftSibling, leftSiblingGen, rightSibling, rightSiblingGen );
     }
 
-    private void assertKeyOrderAndSubtrees( PageCursor cursor, long pageId, KeyRange<KEY> range, int level )
+    private void assertSubtrees( PageCursor cursor, KeyRange<KEY> range, int keyCount, int level )
             throws IOException
     {
-        int keyCount = node.keyCount( cursor );
+        long pageId = cursor.getCurrentPageId();
         KEY prev = layout.newKey();
         KeyRange<KEY> childRange;
 
+        // Check children, all except the last one
         int pos = 0;
         while ( pos < keyCount )
         {
-            node.keyAt( cursor, readKey, pos );
-            assert range.inRange( readKey ) :
-                readKey + " (pos " + pos + "/" + (keyCount-1) + ")" + " isn't in range " + range;
-            if ( pos > 0 )
+            long child;
+            long childGen;
+            do
             {
-                assert comparator.compare( prev, readKey ) < 0; // Assume unique keys
+                child = childAt( cursor, pos );
+                childGen = node.pointerGen( cursor, child );
+                node.keyAt( cursor, readKey, pos );
             }
+            while ( cursor.shouldRetry() );
+            checkAfterShouldRetry( cursor );
 
-            long child = childAt( cursor, pos );
-            long childGen = node.pointerGen( cursor, child );
-            node.goTo( cursor, "child at pos " + pos, child );
-            if ( pos == 0 )
-            {
-                childRange = range.restrictRight( readKey );
-            }
-            else
+            childRange = range.restrictRight( readKey );
+            if ( pos > 0 )
             {
-                childRange = range.restrictLeft( prev ).restrictRight( readKey );
+                childRange = range.restrictLeft( prev );
             }
+
+            node.goTo( cursor, "child at pos " + pos, child );
             checkSubtree( cursor, childRange, childGen, level + 1 );
+
             node.goTo( cursor, "parent", pageId );
 
             layout.copyKey( readKey, prev );
@@ -321,14 +373,28 @@ private void assertKeyOrderAndSubtrees( PageCursor cursor, long pageId, KeyRange
         }
 
         // Check last child
-        long child = childAt( cursor, pos );
-        long childGen = node.pointerGen( cursor, child );
+        long child;
+        long childGen;
+        do
+        {
+            child = childAt( cursor, pos );
+            childGen = node.pointerGen( cursor, child );
+        }
+        while ( cursor.shouldRetry() );
+        checkAfterShouldRetry( cursor );
+
         node.goTo( cursor, "child at pos " + pos, child );
         childRange = range.restrictLeft( prev );
         checkSubtree( cursor, childRange, childGen, level + 1 );
         node.goTo( cursor, "parent", pageId );
     }
 
+    private static void checkAfterShouldRetry( PageCursor cursor ) throws CursorException
+    {
+        checkOutOfBounds( cursor );
+        cursor.checkAndClearCursorException();
+    }
+
     private long childAt( PageCursor cursor, int pos )
     {
         assertNoCrashOrBrokenPointerInGSPP(
@@ -336,18 +402,23 @@ private long childAt( PageCursor cursor, int pos )
         return node.childAt( cursor, pos, stableGeneration, unstableGeneration );
     }
 
-    private void assertKeyOrder( PageCursor cursor, KeyRange<KEY> range )
+    private void assertKeyOrder( PageCursor cursor, KeyRange<KEY> range, int keyCount )
     {
-        int keyCount = node.keyCount( cursor );
         KEY prev = layout.newKey();
         boolean first = true;
         for ( int pos = 0; pos < keyCount; pos++ )
         {
             node.keyAt( cursor, readKey, pos );
-            assert range.inRange( readKey ) : "Expected " + readKey + " to be in range " + range;
+            if ( !range.inRange( readKey ) )
+            {
+                cursor.setCursorException( "Expected " + readKey + " to be in range " + range );
+            }
             if ( !first )
             {
-                assert comparator.compare( prev, readKey ) < 0; // Assume unique keys
+                if ( comparator.compare( prev, readKey ) >= 0 )
+                {
+                    cursor.setCursorException( "Non-unique key " + readKey );
+                }
             }
             else
             {
@@ -384,11 +455,11 @@ static void assertNoCrashOrBrokenPointerInGSPP( PageCursor cursor, long stableGe
         {
             boolean isInternal = treeNode.isInternal( cursor );
             String type = isInternal ? "internal" : "leaf";
-            throw new TreeInconsistencyException(
+            cursor.setCursorException( format(
                     "GSPP state found that was not ok in %s field in %s node with id %d%n  slotA[%s]%n  slotB[%s]",
                     pointerFieldName, type, currentNodeId,
                     stateToString( generationA, pointerA, stateA ),
-                    stateToString( generationB, pointerB, stateB ) );
+                    stateToString( generationB, pointerB, stateB ) ) );
         }
     }
 
diff --git a/community/index/src/main/java/org/neo4j/index/gbptree/RightmostInChain.java b/community/index/src/main/java/org/neo4j/index/gbptree/RightmostInChain.java
index 8f53f200b4a0..da36929fa4a1 100644
--- a/community/index/src/main/java/org/neo4j/index/gbptree/RightmostInChain.java
+++ b/community/index/src/main/java/org/neo4j/index/gbptree/RightmostInChain.java
@@ -21,7 +21,6 @@
 
 import org.neo4j.io.pagecache.PageCursor;
 
-import static org.neo4j.index.gbptree.GenSafePointerPair.pointer;
 import static org.neo4j.index.gbptree.TreeNode.NO_NODE_FLAG;
 
 /**
@@ -31,64 +30,52 @@
  * <p>
  * When assertNext has been called on node that is expected to be last in chain, use {@link #assertLast()} to verify.
  */
-class RightmostInChain<KEY>
+class RightmostInChain
 {
-    private final TreeNode<KEY,?> node;
-    private final long stableGeneration;
-    private final long unstableGeneration;
-
-    private long currentRightmost;
-    private long expectedNextRightmost;
+    private long currentRightmost = TreeNode.NO_NODE_FLAG;
+    private long expectedNextRightmost = TreeNode.NO_NODE_FLAG;
     private long expectedNextRightmostGen;
     private long currentRightmostGen;
 
-    RightmostInChain( TreeNode<KEY,?> node, long stableGeneration, long unstableGeneration )
-    {
-        this.node = node;
-        this.stableGeneration = stableGeneration;
-        this.unstableGeneration = unstableGeneration;
-        this.currentRightmost = TreeNode.NO_NODE_FLAG;
-        this.expectedNextRightmost = TreeNode.NO_NODE_FLAG;
-    }
-
-    long assertNext( PageCursor cursor )
+    void assertNext( PageCursor cursor, long gen,
+            long leftSibling, long leftSiblingGen, long rightSibling, long rightSiblingGen )
     {
         long pageId = cursor.getCurrentPageId();
 
-        long leftSibling = node.leftSibling( cursor, stableGeneration, unstableGeneration );
-        long rightSibling = node.rightSibling( cursor, stableGeneration, unstableGeneration );
-        long leftSiblingGen = node.pointerGen( cursor, leftSibling );
-        long rightSiblingGen = node.pointerGen( cursor, rightSibling );
-        leftSibling = pointer( leftSibling );
-        rightSibling = pointer( rightSibling );
-        long gen = node.gen( cursor );
-
         // Assert we have reached expected node and that we agree about being siblings
-        assert leftSibling == currentRightmost :
-                "Sibling pointer does align with tree structure. Expected left sibling to be " +
-                currentRightmost + " but was " + leftSibling;
-        assert leftSiblingGen <= currentRightmostGen || currentRightmost == NO_NODE_FLAG:
-                "Sibling pointer gen differs from expected. Expected left sigling gen to be " +
-                currentRightmostGen + ", but was " + leftSiblingGen;
-        assert pageId == expectedNextRightmost ||
-               (expectedNextRightmost == NO_NODE_FLAG && currentRightmost == NO_NODE_FLAG) :
-                "Sibling pointer does not align with tree structure. Expected right sibling to be " +
-                expectedNextRightmost + " but was " + rightSibling;
-        assert gen <= expectedNextRightmostGen || expectedNextRightmost == NO_NODE_FLAG:
+        if ( leftSibling != currentRightmost )
+        {
+            cursor.setCursorException( "Sibling pointer does align with tree structure. Expected left sibling to be " +
+                    currentRightmost + " but was " + leftSibling );
+        }
+        if ( !(leftSiblingGen <= currentRightmostGen || currentRightmost == NO_NODE_FLAG) )
+        {
+            cursor.setCursorException( "Sibling pointer gen differs from expected. Expected left sigling gen to be " +
+                    currentRightmostGen + ", but was " + leftSiblingGen );
+        }
+        if ( !(pageId == expectedNextRightmost ||
+                (expectedNextRightmost == NO_NODE_FLAG && currentRightmost == NO_NODE_FLAG)) )
+        {
+            cursor.setCursorException( "Sibling pointer does not align with tree structure. Expected right sibling to be " +
+                    expectedNextRightmost + " but was " + pageId );
+        }
+        if ( !(gen <= expectedNextRightmostGen || expectedNextRightmost == NO_NODE_FLAG) )
+        {
+            cursor.setCursorException(
                 "Sibling pointer gen differs from expected. Expected right sigling gen to be " +
-                expectedNextRightmostGen + ", but was " + gen;
+                expectedNextRightmostGen + ", but was " + gen );
+        }
 
         // Update currentRightmost = pageId;
         currentRightmost = pageId;
         currentRightmostGen = gen;
         expectedNextRightmost = rightSibling;
         expectedNextRightmostGen = rightSiblingGen;
-        return pageId;
     }
 
     void assertLast()
     {
-        assert expectedNextRightmost == NO_NODE_FLAG : "Expected rightmost right sibling to be " +
-                                                       NO_NODE_FLAG + " but was " + expectedNextRightmost;
+        assert expectedNextRightmost == NO_NODE_FLAG : "Expected rightmost right sibling to be " + NO_NODE_FLAG
+                + " but was " + expectedNextRightmost;
     }
 }
diff --git a/community/index/src/test/java/org/neo4j/index/gbptree/ByteArrayPageCursor.java b/community/index/src/test/java/org/neo4j/index/gbptree/ByteArrayPageCursor.java
index b22296ca160f..30a2a8a8a9b5 100644
--- a/community/index/src/test/java/org/neo4j/index/gbptree/ByteArrayPageCursor.java
+++ b/community/index/src/test/java/org/neo4j/index/gbptree/ByteArrayPageCursor.java
@@ -24,6 +24,7 @@
 import java.nio.ByteBuffer;
 import java.util.Arrays;
 
+import org.neo4j.helpers.Exceptions;
 import org.neo4j.io.pagecache.CursorException;
 import org.neo4j.io.pagecache.PageCursor;
 
@@ -44,6 +45,7 @@
 class ByteArrayPageCursor extends PageCursor
 {
     private final ByteBuffer buffer;
+    private CursorException cursorException;
 
     static PageCursor wrap( byte[] array, int offset, int length )
     {
@@ -258,7 +260,18 @@ public boolean checkAndClearBoundsFlag()
 
     @Override
     public void checkAndClearCursorException() throws CursorException
-    {   // Don't check
+    {
+        if ( cursorException != null )
+        {
+            try
+            {
+                throw cursorException;
+            }
+            finally
+            {
+                cursorException = null;
+            }
+        }
     }
 
     @Override
@@ -270,7 +283,7 @@ public void raiseOutOfBounds()
     @Override
     public void setCursorException( String message )
     {
-        throw new UnsupportedOperationException();
+        cursorException = Exceptions.chain( cursorException, new CursorException( message ) );
     }
 
     @Override
diff --git a/community/index/src/test/java/org/neo4j/index/gbptree/ConsistencyCheckerTest.java b/community/index/src/test/java/org/neo4j/index/gbptree/ConsistencyCheckerTest.java
index f9e117148510..7339c0606625 100644
--- a/community/index/src/test/java/org/neo4j/index/gbptree/ConsistencyCheckerTest.java
+++ b/community/index/src/test/java/org/neo4j/index/gbptree/ConsistencyCheckerTest.java
@@ -24,6 +24,7 @@
 
 import org.neo4j.collection.primitive.PrimitiveLongCollections;
 import org.neo4j.index.ValueMergers;
+import org.neo4j.io.pagecache.CursorException;
 import org.neo4j.io.pagecache.PageCursor;
 
 import static org.hamcrest.CoreMatchers.containsString;
@@ -59,9 +60,10 @@ public void shouldThrowDescriptiveExceptionOnBrokenGSPP() throws Exception
         {
             assertNoCrashOrBrokenPointerInGSPP( cursor, stableGeneration, unstableGeneration,
                     pointerFieldName, TreeNode.BYTE_POS_NEWGEN, treeNode );
+            cursor.checkAndClearCursorException();
             fail( "Should have failed" );
         }
-        catch ( TreeInconsistencyException e )
+        catch ( CursorException e )
         {
             // THEN
             assertThat( e.getMessage(), containsString( pointerFieldName ) );
diff --git a/community/index/src/test/java/org/neo4j/index/gbptree/GBPTreeIT.java b/community/index/src/test/java/org/neo4j/index/gbptree/GBPTreeIT.java
index 9e928bccb1bc..b16264214c1e 100644
--- a/community/index/src/test/java/org/neo4j/index/gbptree/GBPTreeIT.java
+++ b/community/index/src/test/java/org/neo4j/index/gbptree/GBPTreeIT.java
@@ -85,7 +85,7 @@ private GBPTree<MutableLong,MutableLong> createIndex( int pageSize )
     private GBPTree<MutableLong,MutableLong> createIndex( int pageSize, GBPTree.Monitor monitor )
             throws IOException
     {
-        pageCache = pageCacheRule.getPageCache( fs.get(), config().withPageSize( pageSize ) );
+        pageCache = pageCacheRule.getPageCache( fs.get(), config().withPageSize( pageSize ).withAccessChecks( true ) );
         return index = new GBPTree<>( pageCache, directory.file( "index" ),
                 layout, 0/*use whatever page cache says*/, monitor );
     }
diff --git a/community/index/src/test/java/org/neo4j/index/gbptree/GBPTreeRecoveryTest.java b/community/index/src/test/java/org/neo4j/index/gbptree/GBPTreeRecoveryTest.java
index 0ec8b895e1b9..e104a86311a7 100644
--- a/community/index/src/test/java/org/neo4j/index/gbptree/GBPTreeRecoveryTest.java
+++ b/community/index/src/test/java/org/neo4j/index/gbptree/GBPTreeRecoveryTest.java
@@ -61,7 +61,8 @@ public class GBPTreeRecoveryTest
 
     private final EphemeralFileSystemRule fs = new EphemeralFileSystemRule();
     private final TestDirectory directory = TestDirectory.testDirectory( getClass(), fs.get() );
-    private final PageCacheRule pageCacheRule = new PageCacheRule( config().withPageSize( PAGE_SIZE ) );
+    private final PageCacheRule pageCacheRule = new PageCacheRule(
+            config().withPageSize( PAGE_SIZE ).withAccessChecks( true ) );
     private final RandomRule random = new RandomRule();
 
     @Rule
diff --git a/community/index/src/test/java/org/neo4j/index/gbptree/GBPTreeTest.java b/community/index/src/test/java/org/neo4j/index/gbptree/GBPTreeTest.java
index 5fcc93e567f9..74d0423183c8 100644
--- a/community/index/src/test/java/org/neo4j/index/gbptree/GBPTreeTest.java
+++ b/community/index/src/test/java/org/neo4j/index/gbptree/GBPTreeTest.java
@@ -66,7 +66,7 @@ public class GBPTreeTest
 {
     private final DefaultFileSystemRule fs = new DefaultFileSystemRule();
     private final TestDirectory directory = TestDirectory.testDirectory( getClass(), fs.get() );
-    private final PageCacheRule pageCacheRule = new PageCacheRule();
+    private final PageCacheRule pageCacheRule = new PageCacheRule( config().withAccessChecks( true ) );
     private final RandomRule random = new RandomRule();
 
     @Rule
diff --git a/community/index/src/test/java/org/neo4j/index/gbptree/InternalTreeLogicTest.java b/community/index/src/test/java/org/neo4j/index/gbptree/InternalTreeLogicTest.java
index 69e014b37e3f..1b894dfee8ba 100644
--- a/community/index/src/test/java/org/neo4j/index/gbptree/InternalTreeLogicTest.java
+++ b/community/index/src/test/java/org/neo4j/index/gbptree/InternalTreeLogicTest.java
@@ -1065,12 +1065,18 @@ private void newRootFromSplit( StructurePropagation<MutableLong> split ) throws
     private void assertSiblingOrderAndPointers( long... children ) throws IOException
     {
         long currentPageId = cursor.getCurrentPageId();
-        RightmostInChain<MutableLong> rightmost =
-                new RightmostInChain<>( node, stableGen, unstableGen );
+        RightmostInChain rightmost = new RightmostInChain();
         for ( long child : children )
         {
             goTo( cursor, child );
-            rightmost.assertNext( cursor );
+            long leftSibling = node.leftSibling( cursor, stableGen, unstableGen );
+            long rightSibling = node.rightSibling( cursor, stableGen, unstableGen );
+            rightmost.assertNext( cursor,
+                    node.gen( cursor ),
+                    pointer( leftSibling ),
+                    node.pointerGen( cursor, leftSibling ),
+                    pointer( rightSibling ),
+                    node.pointerGen( cursor, rightSibling ) );
         }
         rightmost.assertLast();
         goTo( cursor, currentPageId );