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 ); } } }