diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/GroupReferenceEncoding.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/GroupReferenceEncoding.java
new file mode 100644
index 0000000000000..10df55b4d9d46
--- /dev/null
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/GroupReferenceEncoding.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2002-2018 "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 .
+ */
+package org.neo4j.kernel.impl.newapi;
+
+import static org.neo4j.kernel.impl.store.record.AbstractBaseRecord.NO_ID;
+
+class GroupReferenceEncoding
+{
+ private static final long DIRECT = 0x1000_0000_0000_0000L;
+
+ /**
+ * Encode a relationship id as a group reference.
+ */
+ static long encodeRelationship( long relationshipId )
+ {
+ return relationshipId | DIRECT | References.FLAG_MARKER;
+ }
+
+ /**
+ * Check whether a group reference is an encoded relationship id.
+ */
+ static boolean isRelationship( long groupReference )
+ {
+ assert groupReference != NO_ID;
+ return (groupReference & References.FLAG_MASK) == DIRECT;
+ }
+}
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/NodeCursor.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/NodeCursor.java
index abf9a9e27132b..9b88c20629d17 100644
--- a/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/NodeCursor.java
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/NodeCursor.java
@@ -151,13 +151,13 @@ public void properties( PropertyCursor cursor )
@Override
public long relationshipGroupReference()
{
- return isDense() ? getNextRel() : References.Group.encodeRelationship( getNextRel() );
+ return isDense() ? getNextRel() : GroupReferenceEncoding.encodeRelationship( getNextRel() );
}
@Override
public long allRelationshipsReference()
{
- return isDense() ? References.Relationship.encodeFromGroup( getNextRel() ) : getNextRel();
+ return isDense() ? RelationshipReferenceEncoding.encodeGroup( getNextRel() ) : getNextRel();
}
@Override
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/Read.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/Read.java
index 548ff2c0db525..79d3d152435e9 100644
--- a/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/Read.java
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/Read.java
@@ -49,13 +49,7 @@
import org.neo4j.values.storable.Value;
import org.neo4j.values.storable.ValueGroup;
-import static org.neo4j.kernel.impl.newapi.References.Group.isRelationship;
-import static org.neo4j.kernel.impl.newapi.References.Relationship.isFilter;
-import static org.neo4j.kernel.impl.newapi.References.Relationship.isGroup;
-import static org.neo4j.kernel.impl.newapi.References.Relationship.isNoIncoming;
-import static org.neo4j.kernel.impl.newapi.References.Relationship.isNoLoop;
-import static org.neo4j.kernel.impl.newapi.References.Relationship.isNoOutgoing;
-import static org.neo4j.kernel.impl.newapi.References.Relationship.isTxStateFilter;
+import static org.neo4j.kernel.impl.newapi.GroupReferenceEncoding.isRelationship;
import static org.neo4j.kernel.impl.newapi.References.clearEncoding;
import static org.neo4j.kernel.impl.newapi.RelationshipDirection.INCOMING;
import static org.neo4j.kernel.impl.newapi.RelationshipDirection.LOOP;
@@ -287,41 +281,45 @@ public final void relationships(
* This means that we need reference encodings (flags) for cases: 1, 3, 4, 5
*/
ktx.assertOpen();
- if ( reference == NO_ID ) // there are no relationships for this node
+
+ int relationshipType;
+ RelationshipReferenceEncoding encoding = RelationshipReferenceEncoding.parseEncoding( reference );
+
+ switch ( encoding )
{
- // still initiate cursor in case there are tx-state additions
+ case NONE: // this is a normal relationship reference
((RelationshipTraversalCursor) cursor).chain( nodeReference, reference, this );
- }
- else if ( isGroup( reference ) ) // this reference is actually to a group record
- {
- ((RelationshipTraversalCursor) cursor).groups( nodeReference, clearEncoding( reference ), this );
- }
- else if ( isFilter( reference ) ) // this relationship chain needs to be filtered
- {
+ break;
+
+ case FILTER: // this relationship chain needs to be filtered
((RelationshipTraversalCursor) cursor).filtered( nodeReference, clearEncoding( reference ), this, true );
- }
- else if ( isTxStateFilter( reference ) ) // tx-state changes should be filtered by the head of this chain
- {
+ break;
+
+ case FILTER_TX_STATE: // tx-state changes should be filtered by the head of this chain
((RelationshipTraversalCursor) cursor).filtered( nodeReference, clearEncoding( reference ), this, false );
- }
- else if ( isNoOutgoing( reference ) ) // nothing in store, but proceed to check tx-state changes
- {
- int relationshipType = (int) clearEncoding( reference );
+ break;
+
+ case GROUP: // this reference is actually to a group record
+ ((RelationshipTraversalCursor) cursor).groups( nodeReference, clearEncoding( reference ), this );
+ break;
+
+ case NO_OUTGOING_OF_TYPE: // nothing in store, but proceed to check tx-state changes
+ relationshipType = (int) clearEncoding( reference );
((RelationshipTraversalCursor) cursor).filteredTxState( nodeReference, this, relationshipType, OUTGOING );
- }
- else if ( isNoIncoming( reference ) ) // nothing in store, but proceed to check tx-state changes
- {
- int relationshipType = (int) clearEncoding( reference );
+ break;
+
+ case NO_INCOMING_OF_TYPE: // nothing in store, but proceed to check tx-state changes
+ relationshipType = (int) clearEncoding( reference );
((RelationshipTraversalCursor) cursor).filteredTxState( nodeReference, this, relationshipType, INCOMING );
- }
- else if ( isNoLoop( reference ) ) // nothing in store, but proceed to check tx-state changes
- {
- int relationshipType = (int) clearEncoding( reference );
+ break;
+
+ case NO_LOOP_OF_TYPE: // nothing in store, but proceed to check tx-state changes
+ relationshipType = (int) clearEncoding( reference );
((RelationshipTraversalCursor) cursor).filteredTxState( nodeReference, this, relationshipType, LOOP );
- }
- else // this is a normal relationship reference
- {
- ((RelationshipTraversalCursor) cursor).chain( nodeReference, reference, this );
+ break;
+
+ default:
+ throw new IllegalStateException( "Unknown encoding " + encoding );
}
}
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/References.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/References.java
index 866420bae657d..b84160d2fbfab 100644
--- a/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/References.java
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/References.java
@@ -47,9 +47,9 @@
*/
class References
{
- private static final long FLAG_MARKER = 0x8000_0000_0000_0000L;
- private static final long FLAG_MASK = 0x7000_0000_0000_0000L;
- private static final long FLAGS = 0xF000_0000_0000_0000L;
+ static final long FLAG_MARKER = 0x8000_0000_0000_0000L;
+ static final long FLAG_MASK = 0x7000_0000_0000_0000L;
+ static final long FLAGS = 0xF000_0000_0000_0000L;
/**
* Clear all encoding from a reference.
@@ -62,149 +62,4 @@ static long clearEncoding( long reference )
assert reference != NO_ID;
return reference & ~FLAGS;
}
-
- static class Relationship
- {
- /** @see #encodeForFiltering(long) */
- private static final long FILTER = 0x1000_0000_0000_0000L;
-
- /** @see #encodeForTxStateFiltering(long) */
- private static final long FILTER_TX_STATE = 0x2000_0000_0000_0000L;
-
- /** @see #encodeFromGroup(long) */
- private static final long GROUP = 0x3000_0000_0000_0000L;
-
- /** @see #encodeNoOutgoingRels(int) */
- private static final long NO_OUTGOING_OF_TYPE = 0x4000_0000_0000_0000L;
-
- /** @see #encodeNoIncomingRels(int) */
- private static final long NO_INCOMING_OF_TYPE = 0x5000_0000_0000_0000L;
-
- /** @see #encodeNoLoopRels(int) */
- private static final long NO_LOOP_OF_TYPE = 0x6000_0000_0000_0000L;
-
- /**
- * Encode a group id as a relationship reference.
- */
- static long encodeFromGroup( long groupId )
- {
- return groupId | GROUP | FLAG_MARKER;
- }
-
- /**
- * Check whether a relationship reference is an encoded group id.
- */
- static boolean isGroup( long relationshipReference )
- {
- assert relationshipReference != NO_ID;
- return (relationshipReference & FLAG_MASK) == GROUP;
- }
-
- /**
- * Encode that the relationship id needs filtering by it's first element.
- */
- static long encodeForFiltering( long relationshipId )
- {
- return relationshipId | FILTER | FLAG_MARKER;
- }
-
- /**
- * Check whether a relationship reference is a relationship id marked for filtering.
- */
- static boolean isFilter( long relationshipReference )
- {
- assert relationshipReference != NO_ID;
- return (relationshipReference & FLAG_MASK) == FILTER;
- }
-
- /**
- * Encode that the relationship id needs filtering by it's first element.
- */
- static long encodeForTxStateFiltering( long relationshipId )
- {
- return relationshipId | FILTER_TX_STATE | FLAG_MARKER;
- }
-
- /**
- * Check whether a relationship reference is a relationship id marked for tx-state filtering.
- */
- static boolean isTxStateFilter( long relationshipReference )
- {
- assert relationshipReference != NO_ID;
- return (relationshipReference & FLAG_MASK) == FILTER_TX_STATE;
- }
-
- /**
- * Encode that no outgoing relationships of the encoded type exist.
- */
- static long encodeNoOutgoingRels( int type )
- {
- return type | NO_OUTGOING_OF_TYPE | FLAG_MARKER;
- }
-
- /**
- * Check whether this reference encode that no outgoing relationships of the encoded type exist.
- */
- static boolean isNoOutgoing( long relationshipReference )
- {
- assert relationshipReference != NO_ID;
- return (relationshipReference & FLAG_MASK) == NO_OUTGOING_OF_TYPE;
- }
-
- /**
- * Encode that no incoming relationships of the encoded type exist.
- */
- static long encodeNoIncomingRels( int type )
- {
- return type | NO_INCOMING_OF_TYPE | FLAG_MARKER;
- }
-
- /**
- * Check whether this reference encode that no incoming relationships of the encoded type exist.
- */
- static boolean isNoIncoming( long relationshipReference )
- {
- assert relationshipReference != NO_ID;
- return (relationshipReference & FLAG_MASK) == NO_INCOMING_OF_TYPE;
- }
-
- /**
- * Encode that no loop relationships of the encoded type exist.
- */
- static long encodeNoLoopRels( int type )
- {
- return type | NO_LOOP_OF_TYPE | FLAG_MARKER;
- }
-
- /**
- * Check whether this reference encode that no loop relationships of the encoded type exist.
- */
- static boolean isNoLoop( long relationshipReference )
- {
- assert relationshipReference != NO_ID;
- return (relationshipReference & FLAG_MASK) == NO_LOOP_OF_TYPE;
- }
- }
-
- static class Group
- {
- private static final long DIRECT = 0x1000_0000_0000_0000L;
-
- /**
- * Encode a relationship id as a group reference.
- */
- static long encodeRelationship( long relationshipId )
- {
- return relationshipId | DIRECT | FLAG_MARKER;
- }
-
- /**
- * Check whether a group reference is an encoded relationship id.
- */
- static boolean isRelationship( long groupReference )
- {
- assert groupReference != NO_ID;
- return (groupReference & FLAG_MASK) == DIRECT;
- }
- }
}
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/RelationshipGroupCursor.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/RelationshipGroupCursor.java
index a23b239370723..dc619457b7490 100644
--- a/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/RelationshipGroupCursor.java
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/RelationshipGroupCursor.java
@@ -26,9 +26,11 @@
import org.neo4j.kernel.impl.store.record.RelationshipGroupRecord;
import org.neo4j.kernel.impl.store.record.RelationshipRecord;
-import static org.neo4j.kernel.impl.newapi.References.Relationship.encodeNoIncomingRels;
-import static org.neo4j.kernel.impl.newapi.References.Relationship.encodeNoLoopRels;
-import static org.neo4j.kernel.impl.newapi.References.Relationship.encodeNoOutgoingRels;
+import static org.neo4j.kernel.impl.newapi.RelationshipReferenceEncoding.encodeForFiltering;
+import static org.neo4j.kernel.impl.newapi.RelationshipReferenceEncoding.encodeForTxStateFiltering;
+import static org.neo4j.kernel.impl.newapi.RelationshipReferenceEncoding.encodeNoIncomingRels;
+import static org.neo4j.kernel.impl.newapi.RelationshipReferenceEncoding.encodeNoLoopRels;
+import static org.neo4j.kernel.impl.newapi.RelationshipReferenceEncoding.encodeNoOutgoingRels;
class RelationshipGroupCursor extends RelationshipGroupRecord implements org.neo4j.internal.kernel.api.RelationshipGroupCursor
{
@@ -345,14 +347,7 @@ private boolean isBuffered()
private long encodeRelationshipReference( long relationshipId )
{
assert relationshipId != NO_ID;
- if ( isBuffered() )
- {
- return References.Relationship.encodeForFiltering( relationshipId );
- }
- else
- {
- return References.Relationship.encodeForTxStateFiltering( relationshipId );
- }
+ return isBuffered() ? encodeForFiltering( relationshipId ) : encodeForTxStateFiltering( relationshipId );
}
static class BufferedGroup
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/RelationshipReferenceEncoding.java b/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/RelationshipReferenceEncoding.java
new file mode 100644
index 0000000000000..6b69870f2abea
--- /dev/null
+++ b/community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/RelationshipReferenceEncoding.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2002-2018 "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 .
+ */
+package org.neo4j.kernel.impl.newapi;
+
+import static org.neo4j.kernel.impl.store.record.AbstractBaseRecord.NO_ID;
+
+enum RelationshipReferenceEncoding
+{
+ /** No encoding */
+ NONE ( 0 ),
+
+ /** @see #encodeForFiltering(long) */
+ FILTER ( 1 ),
+
+ /** @see #encodeForTxStateFiltering(long) */
+ FILTER_TX_STATE ( 2 ),
+
+ /** @see #encodeGroup(long) */
+ GROUP ( 3 ),
+
+ /** @see #encodeNoOutgoingRels(int) */
+ NO_OUTGOING_OF_TYPE ( 4 ),
+
+ /** @see #encodeNoIncomingRels(int) */
+ NO_INCOMING_OF_TYPE ( 5 ),
+
+ /** @see #encodeNoLoopRels(int) */
+ NO_LOOP_OF_TYPE ( 6 );
+
+ final long id;
+ final long bits;
+
+ RelationshipReferenceEncoding( long id )
+ {
+ this.id = id;
+ this.bits = id << 60;
+ }
+
+ static RelationshipReferenceEncoding parseEncoding( long reference )
+ {
+ if ( reference == NO_ID )
+ {
+ return NONE;
+ }
+ return RelationshipReferenceEncoding.values()[encodingId( reference )];
+ }
+
+ private static int encodingId( long reference )
+ {
+ return (int)((reference & References.FLAG_MASK) >> 60);
+ }
+
+ /**
+ * Encode a group id as a relationship reference.
+ */
+ static long encodeGroup( long groupId )
+ {
+ return groupId | GROUP.bits | References.FLAG_MARKER;
+ }
+
+ /**
+ * Encode that the relationship id needs filtering by it's first element.
+ */
+ static long encodeForFiltering( long relationshipId )
+ {
+ return relationshipId | FILTER.bits | References.FLAG_MARKER;
+ }
+
+ /**
+ * Encode that the relationship id needs filtering by it's first element.
+ */
+ static long encodeForTxStateFiltering( long relationshipId )
+ {
+ return relationshipId | FILTER_TX_STATE.bits | References.FLAG_MARKER;
+ }
+
+ /**
+ * Encode that no outgoing relationships of the encoded type exist.
+ */
+ static long encodeNoOutgoingRels( int type )
+ {
+ return type | NO_OUTGOING_OF_TYPE.bits | References.FLAG_MARKER;
+ }
+
+ /**
+ * Encode that no incoming relationships of the encoded type exist.
+ */
+ static long encodeNoIncomingRels( int type )
+ {
+ return type | NO_INCOMING_OF_TYPE.bits | References.FLAG_MARKER;
+ }
+
+ /**
+ * Encode that no loop relationships of the encoded type exist.
+ */
+ static long encodeNoLoopRels( int type )
+ {
+ return type | NO_LOOP_OF_TYPE.bits | References.FLAG_MARKER;
+ }
+}
diff --git a/community/kernel/src/test/java/org/neo4j/kernel/impl/newapi/ReferencesTest.java b/community/kernel/src/test/java/org/neo4j/kernel/impl/newapi/ReferencesTest.java
index 4cbeb2047bede..e828c274e15e1 100644
--- a/community/kernel/src/test/java/org/neo4j/kernel/impl/newapi/ReferencesTest.java
+++ b/community/kernel/src/test/java/org/neo4j/kernel/impl/newapi/ReferencesTest.java
@@ -23,13 +23,19 @@
import java.util.concurrent.ThreadLocalRandom;
-import org.neo4j.kernel.impl.newapi.References.Group;
-import org.neo4j.kernel.impl.newapi.References.Relationship;
-
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertTrue;
+import static org.neo4j.kernel.impl.newapi.RelationshipReferenceEncoding.FILTER;
+import static org.neo4j.kernel.impl.newapi.RelationshipReferenceEncoding.FILTER_TX_STATE;
+import static org.neo4j.kernel.impl.newapi.RelationshipReferenceEncoding.GROUP;
+import static org.neo4j.kernel.impl.newapi.RelationshipReferenceEncoding.NO_INCOMING_OF_TYPE;
+import static org.neo4j.kernel.impl.newapi.RelationshipReferenceEncoding.NO_LOOP_OF_TYPE;
+import static org.neo4j.kernel.impl.newapi.RelationshipReferenceEncoding.NO_OUTGOING_OF_TYPE;
+import static org.neo4j.kernel.impl.newapi.RelationshipReferenceEncoding.parseEncoding;
import static org.neo4j.kernel.impl.newapi.References.clearEncoding;
import static org.neo4j.kernel.impl.store.record.AbstractBaseRecord.NO_ID;
@@ -41,14 +47,14 @@ public class ReferencesTest
@Test
public void shouldPreserveNoId()
{
- assertThat( Relationship.encodeForFiltering( NO_ID ), equalTo( (long) NO_ID ) );
- assertThat( Relationship.encodeForTxStateFiltering( NO_ID ), equalTo( (long) NO_ID ) );
- assertThat( Relationship.encodeFromGroup( NO_ID ), equalTo( (long) NO_ID ) );
- assertThat( Relationship.encodeNoIncomingRels( NO_ID ), equalTo( (long) NO_ID ) );
- assertThat( Relationship.encodeNoOutgoingRels( NO_ID ), equalTo( (long) NO_ID ) );
- assertThat( Relationship.encodeNoLoopRels( NO_ID ), equalTo( (long) NO_ID ) );
-
- assertThat( Group.encodeRelationship( NO_ID ), equalTo( (long) NO_ID ) );
+ assertThat( RelationshipReferenceEncoding.encodeForFiltering( NO_ID ), equalTo( (long) NO_ID ) );
+ assertThat( RelationshipReferenceEncoding.encodeForTxStateFiltering( NO_ID ), equalTo( (long) NO_ID ) );
+ assertThat( RelationshipReferenceEncoding.encodeGroup( NO_ID ), equalTo( (long) NO_ID ) );
+ assertThat( RelationshipReferenceEncoding.encodeNoIncomingRels( NO_ID ), equalTo( (long) NO_ID ) );
+ assertThat( RelationshipReferenceEncoding.encodeNoOutgoingRels( NO_ID ), equalTo( (long) NO_ID ) );
+ assertThat( RelationshipReferenceEncoding.encodeNoLoopRels( NO_ID ), equalTo( (long) NO_ID ) );
+
+ assertThat( GroupReferenceEncoding.encodeRelationship( NO_ID ), equalTo( (long) NO_ID ) );
}
@Test
@@ -60,14 +66,14 @@ public void shouldClearFlags()
long reference = random.nextLong( MAX_ID_LIMIT );
int token = random.nextInt(Integer.MAX_VALUE);
- assertThat( clearEncoding( Relationship.encodeFromGroup( reference ) ), equalTo( reference ) );
- assertThat( clearEncoding( Relationship.encodeForFiltering( reference ) ), equalTo( reference ) );
- assertThat( clearEncoding( Relationship.encodeForTxStateFiltering( reference ) ), equalTo( reference ) );
- assertThat( clearEncoding( Relationship.encodeNoIncomingRels( token ) ), equalTo( (long) token ) );
- assertThat( clearEncoding( Relationship.encodeNoOutgoingRels( token ) ), equalTo( (long) token ) );
- assertThat( clearEncoding( Relationship.encodeNoLoopRels( token ) ), equalTo( (long) token ) );
+ assertThat( clearEncoding( RelationshipReferenceEncoding.encodeGroup( reference ) ), equalTo( reference ) );
+ assertThat( clearEncoding( RelationshipReferenceEncoding.encodeForFiltering( reference ) ), equalTo( reference ) );
+ assertThat( clearEncoding( RelationshipReferenceEncoding.encodeForTxStateFiltering( reference ) ), equalTo( reference ) );
+ assertThat( clearEncoding( RelationshipReferenceEncoding.encodeNoIncomingRels( token ) ), equalTo( (long) token ) );
+ assertThat( clearEncoding( RelationshipReferenceEncoding.encodeNoOutgoingRels( token ) ), equalTo( (long) token ) );
+ assertThat( clearEncoding( RelationshipReferenceEncoding.encodeNoLoopRels( token ) ), equalTo( (long) token ) );
- assertThat( clearEncoding( Group.encodeRelationship( reference ) ), equalTo( reference ) );
+ assertThat( clearEncoding( GroupReferenceEncoding.encodeRelationship( reference ) ), equalTo( reference ) );
}
}
@@ -80,9 +86,9 @@ public void encodeForFiltering()
for ( int i = 0; i < 1000; i++ )
{
long reference = random.nextLong( MAX_ID_LIMIT );
- assertFalse( Relationship.isFilter( reference ) );
- assertTrue( Relationship.isFilter( Relationship.encodeForFiltering( reference ) ) );
- assertTrue( "encoded reference is negative", Relationship.encodeForFiltering( reference ) < 0 );
+ assertNotEquals( FILTER, parseEncoding( reference ) );
+ assertEquals( FILTER, parseEncoding( RelationshipReferenceEncoding.encodeForFiltering( reference ) ) );
+ assertTrue( "encoded reference is negative", RelationshipReferenceEncoding.encodeForFiltering( reference ) < 0 );
}
}
@@ -93,9 +99,9 @@ public void encodeForTxStateFiltering()
for ( int i = 0; i < 1000; i++ )
{
long reference = random.nextLong( MAX_ID_LIMIT );
- assertFalse( Relationship.isTxStateFilter( reference ) );
- assertTrue( Relationship.isTxStateFilter( Relationship.encodeForTxStateFiltering( reference ) ) );
- assertTrue( "encoded reference is negative", Relationship.encodeForTxStateFiltering( reference ) < 0 );
+ assertNotEquals( FILTER_TX_STATE, parseEncoding( reference ) );
+ assertEquals( FILTER_TX_STATE, parseEncoding( RelationshipReferenceEncoding.encodeForTxStateFiltering( reference ) ) );
+ assertTrue( "encoded reference is negative", RelationshipReferenceEncoding.encodeForTxStateFiltering( reference ) < 0 );
}
}
@@ -106,9 +112,9 @@ public void encodeFromGroup()
for ( int i = 0; i < 1000; i++ )
{
long reference = random.nextLong( MAX_ID_LIMIT );
- assertFalse( Relationship.isGroup( reference ) );
- assertTrue( Relationship.isGroup( Relationship.encodeFromGroup( reference ) ) );
- assertTrue( "encoded reference is negative", Relationship.encodeFromGroup( reference ) < 0 );
+ assertNotEquals( GROUP, parseEncoding( reference ) );
+ assertEquals( GROUP, parseEncoding( RelationshipReferenceEncoding.encodeGroup( reference ) ) );
+ assertTrue( "encoded reference is negative", RelationshipReferenceEncoding.encodeGroup( reference ) < 0 );
}
}
@@ -119,9 +125,9 @@ public void encodeNoIncomingRels()
for ( int i = 0; i < 1000; i++ )
{
int token = random.nextInt(Integer.MAX_VALUE);
- assertFalse( Relationship.isNoIncoming( token ) );
- assertTrue( Relationship.isNoIncoming( Relationship.encodeNoIncomingRels( token ) ) );
- assertTrue( "encoded reference is negative", Relationship.encodeNoIncomingRels( token ) < 0 );
+ assertNotEquals( NO_INCOMING_OF_TYPE, parseEncoding( token ) );
+ assertEquals( NO_INCOMING_OF_TYPE, parseEncoding( RelationshipReferenceEncoding.encodeNoIncomingRels( token ) ) );
+ assertTrue( "encoded reference is negative", RelationshipReferenceEncoding.encodeNoIncomingRels( token ) < 0 );
}
}
@@ -132,9 +138,9 @@ public void encodeNoOutgoingRels()
for ( int i = 0; i < 1000; i++ )
{
int token = random.nextInt(Integer.MAX_VALUE);
- assertFalse( Relationship.isNoOutgoing( token ) );
- assertTrue( Relationship.isNoOutgoing( Relationship.encodeNoOutgoingRels( token ) ) );
- assertTrue( "encoded reference is negative", Relationship.encodeNoOutgoingRels( token ) < 0 );
+ assertNotEquals( NO_OUTGOING_OF_TYPE, parseEncoding( token ) );
+ assertEquals( NO_OUTGOING_OF_TYPE, parseEncoding( RelationshipReferenceEncoding.encodeNoOutgoingRels( token ) ) );
+ assertTrue( "encoded reference is negative", RelationshipReferenceEncoding.encodeNoOutgoingRels( token ) < 0 );
}
}
@@ -145,9 +151,9 @@ public void encodeNoLoopRels()
for ( int i = 0; i < 1000; i++ )
{
int token = random.nextInt(Integer.MAX_VALUE);
- assertFalse( Relationship.isNoLoop( token ) );
- assertTrue( Relationship.isNoLoop( Relationship.encodeNoLoopRels( token ) ) );
- assertTrue( "encoded reference is negative", Relationship.encodeNoLoopRels( token ) < 0 );
+ assertNotEquals( NO_LOOP_OF_TYPE, parseEncoding( token ) );
+ assertEquals( NO_LOOP_OF_TYPE, parseEncoding( RelationshipReferenceEncoding.encodeNoLoopRels( token ) ) );
+ assertTrue( "encoded reference is negative", RelationshipReferenceEncoding.encodeNoLoopRels( token ) < 0 );
}
}
@@ -160,9 +166,9 @@ public void encodeRelationship()
for ( int i = 0; i < 1000; i++ )
{
long reference = random.nextLong( MAX_ID_LIMIT );
- assertFalse( Group.isRelationship( reference ) );
- assertTrue( Group.isRelationship( Group.encodeRelationship( reference ) ) );
- assertTrue( "encoded reference is negative", Group.encodeRelationship( reference ) < 0 );
+ assertFalse( GroupReferenceEncoding.isRelationship( reference ) );
+ assertTrue( GroupReferenceEncoding.isRelationship( GroupReferenceEncoding.encodeRelationship( reference ) ) );
+ assertTrue( "encoded reference is negative", GroupReferenceEncoding.encodeRelationship( reference ) < 0 );
}
}
}