//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldHandleSingleNodePath()
public virtual void ShouldHandleSingleNodePath()
{
// Given
Node node;
using (Transaction tx = Db.beginTx())
{
node = Db.createNode();
tx.Success();
}
// When
Path mapped = _mapper.mapPath(path(AsNodeValues(node), AsRelationshipsValues()));
// Then
using (Transaction ignore = Db.beginTx())
{
assertThat(mapped.Length(), equalTo(0));
assertThat(mapped.StartNode(), equalTo(node));
assertThat(mapped.EndNode(), equalTo(node));
assertThat(Iterables.asList(mapped.Relationships()), hasSize(0));
assertThat(Iterables.asList(mapped.ReverseRelationships()), hasSize(0));
assertThat(Iterables.asList(mapped.Nodes()), equalTo(singletonList(node)));
assertThat(Iterables.asList(mapped.ReverseNodes()), equalTo(singletonList(node)));
assertThat(mapped.LastRelationship(), nullValue());
assertThat(Iterators.asList(mapped.GetEnumerator()), equalTo(singletonList(node)));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldHandleSingleRelationshipPath()
public virtual void ShouldHandleSingleRelationshipPath()
{
// Given
Node start, end;
Relationship relationship;
using (Transaction tx = Db.beginTx())
{
start = Db.createNode();
end = Db.createNode();
relationship = start.CreateRelationshipTo(end, RelationshipType.withName("R"));
tx.Success();
}
// When
Path mapped = _mapper.mapPath(path(AsNodeValues(start, end), AsRelationshipsValues(relationship)));
// Then
using (Transaction ignore = Db.beginTx())
{
assertThat(mapped.Length(), equalTo(1));
assertThat(mapped.StartNode(), equalTo(start));
assertThat(mapped.EndNode(), equalTo(end));
assertThat(Iterables.asList(mapped.Relationships()), equalTo(singletonList(relationship)));
assertThat(Iterables.asList(mapped.ReverseRelationships()), equalTo(singletonList(relationship)));
assertThat(Iterables.asList(mapped.Nodes()), equalTo(Arrays.asList(start, end)));
assertThat(Iterables.asList(mapped.ReverseNodes()), equalTo(Arrays.asList(end, start)));
assertThat(mapped.LastRelationship(), equalTo(relationship));
assertThat(Iterators.asList(mapped.GetEnumerator()), equalTo(Arrays.asList(start, relationship, end)));
}
}
protected internal override bool IncludePath(Path path, TraversalBranch startBranch, TraversalBranch endBranch)
{
if (!base.IncludePath(path, startBranch, endBranch))
{
return(false);
}
/*
* In most cases we could prune startBranch and endBranch here.
*
* Problem when assuming startBranch and endBranch are pruned:
*
* Path (s) -...- (c) weight x
* path (s) -...- (a) weight x
* path (d) -...- (t) weight y
* path (b) -...- (t) weight y
* rel (c) - (b) weight z
* rel (a) - (b) weight z
* rel (a) - (d) weight z
*
* - (c) ---- ---- (d) -
* ... X ...
* / (prune)> / \ <(prune) \
* (s) -^v^v- (a) -- (b) -^v^v- (t)
*
* -^v^v- and ... meaning "some path"
*
* We expect following collisions:
* 1. start (c) - (b) end. Result in path of weight x+z+y
* 2. start (a) - (d) end. Result in path of weight x+z+y
* 3. start (a) - (b) end. Result in path of weight x+z+y
* However, if branches are pruned on collision 1 and 2. Collision 3 will never happen and thus
* a path is missed.
*/
double cost = (new WeightedPathImpl(_costEvaluator, path)).weight();
if (cost < _shortestSoFar.doubleValue())
{
_shortestSoFar.Value = cost;
}
return(NoneStrictMath.compare(cost, _shortestSoFar.doubleValue(), _epsilon) <= 0);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldHandleLongPath()
public virtual void ShouldHandleLongPath()
{
// Given
Node a, b, c, d, e;
Relationship r1, r2, r3, r4;
using (Transaction tx = Db.beginTx())
{
a = Db.createNode();
b = Db.createNode();
c = Db.createNode();
d = Db.createNode();
e = Db.createNode();
r1 = a.CreateRelationshipTo(b, RelationshipType.withName("R"));
r2 = b.CreateRelationshipTo(c, RelationshipType.withName("R"));
r3 = c.CreateRelationshipTo(d, RelationshipType.withName("R"));
r4 = d.CreateRelationshipTo(e, RelationshipType.withName("R"));
tx.Success();
}
// When
Path mapped = _mapper.mapPath(path(AsNodeValues(a, b, c, d, e), AsRelationshipsValues(r1, r2, r3, r4)));
// Then
using (Transaction ignore = Db.beginTx())
{
assertThat(mapped.Length(), equalTo(4));
assertThat(mapped.StartNode(), equalTo(a));
assertThat(mapped.EndNode(), equalTo(e));
assertThat(Iterables.asList(mapped.Relationships()), equalTo(Arrays.asList(r1, r2, r3, r4)));
assertThat(Iterables.asList(mapped.ReverseRelationships()), equalTo(Arrays.asList(r4, r3, r2, r1)));
assertThat(Iterables.asList(mapped.Nodes()), equalTo(Arrays.asList(a, b, c, d, e)));
assertThat(Iterables.asList(mapped.ReverseNodes()), equalTo(Arrays.asList(e, d, c, b, a)));
assertThat(mapped.LastRelationship(), equalTo(r4));
assertThat(Iterators.asList(mapped.GetEnumerator()), equalTo(Arrays.asList(a, r1, b, r2, c, r3, d, r4, e)));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @UserFunction public String works12(@Name("test") org.neo4j.graphdb.Path supported)
public virtual string Works12(Path supported)
{
return("42");
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Procedure public void works12(@Name("test") org.neo4j.graphdb.Path supported)
public virtual void Works12(Path supported)
{
}
public abstract bool CheckFull(Org.Neo4j.Graphdb.Path path);
internal PathWrappingPathValue(Path path)
{
this._path = path;
}
internal abstract bool containsDuplicates(Org.Neo4j.Graphdb.Path path);
internal abstract bool idEquals(Org.Neo4j.Graphdb.Path path, long idToCompare);
internal abstract long getId(Org.Neo4j.Graphdb.Path path);
public FullPath(Path path)
{
this._path = path;
}
