increased assertion level in NodeValueIndexCursor tests

community/kernel-api/src/main/java/org/neo4j/internal/kernel/api/IndexQuery.java

@@ -107,7 +107,7 @@ public static StringPrefixPredicate stringPrefix( int propertyKeyId, String pref
      */
     public static StringContainsPredicate stringContains( int propertyKeyId, String contains )
     {
-        return  new StringContainsPredicate( propertyKeyId, contains );
+        return new StringContainsPredicate( propertyKeyId, contains );
     }
 
     /**

community/kernel-api/src/test/java/org/neo4j/internal/kernel/api/ExplicitIndexCursorTestBase.java

@@ -27,9 +27,9 @@
 import org.neo4j.graphdb.Relationship;
 import org.neo4j.graphdb.Transaction;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
 import static org.neo4j.graphdb.RelationshipType.withName;
+import static org.neo4j.internal.kernel.api.IndexReadAsserts.assertFoundRelationships;
+import static org.neo4j.internal.kernel.api.IndexReadAsserts.assertNodeCount;
 import static org.neo4j.values.storable.Values.stringValue;
 
 public abstract class ExplicitIndexCursorTestBase<G extends KernelAPIReadTestSupport>
@@ -59,13 +59,13 @@ public void shouldFindNodeByLookup() throws Exception
             indexRead.nodeExplicitIndexLookup( cursor, "foo", "bar", stringValue( "this is it" ) );
 
             // then
-            assertFoundNodes( cursor, 1, nodes );
+            assertNodeCount( cursor, 1, nodes );
 
             // when
             indexRead.nodeExplicitIndexLookup( cursor, "foo", "bar", stringValue( "not that" ) );
 
             // then
-            assertFoundNodes( cursor, 0, nodes );
+            assertNodeCount( cursor, 0, nodes );
         }
     }
 
@@ -80,26 +80,26 @@ public void shouldFindNodeByQuery() throws Exception
             indexRead.nodeExplicitIndexQuery( cursor, "foo", "bar:this*" );
 
             // then
-            assertFoundNodes( cursor, 1, nodes );
+            assertNodeCount( cursor, 1, nodes );
 
             // when
             nodes.clear();
             indexRead.nodeExplicitIndexQuery( cursor, "foo", "bar", "this*" );
 
             // then
-            assertFoundNodes( cursor, 1, nodes );
+            assertNodeCount( cursor, 1, nodes );
 
             // when
             indexRead.nodeExplicitIndexQuery( cursor, "foo", "bar:that*" );
 
             // then
-            assertFoundNodes( cursor, 0, nodes );
+            assertNodeCount( cursor, 0, nodes );
 
             // when
             indexRead.nodeExplicitIndexQuery( cursor, "foo", "bar", "that*" );
 
             // then
-            assertFoundNodes( cursor, 0, nodes );
+            assertNodeCount( cursor, 0, nodes );
         }
     }
 
@@ -164,23 +164,4 @@ public void shouldFindRelationshipByQuery() throws Exception
         }
     }
 
-    static void assertFoundNodes( NodeIndexCursor node, int nodes, PrimitiveLongSet uniqueIds )
-    {
-        for ( int i = 0; i < nodes; i++ )
-        {
-            assertTrue( "at least " + nodes + " nodes", node.next() );
-            assertTrue( uniqueIds.add( node.nodeReference() ) );
-        }
-        assertFalse( "no more than " + nodes + " nodes", node.next() );
-    }
-
-    static void assertFoundRelationships( RelationshipIndexCursor edge, int edges, PrimitiveLongSet uniqueIds )
-    {
-        for ( int i = 0; i < edges; i++ )
-        {
-            assertTrue( "at least " + edges + " relationships", edge.next() );
-            assertTrue( uniqueIds.add( edge.relationshipReference() ) );
-        }
-        assertFalse( "no more than " + edges + " relationships", edge.next() );
-    }
 }

community/kernel-api/src/test/java/org/neo4j/internal/kernel/api/IndexQueryTest.java

@@ -283,6 +283,7 @@ public void testStringContains_SomeValues()
 
         Assert.assertFalse( test( p, "dog" ) );
         Assert.assertFalse( test( p, "cameraman" ) );
+        Assert.assertFalse( test( p, "Cat" ) );
         Assert.assertTrue( test( p, "cat" ) );
         Assert.assertTrue( test( p, "bobcat" ) );
         Assert.assertTrue( test( p, "scatman" ) );

community/kernel-api/src/test/java/org/neo4j/internal/kernel/api/IndexReadAsserts.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2002-2017 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.internal.kernel.api;
+
+import org.neo4j.collection.primitive.PrimitiveLongSet;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class IndexReadAsserts
+{
+    static void assertNodes( NodeIndexCursor node, PrimitiveLongSet uniqueIds, long... expected )
+    {
+        uniqueIds.clear();
+        for ( long count : expected )
+        {
+            assertTrue( "at least " + expected.length + " nodes", node.next() );
+            assertTrue( uniqueIds.add( node.nodeReference() ) );
+        }
+        assertFalse( "no more than " + expected.length + " nodes", node.next() );
+        assertEquals( "all nodes are unique", expected.length, uniqueIds.size() );
+        for ( long expectedNode : expected )
+        {
+            assertTrue( "expected node " + expectedNode, uniqueIds.contains( expectedNode ) );
+        }
+    }
+
+    static void assertNodeCount( NodeIndexCursor node, int expectedCount, PrimitiveLongSet uniqueIds )
+    {
+        uniqueIds.clear();
+        for ( int i = 0; i < expectedCount; i++ )
+        {
+            assertTrue( "at least " + expectedCount + " nodes", node.next() );
+            assertTrue( uniqueIds.add( node.nodeReference() ) );
+        }
+        assertFalse( "no more than " + expectedCount + " nodes", node.next() );
+    }
+
+    static void assertFoundRelationships( RelationshipIndexCursor edge, int edges, PrimitiveLongSet uniqueIds )
+    {
+        for ( int i = 0; i < edges; i++ )
+        {
+            assertTrue( "at least " + edges + " relationships", edge.next() );
+            assertTrue( uniqueIds.add( edge.relationshipReference() ) );
+        }
+        assertFalse( "no more than " + edges + " relationships", edge.next() );
+    }
+}

community/kernel-api/src/test/java/org/neo4j/internal/kernel/api/NodeLabelIndexCursorTestBase.java

@@ -27,7 +27,7 @@
 import org.neo4j.graphdb.Transaction;
 
 import static org.neo4j.graphdb.Label.label;
-import static org.neo4j.internal.kernel.api.ExplicitIndexCursorTestBase.assertFoundNodes;
+import static org.neo4j.internal.kernel.api.IndexReadAsserts.assertNodeCount;
 
 public abstract class NodeLabelIndexCursorTestBase<G extends KernelAPIReadTestSupport>
         extends KernelAPIReadTestBase<G>
@@ -63,26 +63,26 @@ public void shouldFindNodesByLabel() throws Exception
             read.nodeLabelScan( one, cursor );
 
             // then
-            assertFoundNodes( cursor, 1, uniqueIds );
+            assertNodeCount( cursor, 1, uniqueIds );
 
             // when
             read.nodeLabelScan( two, cursor );
 
             // then
-            assertFoundNodes( cursor, 2, uniqueIds );
+            assertNodeCount( cursor, 2, uniqueIds );
 
             // when
             read.nodeLabelScan( three, cursor );
 
             // then
-            assertFoundNodes( cursor, 3, uniqueIds );
+            assertNodeCount( cursor, 3, uniqueIds );
 
             // when
             uniqueIds.clear();
             read.nodeLabelScan( first, cursor );
 
             // then
-            assertFoundNodes( cursor, 3, uniqueIds );
+            assertNodeCount( cursor, 3, uniqueIds );
         }
     }
 
@@ -100,7 +100,7 @@ public void shouldFindNodesByDisjunction() throws Exception
             read.nodeLabelUnionScan( cursor, first, two );
 
             // then
-            assertFoundNodes( cursor, 4, uniqueIds );
+            assertNodeCount( cursor, 4, uniqueIds );
         }
     }
 
@@ -118,7 +118,7 @@ public void shouldFindNodesByConjunction() throws Exception
             read.nodeLabelIntersectionScan( cursor, first, two );
 
             // then
-            assertFoundNodes( cursor, 1, uniqueIds );
+            assertNodeCount( cursor, 1, uniqueIds );
         }
     }
 }