//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSeeNewNodePropertyInTransaction() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldSeeNewNodePropertyInTransaction()
{
long nodeId;
string propKey1 = "prop1";
string propKey2 = "prop2";
using (Transaction tx = beginTransaction())
{
nodeId = tx.DataWrite().nodeCreate();
int prop1 = tx.Token().propertyKeyGetOrCreateForName(propKey1);
int prop2 = tx.Token().propertyKeyGetOrCreateForName(propKey2);
assertEquals(tx.DataWrite().nodeSetProperty(nodeId, prop1, stringValue("hello")), NO_VALUE);
assertEquals(tx.DataWrite().nodeSetProperty(nodeId, prop2, stringValue("world")), NO_VALUE);
using (NodeCursor node = tx.Cursors().allocateNodeCursor(), PropertyCursor property = tx.Cursors().allocatePropertyCursor())
{
tx.DataRead().singleNode(nodeId, node);
assertTrue("should access node", node.Next());
node.Properties(property);
assertTrue(property.Next());
//First property
assertEquals(prop1, property.PropertyKey());
assertEquals(property.PropertyValue(), stringValue("hello"));
//second property
assertTrue(property.Next());
assertEquals(prop2, property.PropertyKey());
assertEquals(property.PropertyValue(), stringValue("world"));
assertFalse("should only find two properties", property.Next());
assertFalse("should only find one node", node.Next());
}
tx.Success();
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSeeNewLabeledNodeInTransaction() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldSeeNewLabeledNodeInTransaction()
{
long nodeId;
int labelId;
const string labelName = "Town";
using (Transaction tx = beginTransaction())
{
nodeId = tx.DataWrite().nodeCreate();
labelId = tx.Token().labelGetOrCreateForName(labelName);
tx.DataWrite().nodeAddLabel(nodeId, labelId);
using (NodeCursor node = tx.Cursors().allocateNodeCursor())
{
tx.DataRead().singleNode(nodeId, node);
assertTrue("should access node", node.Next());
LabelSet labels = node.Labels();
assertEquals(1, labels.NumberOfLabels());
assertEquals(labelId, labels.Label(0));
assertTrue(node.HasLabel(labelId));
assertFalse(node.HasLabel(labelId + 1));
assertFalse("should only find one node", node.Next());
}
tx.Success();
}
using (Org.Neo4j.Graphdb.Transaction ignore = graphDb.beginTx())
{
assertThat(graphDb.getNodeById(nodeId).Labels, equalTo(Iterables.iterable(label(labelName))));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldFollowSpecificRelationship()
public virtual void ShouldFollowSpecificRelationship()
{
// given
using (NodeCursor node = cursors.allocateNodeCursor(), RelationshipGroupCursor group = cursors.allocateRelationshipGroupCursor(), RelationshipTraversalCursor relationship = cursors.allocateRelationshipTraversalCursor())
{
// when - traversing from start to end
read.singleNode(_start, node);
assertTrue("access start node", node.Next());
node.Relationships(group);
assertTrue("access relationship group", group.next());
group.Outgoing(relationship);
assertTrue("access outgoing relationships", relationship.next());
// then
assertEquals("source node", _start, relationship.SourceNodeReference());
assertEquals("target node", _end, relationship.TargetNodeReference());
assertEquals("node of origin", _start, relationship.OriginNodeReference());
assertEquals("neighbouring node", _end, relationship.NeighbourNodeReference());
assertEquals("relationship should have same label as group", group.Type(), relationship.Type());
assertFalse("only a single relationship", relationship.next());
group.Incoming(relationship);
assertFalse("no incoming relationships", relationship.next());
group.Loops(relationship);
assertFalse("no loop relationships", relationship.next());
assertFalse("only a single group", group.next());
// when - traversing from end to start
read.singleNode(_end, node);
assertTrue("access start node", node.Next());
node.Relationships(group);
assertTrue("access relationship group", group.next());
group.Incoming(relationship);
assertTrue("access incoming relationships", relationship.next());
// then
assertEquals("source node", _start, relationship.SourceNodeReference());
assertEquals("target node", _end, relationship.TargetNodeReference());
assertEquals("node of origin", _end, relationship.OriginNodeReference());
assertEquals("neighbouring node", _start, relationship.NeighbourNodeReference());
assertEquals("relationship should have same label as group", group.Type(), relationship.Type());
assertFalse("only a single relationship", relationship.next());
group.Outgoing(relationship);
assertFalse("no outgoing relationships", relationship.next());
group.Loops(relationship);
assertFalse("no loop relationships", relationship.next());
assertFalse("only a single group", group.next());
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSeeLabelChangesInTransaction() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldSeeLabelChangesInTransaction()
{
long nodeId;
int toRetain, toDelete, toAdd, toRegret;
const string toRetainName = "ToRetain";
const string toDeleteName = "ToDelete";
const string toAddName = "ToAdd";
const string toRegretName = "ToRegret";
using (Transaction tx = beginTransaction())
{
nodeId = tx.DataWrite().nodeCreate();
toRetain = tx.Token().labelGetOrCreateForName(toRetainName);
toDelete = tx.Token().labelGetOrCreateForName(toDeleteName);
tx.DataWrite().nodeAddLabel(nodeId, toRetain);
tx.DataWrite().nodeAddLabel(nodeId, toDelete);
tx.Success();
}
using (Org.Neo4j.Graphdb.Transaction ignore = graphDb.beginTx())
{
assertThat(graphDb.getNodeById(nodeId).Labels, containsInAnyOrder(label(toRetainName), label(toDeleteName)));
}
using (Transaction tx = beginTransaction())
{
toAdd = tx.Token().labelGetOrCreateForName(toAddName);
tx.DataWrite().nodeAddLabel(nodeId, toAdd);
tx.DataWrite().nodeRemoveLabel(nodeId, toDelete);
toRegret = tx.Token().labelGetOrCreateForName(toRegretName);
tx.DataWrite().nodeAddLabel(nodeId, toRegret);
tx.DataWrite().nodeRemoveLabel(nodeId, toRegret);
using (NodeCursor node = tx.Cursors().allocateNodeCursor())
{
tx.DataRead().singleNode(nodeId, node);
assertTrue("should access node", node.Next());
AssertLabels(node.Labels(), toRetain, toAdd);
assertTrue(node.HasLabel(toAdd));
assertTrue(node.HasLabel(toRetain));
assertFalse(node.HasLabel(toDelete));
assertFalse(node.HasLabel(toRegret));
assertFalse("should only find one node", node.Next());
}
tx.Success();
}
using (Org.Neo4j.Graphdb.Transaction ignored = graphDb.beginTx())
{
assertThat(graphDb.getNodeById(nodeId).Labels, containsInAnyOrder(label(toRetainName), label(toAddName)));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSeeAddedPropertyFromExistingNodeWithPropertiesInTransaction() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldSeeAddedPropertyFromExistingNodeWithPropertiesInTransaction()
{
// Given
long nodeId;
string propKey1 = "prop1";
string propKey2 = "prop2";
int propToken1;
int propToken2;
using (Transaction tx = beginTransaction())
{
nodeId = tx.DataWrite().nodeCreate();
propToken1 = tx.Token().propertyKeyGetOrCreateForName(propKey1);
assertEquals(tx.DataWrite().nodeSetProperty(nodeId, propToken1, stringValue("hello")), NO_VALUE);
tx.Success();
}
// When/Then
using (Transaction tx = beginTransaction())
{
propToken2 = tx.Token().propertyKeyGetOrCreateForName(propKey2);
assertEquals(tx.DataWrite().nodeSetProperty(nodeId, propToken2, stringValue("world")), NO_VALUE);
using (NodeCursor node = tx.Cursors().allocateNodeCursor(), PropertyCursor property = tx.Cursors().allocatePropertyCursor())
{
tx.DataRead().singleNode(nodeId, node);
assertTrue("should access node", node.Next());
node.Properties(property);
//property 2, start with tx state
assertTrue(property.Next());
assertEquals(propToken2, property.PropertyKey());
assertEquals(property.PropertyValue(), stringValue("world"));
//property 1, from disk
assertTrue(property.Next());
assertEquals(propToken1, property.PropertyKey());
assertEquals(property.PropertyValue(), stringValue("hello"));
assertFalse("should only find two properties", property.Next());
assertFalse("should only find one node", node.Next());
}
tx.Success();
}
using (Org.Neo4j.Graphdb.Transaction ignored = graphDb.beginTx())
{
assertThat(graphDb.getNodeById(nodeId).getProperty(propKey1), equalTo("hello"));
assertThat(graphDb.getNodeById(nodeId).getProperty(propKey2), equalTo("world"));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldHaveBeenAbleToCreateDenseAndSparseNodes()
public virtual void ShouldHaveBeenAbleToCreateDenseAndSparseNodes()
{
// given
using (NodeCursor node = cursors.allocateNodeCursor())
{
read.singleNode(_dense.id, node);
assertTrue("access dense node", node.Next());
assertTrue("dense node", node.Dense);
read.singleNode(_sparse.id, node);
assertTrue("access sparse node", node.Next());
assertFalse("sparse node", node.Dense && SupportsSparseNodes());
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void propertyTypeShouldBeTxStateAware() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void PropertyTypeShouldBeTxStateAware()
{
// Given
long node;
using (Transaction tx = beginTransaction())
{
node = tx.DataWrite().nodeCreate();
tx.Success();
}
// Then
using (Transaction tx = beginTransaction())
{
using (NodeCursor nodes = tx.Cursors().allocateNodeCursor(), PropertyCursor properties = tx.Cursors().allocatePropertyCursor())
{
tx.DataRead().singleNode(node, nodes);
assertTrue(nodes.Next());
assertFalse(HasProperties(nodes, properties));
int prop = tx.TokenWrite().propertyKeyGetOrCreateForName("prop");
tx.DataWrite().nodeSetProperty(node, prop, stringValue("foo"));
nodes.Properties(properties);
assertTrue(properties.Next());
assertThat(properties.PropertyType(), equalTo(ValueGroup.TEXT));
}
}
}
private ResourceIterator <Relationship> GetRelationshipSelectionIterator(KernelTransaction transaction, Direction direction, int[] typeIds)
{
NodeCursor node = transaction.AmbientNodeCursor();
transaction.DataRead().singleNode(Id, node);
if (!node.Next())
{
throw new NotFoundException(format("Node %d not found", _nodeId));
}
switch (direction.innerEnumValue)
{
case Direction.InnerEnum.OUTGOING:
return(outgoingIterator(transaction.Cursors(), node, typeIds, this));
case Direction.InnerEnum.INCOMING:
return(incomingIterator(transaction.Cursors(), node, typeIds, this));
case Direction.InnerEnum.BOTH:
return(allIterator(transaction.Cursors(), node, typeIds, this));
default:
throw new System.InvalidOperationException("Unknown direction " + direction);
}
}
internal virtual IEnumerator <long> NodeGetRelationships(Transaction transaction, long node, Direction direction, int[] types)
{
NodeCursor cursor = transaction.Cursors().allocateNodeCursor();
transaction.DataRead().singleNode(node, cursor);
if (!cursor.Next())
{
return(emptyIterator());
}
switch (direction.innerEnumValue)
{
case Direction.InnerEnum.OUTGOING:
return(outgoingIterator(transaction.Cursors(), cursor, types, (id, startNodeId, typeId, endNodeId) => id));
case Direction.InnerEnum.INCOMING:
return(incomingIterator(transaction.Cursors(), cursor, types, (id, startNodeId, typeId, endNodeId) => id));
case Direction.InnerEnum.BOTH:
return(allIterator(transaction.Cursors(), cursor, types, (id, startNodeId, typeId, endNodeId) => id));
default:
throw new System.InvalidOperationException(direction + " is not a valid direction");
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void traverseViaGroups(RelationshipTestSupport.StartNode start, boolean detached) throws org.neo4j.internal.kernel.api.exceptions.KernelException
private void TraverseViaGroups(RelationshipTestSupport.StartNode start, bool detached)
{
// given
IDictionary <string, int> expectedCounts = start.ExpectedCounts();
using (NodeCursor node = cursors.allocateNodeCursor(), RelationshipGroupCursor group = cursors.allocateRelationshipGroupCursor(), RelationshipTraversalCursor relationship = cursors.allocateRelationshipTraversalCursor())
{
// when
read.singleNode(start.Id, node);
assertTrue("access node", node.Next());
if (detached)
{
read.relationshipGroups(start.Id, node.RelationshipGroupReference(), group);
}
else
{
node.Relationships(group);
}
while (group.next())
{
// outgoing
if (detached)
{
read.relationships(start.Id, group.OutgoingReference(), relationship);
}
else
{
group.Outgoing(relationship);
}
// then
assertCount(tx, relationship, expectedCounts, group.Type(), OUTGOING);
// incoming
if (detached)
{
read.relationships(start.Id, group.IncomingReference(), relationship);
}
else
{
group.Incoming(relationship);
}
// then
assertCount(tx, relationship, expectedCounts, group.Type(), INCOMING);
// loops
if (detached)
{
read.relationships(start.Id, group.LoopsReference(), relationship);
}
else
{
group.Loops(relationship);
}
// then
assertCount(tx, relationship, expectedCounts, group.Type(), BOTH);
}
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldAccessNodesByReference()
public virtual void ShouldAccessNodesByReference()
{
// given
using (NodeCursor nodes = cursors.allocateNodeCursor())
{
foreach (long id in _nodeIds)
{
// when
read.singleNode(id, nodes);
// then
assertTrue("should access defined node", nodes.Next());
assertEquals("should access the correct node", id, nodes.NodeReference());
assertFalse("should only access a single node", nodes.Next());
}
}
}
private void SingleNode(KernelTransaction transaction, NodeCursor nodes)
{
transaction.DataRead().singleNode(_nodeId, nodes);
if (!nodes.Next())
{
throw new NotFoundException(new EntityNotFoundException(EntityType.NODE, _nodeId));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldManageRandomTraversals()
public virtual void ShouldManageRandomTraversals()
{
// given
try
{
using (NodeCursor node = cursors.allocateNodeCursor(), RelationshipGroupCursor group = cursors.allocateRelationshipGroupCursor(), RelationshipTraversalCursor relationship = cursors.allocateRelationshipTraversalCursor())
{
for (int i = 0; i < N_TRAVERSALS; i++)
{
// when
long nodeId = _nodeIds[_random.Next(_nNodes)];
read.singleNode(nodeId, node);
assertTrue("access root node", node.Next());
node.Relationships(group);
assertFalse("single root", node.Next());
// then
while (group.next())
{
group.Incoming(relationship);
while (relationship.next())
{
assertEquals("incoming origin", nodeId, relationship.OriginNodeReference());
relationship.Neighbour(node);
}
group.Outgoing(relationship);
while (relationship.next())
{
assertEquals("outgoing origin", nodeId, relationship.OriginNodeReference());
relationship.Neighbour(node);
}
group.Loops(relationship);
while (relationship.next())
{
assertEquals("loop origin", nodeId, relationship.OriginNodeReference());
relationship.Neighbour(node);
}
}
}
}
}
catch (Exception t)
{
throw new Exception("Failed with random seed " + _seed, t);
}
}
private void ScanEverythingBelongingToNodes(NodeMappings nodeMappings)
{
using (NodeCursor nodeCursor = _cursors.allocateNodeCursor(), PropertyCursor propertyCursor = _cursors.allocatePropertyCursor())
{
_dataRead.allNodesScan(nodeCursor);
while (nodeCursor.Next())
{
// each node
SortedLabels labels = SortedLabels.From(nodeCursor.Labels());
nodeCursor.Properties(propertyCursor);
MutableIntSet propertyIds = IntSets.mutable.empty();
while (propertyCursor.Next())
{
Value currentValue = propertyCursor.PropertyValue();
int propertyKeyId = propertyCursor.PropertyKey();
Pair <SortedLabels, int> key = Pair.of(labels, propertyKeyId);
UpdateValueTypeInMapping(currentValue, key, nodeMappings.LabelSetANDNodePropertyKeyIdToValueType);
propertyIds.add(propertyKeyId);
}
propertyCursor.Close();
MutableIntSet oldPropertyKeySet = nodeMappings.LabelSetToPropertyKeys.getOrDefault(labels, _emptyPropertyIdSet);
// find out which old properties we did not visited and mark them as nullable
if (oldPropertyKeySet == _emptyPropertyIdSet)
{
if (propertyIds.size() == 0)
{
// Even if we find property key on other nodes with those labels, set all of them nullable
nodeMappings.NullableLabelSets.Add(labels);
}
propertyIds.addAll(oldPropertyKeySet);
}
else
{
MutableIntSet currentPropertyIdsHelperSet = new IntHashSet(propertyIds.size());
currentPropertyIdsHelperSet.addAll(propertyIds);
propertyIds.removeAll(oldPropertyKeySet); // only the brand new ones in propIds now
oldPropertyKeySet.removeAll(currentPropertyIdsHelperSet); // only the old ones that are not on the new node
propertyIds.addAll(oldPropertyKeySet);
propertyIds.forEach(id =>
{
Pair <SortedLabels, int> key = Pair.of(labels, id);
nodeMappings.LabelSetANDNodePropertyKeyIdToValueType[key].setNullable();
});
propertyIds.addAll(currentPropertyIdsHelperSet);
}
nodeMappings.LabelSetToPropertyKeys[labels] = propertyIds;
}
nodeCursor.Close();
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotAccessNonExistentProperties()
public virtual void ShouldNotAccessNonExistentProperties()
{
// given
using (NodeCursor node = cursors.allocateNodeCursor(), PropertyCursor props = cursors.allocatePropertyCursor())
{
// when
read.singleNode(_bare, node);
assertTrue("node by reference", node.Next());
assertFalse("no properties", HasProperties(node, props));
node.Properties(props);
assertFalse("no properties by direct method", props.Next());
read.nodeProperties(node.NodeReference(), node.PropertiesReference(), props);
assertFalse("no properties via property ref", props.Next());
assertFalse("only one node", node.Next());
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSeeRemovedThenAddedPropertyInTransaction() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldSeeRemovedThenAddedPropertyInTransaction()
{
// Given
long nodeId;
string propKey = "prop1";
int propToken;
using (Transaction tx = beginTransaction())
{
nodeId = tx.DataWrite().nodeCreate();
propToken = tx.Token().propertyKeyGetOrCreateForName(propKey);
assertEquals(tx.DataWrite().nodeSetProperty(nodeId, propToken, stringValue("hello")), NO_VALUE);
tx.Success();
}
// When/Then
using (Transaction tx = beginTransaction())
{
assertEquals(tx.DataWrite().nodeRemoveProperty(nodeId, propToken), stringValue("hello"));
assertEquals(tx.DataWrite().nodeSetProperty(nodeId, propToken, stringValue("world")), NO_VALUE);
using (NodeCursor node = tx.Cursors().allocateNodeCursor(), PropertyCursor property = tx.Cursors().allocatePropertyCursor())
{
tx.DataRead().singleNode(nodeId, node);
assertTrue("should access node", node.Next());
node.Properties(property);
assertTrue(property.Next());
assertEquals(propToken, property.PropertyKey());
assertEquals(property.PropertyValue(), stringValue("world"));
assertFalse("should not find any properties", property.Next());
assertFalse("should only find one node", node.Next());
}
tx.Success();
}
using (Org.Neo4j.Graphdb.Transaction ignored = graphDb.beginTx())
{
assertThat(graphDb.getNodeById(nodeId).getProperty(propKey), equalTo("world"));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldAllowManyLabelsAndPropertyCursor()
public virtual void ShouldAllowManyLabelsAndPropertyCursor()
{
int propertyCount = 10;
int labelCount = 15;
GraphDatabaseAPI db = DbRule.GraphDatabaseAPI;
Node node;
using (Transaction tx = Db.beginTx())
{
node = Db.createNode();
for (int i = 0; i < propertyCount; i++)
{
node.SetProperty("foo" + i, "bar");
}
for (int i = 0; i < labelCount; i++)
{
node.AddLabel(label("label" + i));
}
tx.Success();
}
ISet <int> seenProperties = new HashSet <int>();
ISet <int> seenLabels = new HashSet <int>();
using (Transaction tx = Db.beginTx())
{
DependencyResolver resolver = Db.DependencyResolver;
ThreadToStatementContextBridge bridge = resolver.ResolveDependency(typeof(ThreadToStatementContextBridge));
KernelTransaction ktx = bridge.GetKernelTransactionBoundToThisThread(true);
using (NodeCursor nodes = ktx.Cursors().allocateNodeCursor(), PropertyCursor propertyCursor = ktx.Cursors().allocatePropertyCursor())
{
ktx.DataRead().singleNode(node.Id, nodes);
while (nodes.Next())
{
nodes.Properties(propertyCursor);
while (propertyCursor.Next())
{
seenProperties.Add(propertyCursor.PropertyKey());
}
LabelSet labels = nodes.Labels();
for (int i = 0; i < labels.NumberOfLabels(); i++)
{
seenLabels.Add(labels.Label(i));
}
}
}
tx.Success();
}
assertEquals(propertyCount, seenProperties.Count);
assertEquals(labelCount, seenLabels.Count);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldTraverseTreeOfDepthThree()
public virtual void ShouldTraverseTreeOfDepthThree()
{
using (NodeCursor node = cursors.allocateNodeCursor(), RelationshipGroupCursor group = cursors.allocateRelationshipGroupCursor(), RelationshipTraversalCursor relationship1 = cursors.allocateRelationshipTraversalCursor(), RelationshipTraversalCursor relationship2 = cursors.allocateRelationshipTraversalCursor())
{
MutableLongSet leafs = new LongHashSet();
long total = 0;
// when
read.singleNode(_threeRoot, node);
assertTrue("access root node", node.Next());
node.Relationships(group);
assertFalse("single root", node.Next());
assertTrue("access group of root", group.next());
group.Incoming(relationship1);
assertFalse("single group of root", group.next());
while (relationship1.next())
{
relationship1.Neighbour(node);
assertTrue("child level 1", node.Next());
node.Relationships(group);
assertFalse("single node", node.Next());
assertTrue("group of level 1 child", group.next());
group.Incoming(relationship2);
assertFalse("single group of level 1 child", group.next());
while (relationship2.next())
{
leafs.add(relationship2.NeighbourNodeReference());
total++;
}
}
// then
assertEquals("total number of leaf nodes", _expectedTotal, total);
assertEquals("number of distinct leaf nodes", _expectedUnique, leafs.size());
}
}
// This is functionality which is only required for the hacky db.schema not to leak real data
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotAccessNegativeReferences()
public virtual void ShouldNotAccessNegativeReferences()
{
// given
using (NodeCursor node = cursors.allocateNodeCursor())
{
// when
read.singleNode(-2L, node);
// then
assertFalse("should not access negative reference node", node.Next());
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotFindDeletedNode()
public virtual void ShouldNotFindDeletedNode()
{
// given
using (NodeCursor nodes = cursors.allocateNodeCursor())
{
// when
read.singleNode(_gone, nodes);
// then
assertFalse("should not access deleted node", nodes.Next());
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldTraverseRelationshipsOfGivenType()
public virtual void ShouldTraverseRelationshipsOfGivenType()
{
// given
using (NodeCursor node = cursors.allocateNodeCursor(), RelationshipGroupCursor group = cursors.allocateRelationshipGroupCursor(), RelationshipTraversalCursor relationship = cursors.allocateRelationshipTraversalCursor())
{
int empty = 0;
// when
read.allNodesScan(node);
while (node.Next())
{
node.Relationships(group);
bool none = true;
while (group.next())
{
none = false;
Sizes degree = new Sizes();
group.Outgoing(relationship);
while (relationship.next())
{
assertEquals("node #" + node.NodeReference() + " relationship should have same label as group", group.Type(), relationship.Type());
degree.Outgoing++;
}
group.Incoming(relationship);
while (relationship.next())
{
assertEquals("node #" + node.NodeReference() + "relationship should have same label as group", group.Type(), relationship.Type());
degree.Incoming++;
}
group.Loops(relationship);
while (relationship.next())
{
assertEquals("node #" + node.NodeReference() + "relationship should have same label as group", group.Type(), relationship.Type());
degree.Loop++;
}
// then
assertNotEquals("all", 0, degree.Incoming + degree.Outgoing + degree.Loop);
assertEquals("node #" + node.NodeReference() + " outgoing", group.OutgoingCount(), degree.Outgoing);
assertEquals("node #" + node.NodeReference() + " incoming", group.IncomingCount(), degree.Incoming);
assertEquals("node #" + node.NodeReference() + " loop", group.LoopCount(), degree.Loop);
assertEquals("node #" + node.NodeReference() + " all = incoming + outgoing - loop", group.TotalCount(), degree.Incoming + degree.Outgoing + degree.Loop);
}
if (none)
{
empty++;
}
}
// then
assertEquals("number of empty nodes", 1, empty);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSeeNodeInTransaction() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldSeeNodeInTransaction()
{
long nodeId;
using (Transaction tx = beginTransaction())
{
nodeId = tx.DataWrite().nodeCreate();
using (NodeCursor node = tx.Cursors().allocateNodeCursor())
{
tx.DataRead().singleNode(nodeId, node);
assertTrue("should access node", node.Next());
assertEquals(nodeId, node.NodeReference());
assertFalse("should only find one node", node.Next());
}
tx.Success();
}
using (Org.Neo4j.Graphdb.Transaction ignore = graphDb.beginTx())
{
assertEquals(nodeId, graphDb.getNodeById(nodeId).Id);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotAccessGroupsOfBareNode()
public virtual void ShouldNotAccessGroupsOfBareNode()
{
// given
using (NodeCursor node = cursors.allocateNodeCursor(), RelationshipGroupCursor group = cursors.allocateRelationshipGroupCursor())
{
// when
read.singleNode(_bare, node);
assertTrue("access node", node.Next());
node.Relationships(group);
// then
assertFalse("access group", group.next());
}
}
protected internal virtual int CountNodes(Transaction transaction)
{
int result = 0;
using (NodeCursor cursor = transaction.Cursors().allocateNodeCursor())
{
transaction.DataRead().allNodesScan(cursor);
while (cursor.Next())
{
result++;
}
}
return(result);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void hasPropertiesShouldSeeNewlyCreatedPropertiesOnNewlyCreatedNode() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void HasPropertiesShouldSeeNewlyCreatedPropertiesOnNewlyCreatedNode()
{
using (Transaction tx = beginTransaction())
{
long node = tx.DataWrite().nodeCreate();
using (NodeCursor cursor = tx.Cursors().allocateNodeCursor(), PropertyCursor props = tx.Cursors().allocatePropertyCursor())
{
tx.DataRead().singleNode(node, cursor);
assertTrue(cursor.Next());
assertFalse(HasProperties(cursor, props));
tx.DataWrite().nodeSetProperty(node, tx.TokenWrite().propertyKeyGetOrCreateForName("prop"), stringValue("foo"));
assertTrue(HasProperties(cursor, props));
}
}
}
public override bool HasLabel(Label label)
{
KernelTransaction transaction = SafeAcquireTransaction();
NodeCursor nodes = transaction.AmbientNodeCursor();
using (Statement ignore = transaction.AcquireStatement())
{
int labelId = transaction.TokenRead().nodeLabel(label.Name());
if (labelId == NO_SUCH_LABEL)
{
return(false);
}
transaction.DataRead().singleNode(_nodeId, nodes);
return(nodes.Next() && nodes.HasLabel(labelId));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldScanNodes()
public virtual void ShouldScanNodes()
{
// given
IList <long> ids = new List <long>();
using (NodeCursor nodes = cursors.allocateNodeCursor())
{
// when
read.allNodesScan(nodes);
while (nodes.Next())
{
ids.Add(nodes.NodeReference());
}
}
// then
assertEquals(_nodeIds, ids);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldAccessAllNodeProperties()
public virtual void ShouldAccessAllNodeProperties()
{
// given
using (NodeCursor node = cursors.allocateNodeCursor(), PropertyCursor props = cursors.allocatePropertyCursor())
{
// when
read.singleNode(_allProps, node);
assertTrue("node by reference", node.Next());
assertTrue("has properties", HasProperties(node, props));
node.Properties(props);
ISet <object> values = new HashSet <object>();
while (props.Next())
{
values.Add(props.PropertyValue().asObject());
}
assertTrue("byteProp", values.Contains(( sbyte )13));
assertTrue("shortProp", values.Contains(( short )13));
assertTrue("intProp", values.Contains(13));
assertTrue("inlineLongProp", values.Contains(13L));
assertTrue("longProp", values.Contains(long.MaxValue));
assertTrue("floatProp", values.Contains(13.0f));
assertTrue("doubleProp", values.Contains(13.0));
assertTrue("trueProp", values.Contains(true));
assertTrue("falseProp", values.Contains(false));
assertTrue("charProp", values.Contains('x'));
assertTrue("emptyStringProp", values.Contains(""));
assertTrue("shortStringProp", values.Contains("hello"));
assertTrue("utf8Prop", values.Contains(_chinese));
if (SupportsBigProperties())
{
assertTrue("longStringProp", values.Contains(LONG_STRING));
assertThat("smallArray", values, hasItem(IntArray(1, 2, 3, 4)));
assertThat("bigArray", values, hasItem(arrayContaining(LONG_STRING)));
}
assertTrue("pointProp", values.Contains(_pointValue));
int expected = SupportsBigProperties() ? 18 : 15;
assertEquals("number of values", expected, values.Count);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldDiscoverDeletedNodeInTransaction() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldDiscoverDeletedNodeInTransaction()
{
long nodeId;
using (Transaction tx = beginTransaction())
{
nodeId = tx.DataWrite().nodeCreate();
tx.Success();
}
using (Transaction tx = beginTransaction())
{
assertTrue(tx.DataWrite().nodeDelete(nodeId));
using (NodeCursor node = tx.Cursors().allocateNodeCursor())
{
tx.DataRead().singleNode(nodeId, node);
assertFalse(node.Next());
}
tx.Success();
}
}
private void AssertAccessSingleProperty(long nodeId, object expectedValue, ValueGroup expectedValueType)
{
// given
using (NodeCursor node = cursors.allocateNodeCursor(), PropertyCursor props = cursors.allocatePropertyCursor())
{
// when
read.singleNode(nodeId, node);
assertTrue("node by reference", node.Next());
assertTrue("has properties", HasProperties(node, props));
node.Properties(props);
assertTrue("has properties by direct method", props.Next());
assertEquals("correct value", expectedValue, props.PropertyValue());
assertEquals("correct value type ", expectedValueType, props.PropertyType());
assertFalse("single property", props.Next());
read.nodeProperties(node.NodeReference(), node.PropertiesReference(), props);
assertTrue("has properties via property ref", props.Next());
assertEquals("correct value", expectedValue, props.PropertyValue());
assertFalse("single property", props.Next());
}
}
