blob: 6df92bac73a410a0ed20c1887cd07d844ff90e49 [file] [log] [blame]
#region License
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
#endregion
using System;
using System.Collections.Generic;
using System.Linq;
using Gremlin.Net.Structure;
using Xunit;
namespace Gremlin.Net.UnitTest.Structure
{
public class PathTests
{
[Fact]
public void ShouldAssignPropertiesCorrectly()
{
var labels = new List<ISet<string>>
{
new HashSet<string> {"a", "b"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
};
var objects = new List<object> {1, new Vertex(1), "hello"};
var path = new Path(labels, objects);
Assert.Equal(labels, path.Labels);
Assert.Equal(objects, path.Objects);
}
[Fact]
public void ShouldReturnTrueForContainsKeyWhenGivenKeyExists()
{
var labels = new List<ISet<string>>
{
new HashSet<string> {"a", "b"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
};
var path = new Path(labels, new List<object>());
var containsKey = path.ContainsKey("c");
Assert.True(containsKey);
}
[Fact]
public void ShouldReturnFalseForContainsKeyWhenGivenKeyDoesNotExist()
{
var labels = new List<ISet<string>>
{
new HashSet<string> {"a", "b"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
};
var path = new Path(labels, new List<object>());
var containsKey = path.ContainsKey("z");
Assert.False(containsKey);
}
[Fact]
public void ShouldReturnCountOfObjectsForCountProperty()
{
var objects = new List<object> {1, new Vertex(1), "hello"};
var path = new Path(new List<ISet<string>>(), objects);
var count = path.Count;
Assert.Equal(3, count);
}
[Fact]
public void ShouldEnumeratorObjectsIntoListWhenToListIsCalled()
{
var objects = new List<object> {1, new Vertex(1), "hello"};
var path = new Path(new List<ISet<string>>(), objects);
var enumeratedObj = path.ToList();
Assert.Equal(objects, enumeratedObj);
}
[Fact]
public void ShouldReturnTrueForEqualsOfTwoEqualPaths()
{
var firstPath =
new Path(
new List<ISet<string>>
{
new HashSet<string> {"a", "b"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
}, new List<object> {1, new Vertex(1), "hello"});
var secondPath =
new Path(
new List<ISet<string>>
{
new HashSet<string> {"a", "b"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
}, new List<object> {1, new Vertex(1), "hello"});
var equals = firstPath.Equals(secondPath);
Assert.True(equals);
}
[Fact]
public void ShouldReturnFalseForEqualsOfPathsWithDifferentLabels()
{
var firstPath =
new Path(
new List<ISet<string>>
{
new HashSet<string> {"a", "b"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
}, new List<object> {1, new Vertex(1), "hello"});
var secondPath =
new Path(
new List<ISet<string>>
{
new HashSet<string> {"a"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
}, new List<object> {1, new Vertex(1), "hello"});
var equals = firstPath.Equals(secondPath);
Assert.False(equals);
}
[Fact]
public void ShouldReturnFalseForEqualsOfPathsWithDifferentObjects()
{
var firstPath =
new Path(
new List<ISet<string>>
{
new HashSet<string> {"a", "b"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
}, new List<object> {1, new Vertex(1), "hello"});
var secondPath =
new Path(
new List<ISet<string>>
{
new HashSet<string> {"a", "b"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
}, new List<object> {3, new Vertex(1), "hello"});
var equals = firstPath.Equals(secondPath);
Assert.False(equals);
}
[Fact]
public void ShouldReturnTrueForEqualsObjectOfTwoEqualPaths()
{
var firstPath =
new Path(
new List<ISet<string>>
{
new HashSet<string> {"a", "b"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
}, new List<object> { 1, new Vertex(1), "hello" });
object secondPath =
new Path(
new List<ISet<string>>
{
new HashSet<string> {"a", "b"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
}, new List<object> { 1, new Vertex(1), "hello" });
var equals = firstPath.Equals(secondPath);
Assert.True(equals);
}
[Fact]
public void ShouldReturnFalseForEqualsObjectOfPathsWithDifferentLabels()
{
var firstPath =
new Path(
new List<ISet<string>>
{
new HashSet<string> {"a", "b"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
}, new List<object> { 1, new Vertex(1), "hello" });
object secondPath =
new Path(
new List<ISet<string>>
{
new HashSet<string> {"a"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
}, new List<object> { 1, new Vertex(1), "hello" });
var equals = firstPath.Equals(secondPath);
Assert.False(equals);
}
[Fact]
public void ShouldReturnFalseForEqualsObjectOfPathsWithDifferentObjects()
{
var firstPath =
new Path(
new List<ISet<string>>
{
new HashSet<string> {"a", "b"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
}, new List<object> { 1, new Vertex(1), "hello" });
object secondPath =
new Path(
new List<ISet<string>>
{
new HashSet<string> {"a", "b"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
}, new List<object> { 3, new Vertex(1), "hello" });
var equals = firstPath.Equals(secondPath);
Assert.False(equals);
}
[Fact]
public void ShouldReturnFalseForEqualsWhereOtherIsNull()
{
var path = new Path(new List<ISet<string>> {new HashSet<string> {"a", "b"},}, new List<object> {1});
var equals = path.Equals(null);
Assert.False(equals);
}
[Fact]
public void ShouldReturnEqualHashcodesForEqualPaths()
{
var firstPath =
new Path(
new List<ISet<string>>
{
new HashSet<string> {"a", "b"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
}, new List<object> { 1, new Vertex(1), "hello" });
var secondPath =
new Path(
new List<ISet<string>>
{
new HashSet<string> {"a", "b"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
}, new List<object> { 1, new Vertex(1), "hello" });
var firstHashCode = firstPath.GetHashCode();
var secondHashCode = secondPath.GetHashCode();
Assert.Equal(firstHashCode, secondHashCode);
}
[Fact]
public void ShouldThrowWhenInvalidIndexIsAccessed()
{
var objects = new List<object> {1, new Vertex(1), "hello"};
var path = new Path(new List<ISet<string>>(), objects);
Assert.Throws<ArgumentOutOfRangeException>(() => path[3]);
}
[Fact]
public void ShouldReturnObjectsByTheirIndex()
{
var objects = new List<object> {1, new Vertex(1), "hello"};
var path = new Path(new List<ISet<string>>(), objects);
Assert.Equal(1, path[0]);
Assert.Equal(new Vertex(1), path[1]);
Assert.Equal("hello", path[2]);
}
[Fact]
public void ShouldReturnAllObjectsWhenTheirKeyIsAccessed()
{
var labels = new List<ISet<string>>
{
new HashSet<string> {"a", "b"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
};
var objects = new List<object> {1, new Vertex(1), "hello"};
var path = new Path(labels, objects);
var bObjects = path["b"];
Assert.Equal(new List<object> {1, new Vertex(1)}, bObjects);
}
[Fact]
public void ShouldReturnObjectsByTheirKey()
{
var labels = new List<ISet<string>>
{
new HashSet<string> {"a"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
};
var objects = new List<object> {1, new Vertex(1), "hello"};
var path = new Path(labels, objects);
Assert.Equal(1, path["a"]);
Assert.Equal(new Vertex(1), path["c"]);
Assert.Equal(new Vertex(1), path["b"]);
}
[Fact]
public void ShouldThrowWhenUnknownKeyIsAccessed()
{
var path = new Path(new List<ISet<string>>(), new List<object>());
Assert.Throws<KeyNotFoundException>(() => path["unknownKey"]);
}
[Fact]
public void ShouldReturnCommonStringRepresentationForToString()
{
var labels = new List<ISet<string>>
{
new HashSet<string> {"a", "b"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
};
var objects = new List<object> {1, new Vertex(1), "hello"};
var path = new Path(labels, objects);
var pathStr = path.ToString();
Assert.Equal("path[1, v[1], hello]", pathStr);
}
[Fact]
public void ShouldReturnTrueAndObjectsForTryGetWhenKeyWithMultipleObjectsIsProvided()
{
var labels = new List<ISet<string>>
{
new HashSet<string> {"a", "b"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
};
var objects = new List<object> {1, new Vertex(1), "hello"};
var path = new Path(labels, objects);
var success = path.TryGetValue("b", out object actualObj);
Assert.True(success);
Assert.Equal(new List<object> {1, new Vertex(1)}, actualObj);
}
[Fact]
public void ShouldReturnTrueAndCorrectObjectForTryGet()
{
var labels = new List<ISet<string>>
{
new HashSet<string> {"a"},
new HashSet<string> {"c", "b"},
new HashSet<string>()
};
var objects = new List<object> {1, new Vertex(1), "hello"};
var path = new Path(labels, objects);
var success = path.TryGetValue("b", out object actualObj);
Assert.True(success);
Assert.Equal(new Vertex(1), actualObj);
}
[Fact]
public void ShouldReturnFalseForTryGetWhenUnknownKeyIsProvided()
{
var path = new Path(new List<ISet<string>>(), new List<object>());
var success = path.TryGetValue("unknownKey", out object _);
Assert.False(success);
}
}
}