From 10cc831ed20d0a0cfa517fe72b5c34b0dc156226 Mon Sep 17 00:00:00 2001
From: Matej Ferencevic <matej.ferencevic@memgraph.io>
Date: Tue, 3 Dec 2019 20:26:32 +0100
Subject: [PATCH] Implement all edge filters for storage v2
Summary:
Edge filters (edge type and destination vertex) are now handled natively in the
storage API. The API is implemented to be the fastest possible when using the
filters with the assumption that the number of edge types will be small.
Reviewers: teon.banek
Reviewed By: teon.banek
Subscribers: pullbot
Differential Revision: https://phabricator.memgraph.io/D2576
---
src/query/db_accessor.hpp | 42 +-
src/storage/v2/durability.cpp | 4 +-
src/storage/v2/vertex_accessor.cpp | 86 +-
src/storage/v2/vertex_accessor.hpp | 7 +-
tests/unit/query_dump.cpp | 2 +-
tests/unit/storage_v2.cpp | 16 +-
tests/unit/storage_v2_durability.cpp | 24 +-
tests/unit/storage_v2_edge.cpp | 1808 ++++++++++++++++----------
tests/unit/storage_v2_gc.cpp | 4 +-
9 files changed, 1261 insertions(+), 732 deletions(-)
diff --git a/src/query/db_accessor.hpp b/src/query/db_accessor.hpp
index f05f703ee..72e8c886f 100644
--- a/src/query/db_accessor.hpp
+++ b/src/query/db_accessor.hpp
@@ -123,9 +123,9 @@ class VertexAccessor final {
auto InEdges(storage::View view,
const std::vector<storage::EdgeType> &edge_types) const
- -> storage::Result<decltype(
- iter::imap(MakeEdgeAccessor, *impl_.InEdges(edge_types, view)))> {
- auto maybe_edges = impl_.InEdges(edge_types, view);
+ -> storage::Result<decltype(iter::imap(MakeEdgeAccessor,
+ *impl_.InEdges(view)))> {
+ auto maybe_edges = impl_.InEdges(view, edge_types);
if (maybe_edges.HasError()) return maybe_edges.GetError();
return iter::imap(MakeEdgeAccessor, std::move(*maybe_edges));
}
@@ -135,25 +135,18 @@ class VertexAccessor final {
auto InEdges(storage::View view,
const std::vector<storage::EdgeType> &edge_types,
const VertexAccessor &dest) const
- -> storage::Result<decltype(
- iter::imap(MakeEdgeAccessor, *impl_.InEdges(edge_types, view)))> {
- auto maybe_edges = impl_.InEdges(edge_types, view);
+ -> storage::Result<decltype(iter::imap(MakeEdgeAccessor,
+ *impl_.InEdges(view)))> {
+ auto maybe_edges = impl_.InEdges(view, edge_types, &dest.impl_);
if (maybe_edges.HasError()) return maybe_edges.GetError();
- std::vector<storage::EdgeAccessor> reduced_edges;
- reduced_edges.reserve(maybe_edges->size());
- for (auto &edge : *maybe_edges) {
- if (edge.FromVertex() == dest.impl_) {
- reduced_edges.push_back(edge);
- }
- }
- return iter::imap(MakeEdgeAccessor, std::move(reduced_edges));
+ return iter::imap(MakeEdgeAccessor, std::move(*maybe_edges));
}
auto OutEdges(storage::View view,
const std::vector<storage::EdgeType> &edge_types) const
- -> storage::Result<decltype(
- iter::imap(MakeEdgeAccessor, *impl_.OutEdges(edge_types, view)))> {
- auto maybe_edges = impl_.OutEdges(edge_types, view);
+ -> storage::Result<decltype(iter::imap(MakeEdgeAccessor,
+ *impl_.OutEdges(view)))> {
+ auto maybe_edges = impl_.OutEdges(view, edge_types);
if (maybe_edges.HasError()) return maybe_edges.GetError();
return iter::imap(MakeEdgeAccessor, std::move(*maybe_edges));
}
@@ -163,18 +156,11 @@ class VertexAccessor final {
auto OutEdges(storage::View view,
const std::vector<storage::EdgeType> &edge_types,
const VertexAccessor &dest) const
- -> storage::Result<decltype(
- iter::imap(MakeEdgeAccessor, *impl_.OutEdges(edge_types, view)))> {
- auto maybe_edges = impl_.OutEdges(edge_types, view);
+ -> storage::Result<decltype(iter::imap(MakeEdgeAccessor,
+ *impl_.OutEdges(view)))> {
+ auto maybe_edges = impl_.OutEdges(view, edge_types, &dest.impl_);
if (maybe_edges.HasError()) return maybe_edges.GetError();
- std::vector<storage::EdgeAccessor> reduced_edges;
- reduced_edges.reserve(maybe_edges->size());
- for (auto &edge : *maybe_edges) {
- if (edge.ToVertex() == dest.impl_) {
- reduced_edges.push_back(edge);
- }
- }
- return iter::imap(MakeEdgeAccessor, std::move(reduced_edges));
+ return iter::imap(MakeEdgeAccessor, std::move(*maybe_edges));
}
storage::Result<size_t> InDegree(storage::View view) const {
diff --git a/src/storage/v2/durability.cpp b/src/storage/v2/durability.cpp
index 119431a69..adfe8955a 100644
--- a/src/storage/v2/durability.cpp
+++ b/src/storage/v2/durability.cpp
@@ -1660,9 +1660,9 @@ void Durability::CreateSnapshot(Transaction *transaction) {
CHECK(maybe_labels.HasValue()) << "Invalid database state!";
auto maybe_props = va->Properties(View::OLD);
CHECK(maybe_props.HasValue()) << "Invalid database state!";
- auto maybe_in_edges = va->InEdges({}, View::OLD);
+ auto maybe_in_edges = va->InEdges(View::OLD);
CHECK(maybe_in_edges.HasValue()) << "Invalid database state!";
- auto maybe_out_edges = va->OutEdges({}, View::OLD);
+ auto maybe_out_edges = va->OutEdges(View::OLD);
CHECK(maybe_out_edges.HasValue()) << "Invalid database state!";
// Store the vertex.
diff --git a/src/storage/v2/vertex_accessor.cpp b/src/storage/v2/vertex_accessor.cpp
index 29c5d17ab..2a0e2dd52 100644
--- a/src/storage/v2/vertex_accessor.cpp
+++ b/src/storage/v2/vertex_accessor.cpp
@@ -348,7 +348,10 @@ Result<std::map<PropertyId, PropertyValue>> VertexAccessor::Properties(
}
Result<std::vector<EdgeAccessor>> VertexAccessor::InEdges(
- const std::vector<EdgeTypeId> &edge_types, View view) const {
+ View view, const std::vector<EdgeTypeId> &edge_types,
+ const VertexAccessor *destination) const {
+ CHECK(!destination || destination->transaction_ == transaction_)
+ << "Invalid accessor!";
bool exists = true;
bool deleted = false;
std::vector<std::tuple<EdgeTypeId, Vertex *, EdgeRef>> in_edges;
@@ -356,14 +359,33 @@ Result<std::vector<EdgeAccessor>> VertexAccessor::InEdges(
{
std::lock_guard<utils::SpinLock> guard(vertex_->lock);
deleted = vertex_->deleted;
- in_edges = vertex_->in_edges;
+ if (edge_types.empty() && !destination) {
+ in_edges = vertex_->in_edges;
+ } else {
+ for (const auto &item : vertex_->in_edges) {
+ const auto &[edge_type, from_vertex, edge] = item;
+ if (destination && from_vertex != destination->vertex_) continue;
+ if (!edge_types.empty() &&
+ std::find(edge_types.begin(), edge_types.end(), edge_type) ==
+ edge_types.end())
+ continue;
+ in_edges.push_back(item);
+ }
+ }
delta = vertex_->delta;
}
ApplyDeltasForRead(
transaction_, delta, view,
- [&exists, &deleted, &in_edges](const Delta &delta) {
+ [&exists, &deleted, &in_edges, &edge_types,
+ &destination](const Delta &delta) {
switch (delta.action) {
case Delta::Action::ADD_IN_EDGE: {
+ if (destination && delta.vertex_edge.vertex != destination->vertex_)
+ break;
+ if (!edge_types.empty() &&
+ std::find(edge_types.begin(), edge_types.end(),
+ delta.vertex_edge.edge_type) == edge_types.end())
+ break;
// Add the edge because we don't see the removal.
std::tuple<EdgeTypeId, Vertex *, EdgeRef> link{
delta.vertex_edge.edge_type, delta.vertex_edge.vertex,
@@ -374,6 +396,12 @@ Result<std::vector<EdgeAccessor>> VertexAccessor::InEdges(
break;
}
case Delta::Action::REMOVE_IN_EDGE: {
+ if (destination && delta.vertex_edge.vertex != destination->vertex_)
+ break;
+ if (!edge_types.empty() &&
+ std::find(edge_types.begin(), edge_types.end(),
+ delta.vertex_edge.edge_type) == edge_types.end())
+ break;
// Remove the label because we don't see the addition.
std::tuple<EdgeTypeId, Vertex *, EdgeRef> link{
delta.vertex_edge.edge_type, delta.vertex_edge.vertex,
@@ -405,18 +433,18 @@ Result<std::vector<EdgeAccessor>> VertexAccessor::InEdges(
std::vector<EdgeAccessor> ret;
ret.reserve(in_edges.size());
for (const auto &item : in_edges) {
- auto [edge_type, from_vertex, edge] = item;
- if (edge_types.empty() || std::find(edge_types.begin(), edge_types.end(),
- edge_type) != edge_types.end()) {
- ret.emplace_back(edge, edge_type, from_vertex, vertex_, transaction_,
- indices_, config_);
- }
+ const auto &[edge_type, from_vertex, edge] = item;
+ ret.emplace_back(edge, edge_type, from_vertex, vertex_, transaction_,
+ indices_, config_);
}
return std::move(ret);
}
Result<std::vector<EdgeAccessor>> VertexAccessor::OutEdges(
- const std::vector<EdgeTypeId> &edge_types, View view) const {
+ View view, const std::vector<EdgeTypeId> &edge_types,
+ const VertexAccessor *destination) const {
+ CHECK(!destination || destination->transaction_ == transaction_)
+ << "Invalid accessor!";
bool exists = true;
bool deleted = false;
std::vector<std::tuple<EdgeTypeId, Vertex *, EdgeRef>> out_edges;
@@ -424,14 +452,33 @@ Result<std::vector<EdgeAccessor>> VertexAccessor::OutEdges(
{
std::lock_guard<utils::SpinLock> guard(vertex_->lock);
deleted = vertex_->deleted;
- out_edges = vertex_->out_edges;
+ if (edge_types.empty() && !destination) {
+ out_edges = vertex_->out_edges;
+ } else {
+ for (const auto &item : vertex_->out_edges) {
+ const auto &[edge_type, to_vertex, edge] = item;
+ if (destination && to_vertex != destination->vertex_) continue;
+ if (!edge_types.empty() &&
+ std::find(edge_types.begin(), edge_types.end(), edge_type) ==
+ edge_types.end())
+ continue;
+ out_edges.push_back(item);
+ }
+ }
delta = vertex_->delta;
}
ApplyDeltasForRead(
transaction_, delta, view,
- [&exists, &deleted, &out_edges](const Delta &delta) {
+ [&exists, &deleted, &out_edges, &edge_types,
+ &destination](const Delta &delta) {
switch (delta.action) {
case Delta::Action::ADD_OUT_EDGE: {
+ if (destination && delta.vertex_edge.vertex != destination->vertex_)
+ break;
+ if (!edge_types.empty() &&
+ std::find(edge_types.begin(), edge_types.end(),
+ delta.vertex_edge.edge_type) == edge_types.end())
+ break;
// Add the edge because we don't see the removal.
std::tuple<EdgeTypeId, Vertex *, EdgeRef> link{
delta.vertex_edge.edge_type, delta.vertex_edge.vertex,
@@ -442,6 +489,12 @@ Result<std::vector<EdgeAccessor>> VertexAccessor::OutEdges(
break;
}
case Delta::Action::REMOVE_OUT_EDGE: {
+ if (destination && delta.vertex_edge.vertex != destination->vertex_)
+ break;
+ if (!edge_types.empty() &&
+ std::find(edge_types.begin(), edge_types.end(),
+ delta.vertex_edge.edge_type) == edge_types.end())
+ break;
// Remove the label because we don't see the addition.
std::tuple<EdgeTypeId, Vertex *, EdgeRef> link{
delta.vertex_edge.edge_type, delta.vertex_edge.vertex,
@@ -473,12 +526,9 @@ Result<std::vector<EdgeAccessor>> VertexAccessor::OutEdges(
std::vector<EdgeAccessor> ret;
ret.reserve(out_edges.size());
for (const auto &item : out_edges) {
- auto [edge_type, to_vertex, edge] = item;
- if (edge_types.empty() || std::find(edge_types.begin(), edge_types.end(),
- edge_type) != edge_types.end()) {
- ret.emplace_back(edge, edge_type, vertex_, to_vertex, transaction_,
- indices_, config_);
- }
+ const auto &[edge_type, to_vertex, edge] = item;
+ ret.emplace_back(edge, edge_type, vertex_, to_vertex, transaction_,
+ indices_, config_);
}
return std::move(ret);
}
diff --git a/src/storage/v2/vertex_accessor.hpp b/src/storage/v2/vertex_accessor.hpp
index 7cce4a411..fae7419ad 100644
--- a/src/storage/v2/vertex_accessor.hpp
+++ b/src/storage/v2/vertex_accessor.hpp
@@ -65,18 +65,19 @@ class VertexAccessor final {
/// @throw std::bad_alloc
Result<std::map<PropertyId, PropertyValue>> Properties(View view) const;
- // TODO: Add API for obtaining edges filtered by destination VertexAccessor
/// @throw std::bad_alloc
/// @throw std::length_error if the resulting vector exceeds
/// std::vector::max_size().
Result<std::vector<EdgeAccessor>> InEdges(
- const std::vector<EdgeTypeId> &edge_types, View view) const;
+ View view, const std::vector<EdgeTypeId> &edge_types = {},
+ const VertexAccessor *destination = nullptr) const;
/// @throw std::bad_alloc
/// @throw std::length_error if the resulting vector exceeds
/// std::vector::max_size().
Result<std::vector<EdgeAccessor>> OutEdges(
- const std::vector<EdgeTypeId> &edge_types, View view) const;
+ View view, const std::vector<EdgeTypeId> &edge_types = {},
+ const VertexAccessor *destination = nullptr) const;
Result<size_t> InDegree(View view) const;
diff --git a/tests/unit/query_dump.cpp b/tests/unit/query_dump.cpp
index 45650a936..4f60a5e32 100644
--- a/tests/unit/query_dump.cpp
+++ b/tests/unit/query_dump.cpp
@@ -135,7 +135,7 @@ DatabaseState GetState(storage::Storage *db) {
// Capture all edges
std::set<DatabaseState::Edge> edges;
for (const auto &vertex : dba.Vertices(storage::View::NEW)) {
- auto maybe_edges = vertex.OutEdges({}, storage::View::NEW);
+ auto maybe_edges = vertex.OutEdges(storage::View::NEW);
CHECK(maybe_edges.HasValue());
for (const auto &edge : *maybe_edges) {
const auto &edge_type_name = dba.EdgeTypeToName(edge.EdgeType());
diff --git a/tests/unit/storage_v2.cpp b/tests/unit/storage_v2.cpp
index 9b313da21..6f7635507 100644
--- a/tests/unit/storage_v2.cpp
+++ b/tests/unit/storage_v2.cpp
@@ -2275,9 +2275,9 @@ TEST(StorageV2, VertexNonexistentLabelPropertyEdgeAPI) {
storage::Error::NONEXISTENT_OBJECT);
ASSERT_EQ(vertex.GetProperty(property, storage::View::OLD).GetError(),
storage::Error::NONEXISTENT_OBJECT);
- ASSERT_EQ(vertex.InEdges({}, storage::View::OLD).GetError(),
+ ASSERT_EQ(vertex.InEdges(storage::View::OLD).GetError(),
storage::Error::NONEXISTENT_OBJECT);
- ASSERT_EQ(vertex.OutEdges({}, storage::View::OLD).GetError(),
+ ASSERT_EQ(vertex.OutEdges(storage::View::OLD).GetError(),
storage::Error::NONEXISTENT_OBJECT);
ASSERT_EQ(vertex.InDegree(storage::View::OLD).GetError(),
storage::Error::NONEXISTENT_OBJECT);
@@ -2290,8 +2290,8 @@ TEST(StorageV2, VertexNonexistentLabelPropertyEdgeAPI) {
ASSERT_EQ(vertex.Properties(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex.GetProperty(property, storage::View::NEW),
storage::PropertyValue());
- ASSERT_EQ(vertex.InEdges({}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex.OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex.InEdges(storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex.OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex.InDegree(storage::View::NEW), 0);
ASSERT_EQ(*vertex.OutDegree(storage::View::NEW), 0);
@@ -2311,9 +2311,9 @@ TEST(StorageV2, VertexNonexistentLabelPropertyEdgeAPI) {
storage::Error::NONEXISTENT_OBJECT);
ASSERT_EQ(vertex.GetProperty(property, storage::View::OLD).GetError(),
storage::Error::NONEXISTENT_OBJECT);
- ASSERT_EQ(vertex.InEdges({}, storage::View::OLD).GetError(),
+ ASSERT_EQ(vertex.InEdges(storage::View::OLD).GetError(),
storage::Error::NONEXISTENT_OBJECT);
- ASSERT_EQ(vertex.OutEdges({}, storage::View::OLD).GetError(),
+ ASSERT_EQ(vertex.OutEdges(storage::View::OLD).GetError(),
storage::Error::NONEXISTENT_OBJECT);
ASSERT_EQ(vertex.InDegree(storage::View::OLD).GetError(),
storage::Error::NONEXISTENT_OBJECT);
@@ -2326,8 +2326,8 @@ TEST(StorageV2, VertexNonexistentLabelPropertyEdgeAPI) {
ASSERT_EQ(vertex.Properties(storage::View::NEW)->size(), 1);
ASSERT_EQ(*vertex.GetProperty(property, storage::View::NEW),
storage::PropertyValue("value"));
- ASSERT_EQ(vertex.InEdges({}, storage::View::NEW)->size(), 1);
- ASSERT_EQ(vertex.OutEdges({}, storage::View::NEW)->size(), 1);
+ ASSERT_EQ(vertex.InEdges(storage::View::NEW)->size(), 1);
+ ASSERT_EQ(vertex.OutEdges(storage::View::NEW)->size(), 1);
ASSERT_EQ(*vertex.InDegree(storage::View::NEW), 1);
ASSERT_EQ(*vertex.OutDegree(storage::View::NEW), 1);
diff --git a/tests/unit/storage_v2_durability.cpp b/tests/unit/storage_v2_durability.cpp
index 49342859f..5f1f7d546 100644
--- a/tests/unit/storage_v2_durability.cpp
+++ b/tests/unit/storage_v2_durability.cpp
@@ -326,7 +326,7 @@ class DurabilityTest : public ::testing::TestWithParam<bool> {
acc.FindVertex(base_vertex_gids_[(i / 2) % kNumBaseVertices],
storage::View::OLD);
ASSERT_TRUE(vertex1);
- auto out_edges = vertex1->OutEdges({}, storage::View::OLD);
+ auto out_edges = vertex1->OutEdges(storage::View::OLD);
ASSERT_TRUE(out_edges.HasValue());
auto edge1 = find_edge(*out_edges);
ASSERT_TRUE(edge1);
@@ -351,7 +351,7 @@ class DurabilityTest : public ::testing::TestWithParam<bool> {
acc.FindVertex(base_vertex_gids_[(i / 3) % kNumBaseVertices],
storage::View::OLD);
ASSERT_TRUE(vertex2);
- auto in_edges = vertex2->InEdges({}, storage::View::OLD);
+ auto in_edges = vertex2->InEdges(storage::View::OLD);
ASSERT_TRUE(in_edges.HasValue());
auto edge2 = find_edge(*in_edges);
ASSERT_TRUE(edge2);
@@ -479,7 +479,7 @@ class DurabilityTest : public ::testing::TestWithParam<bool> {
extended_vertex_gids_[(i / 5) % kNumExtendedVertices],
storage::View::OLD);
ASSERT_TRUE(vertex1);
- auto out_edges = vertex1->OutEdges({}, storage::View::OLD);
+ auto out_edges = vertex1->OutEdges(storage::View::OLD);
ASSERT_TRUE(out_edges.HasValue());
auto edge1 = find_edge(*out_edges);
ASSERT_TRUE(edge1);
@@ -498,7 +498,7 @@ class DurabilityTest : public ::testing::TestWithParam<bool> {
extended_vertex_gids_[(i / 6) % kNumExtendedVertices],
storage::View::OLD);
ASSERT_TRUE(vertex2);
- auto in_edges = vertex2->InEdges({}, storage::View::OLD);
+ auto in_edges = vertex2->InEdges(storage::View::OLD);
ASSERT_TRUE(in_edges.HasValue());
auto edge2 = find_edge(*in_edges);
ASSERT_TRUE(edge2);
@@ -1141,7 +1141,7 @@ TEST_F(DurabilityTest,
{
auto acc = store.Access();
for (auto vertex : acc.Vertices(storage::View::OLD)) {
- auto in_edges = vertex.InEdges({}, storage::View::OLD);
+ auto in_edges = vertex.InEdges(storage::View::OLD);
ASSERT_TRUE(in_edges.HasValue());
for (auto edge : *in_edges) {
// TODO (mferencevic): Replace with `ClearProperties()`
@@ -1152,7 +1152,7 @@ TEST_F(DurabilityTest,
.HasValue());
}
}
- auto out_edges = vertex.InEdges({}, storage::View::OLD);
+ auto out_edges = vertex.InEdges(storage::View::OLD);
ASSERT_TRUE(out_edges.HasValue());
for (auto edge : *out_edges) {
// TODO (mferencevic): Replace with `ClearProperties()`
@@ -1397,10 +1397,10 @@ TEST_P(DurabilityTest, WalCreateInSingleTransaction) {
auto props = v1->Properties(storage::View::OLD);
ASSERT_TRUE(props.HasValue());
ASSERT_EQ(props->size(), 0);
- auto in_edges = v1->InEdges({}, storage::View::OLD);
+ auto in_edges = v1->InEdges(storage::View::OLD);
ASSERT_TRUE(in_edges.HasValue());
ASSERT_EQ(in_edges->size(), 0);
- auto out_edges = v1->OutEdges({}, storage::View::OLD);
+ auto out_edges = v1->OutEdges(storage::View::OLD);
ASSERT_TRUE(out_edges.HasValue());
ASSERT_EQ(out_edges->size(), 1);
const auto &edge = (*out_edges)[0];
@@ -1426,7 +1426,7 @@ TEST_P(DurabilityTest, WalCreateInSingleTransaction) {
ASSERT_THAT(*props, UnorderedElementsAre(
std::make_pair(store.NameToProperty("hello"),
storage::PropertyValue("world"))));
- auto in_edges = v2->InEdges({}, storage::View::OLD);
+ auto in_edges = v2->InEdges(storage::View::OLD);
ASSERT_TRUE(in_edges.HasValue());
ASSERT_EQ(in_edges->size(), 1);
const auto &edge = (*in_edges)[0];
@@ -1440,7 +1440,7 @@ TEST_P(DurabilityTest, WalCreateInSingleTransaction) {
} else {
ASSERT_EQ(edge_props->size(), 0);
}
- auto out_edges = v2->OutEdges({}, storage::View::OLD);
+ auto out_edges = v2->OutEdges(storage::View::OLD);
ASSERT_TRUE(out_edges.HasValue());
ASSERT_EQ(out_edges->size(), 0);
}
@@ -1455,10 +1455,10 @@ TEST_P(DurabilityTest, WalCreateInSingleTransaction) {
ASSERT_THAT(*props,
UnorderedElementsAre(std::make_pair(
store.NameToProperty("v3"), storage::PropertyValue(42))));
- auto in_edges = v3->InEdges({}, storage::View::OLD);
+ auto in_edges = v3->InEdges(storage::View::OLD);
ASSERT_TRUE(in_edges.HasValue());
ASSERT_EQ(in_edges->size(), 0);
- auto out_edges = v3->OutEdges({}, storage::View::OLD);
+ auto out_edges = v3->OutEdges(storage::View::OLD);
ASSERT_TRUE(out_edges.HasValue());
ASSERT_EQ(out_edges->size(), 0);
}
diff --git a/tests/unit/storage_v2_edge.cpp b/tests/unit/storage_v2_edge.cpp
index a308d498b..c7f9255ea 100644
--- a/tests/unit/storage_v2_edge.cpp
+++ b/tests/unit/storage_v2_edge.cpp
@@ -50,14 +50,14 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerCommit) {
ASSERT_EQ(edge.ToVertex(), *vertex_to);
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::OLD), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -67,10 +67,10 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerCommit) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::OLD), 0);
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -80,20 +80,51 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerCommit) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et}, &*vertex_to)
+ ->size(),
+ 0);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {et, other_et}, &*vertex_to)
+ ->size(),
+ 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {et, other_et}, &*vertex_from)
+ ->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et}, &*vertex_from)
+ ->size(),
+ 0);
+ ASSERT_EQ(
+ vertex_to->InEdges(storage::View::NEW, {et, other_et}, &*vertex_from)
+ ->size(),
+ 1);
+ ASSERT_EQ(
+ vertex_to->InEdges(storage::View::NEW, {et, other_et}, &*vertex_to)
+ ->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -109,12 +140,12 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerCommit) {
auto et = acc.NameToEdgeType("et5");
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -125,7 +156,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerCommit) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -136,7 +167,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerCommit) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -147,7 +178,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerCommit) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -157,26 +188,88 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerCommit) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {other_et}, &*vertex_to)
+ ->size(),
+ 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et}, &*vertex_to)
+ ->size(),
+ 0);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {et, other_et}, &*vertex_to)
+ ->size(),
+ 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {et, other_et}, &*vertex_to)
+ ->size(),
+ 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {et, other_et}, &*vertex_from)
+ ->size(),
+ 0);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {et, other_et}, &*vertex_from)
+ ->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_to)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {other_et}, &*vertex_from)
+ ->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et}, &*vertex_from)
+ ->size(),
+ 0);
+ ASSERT_EQ(
+ vertex_to->InEdges(storage::View::OLD, {et, other_et}, &*vertex_from)
+ ->size(),
+ 1);
+ ASSERT_EQ(
+ vertex_to->InEdges(storage::View::NEW, {et, other_et}, &*vertex_from)
+ ->size(),
+ 1);
+ ASSERT_EQ(
+ vertex_to->InEdges(storage::View::OLD, {et, other_et}, &*vertex_to)
+ ->size(),
+ 0);
+ ASSERT_EQ(
+ vertex_to->InEdges(storage::View::NEW, {et, other_et}, &*vertex_to)
+ ->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -218,14 +311,14 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerCommit) {
ASSERT_EQ(edge.ToVertex(), *vertex_to);
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::OLD), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -235,10 +328,10 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerCommit) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::OLD), 0);
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -248,20 +341,29 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerCommit) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -277,12 +379,12 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerCommit) {
auto et = acc.NameToEdgeType("et5");
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -293,7 +395,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerCommit) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -304,7 +406,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerCommit) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -315,7 +417,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerCommit) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -325,26 +427,44 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerCommit) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_to)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -380,10 +500,10 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameCommit) {
ASSERT_EQ(edge.ToVertex(), *vertex);
// Check edges without filters
- ASSERT_EQ(vertex->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex->InDegree(storage::View::OLD), 0);
{
- auto ret = vertex->InEdges({}, storage::View::NEW);
+ auto ret = vertex->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -393,10 +513,10 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameCommit) {
ASSERT_EQ(e.FromVertex(), *vertex);
ASSERT_EQ(e.ToVertex(), *vertex);
}
- ASSERT_EQ(vertex->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex->OutDegree(storage::View::OLD), 0);
{
- auto ret = vertex->OutEdges({}, storage::View::NEW);
+ auto ret = vertex->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -410,10 +530,16 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameCommit) {
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->OutEdges({et, other_et}, storage::View::NEW)->size(), 1);
- ASSERT_EQ(vertex->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->InEdges({et, other_et}, storage::View::NEW)->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(
+ vertex->OutEdges(storage::View::NEW, {other_et}, &*vertex)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et}, &*vertex)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -428,7 +554,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameCommit) {
// Check edges without filters
{
- auto ret = vertex->InEdges({}, storage::View::OLD);
+ auto ret = vertex->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -439,7 +565,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameCommit) {
ASSERT_EQ(e.ToVertex(), *vertex);
}
{
- auto ret = vertex->InEdges({}, storage::View::NEW);
+ auto ret = vertex->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -450,7 +576,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameCommit) {
ASSERT_EQ(e.ToVertex(), *vertex);
}
{
- auto ret = vertex->OutEdges({}, storage::View::OLD);
+ auto ret = vertex->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -461,7 +587,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameCommit) {
ASSERT_EQ(e.ToVertex(), *vertex);
}
{
- auto ret = vertex->OutEdges({}, storage::View::NEW);
+ auto ret = vertex->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -475,14 +601,20 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameCommit) {
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->InEdges({et, other_et}, storage::View::OLD)->size(), 1);
- ASSERT_EQ(vertex->InEdges({et, other_et}, storage::View::NEW)->size(), 1);
- ASSERT_EQ(vertex->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->OutEdges({et, other_et}, storage::View::OLD)->size(), 1);
- ASSERT_EQ(vertex->OutEdges({et, other_et}, storage::View::NEW)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et}, &*vertex)->size(),
+ 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(
+ vertex->OutEdges(storage::View::NEW, {other_et}, &*vertex)->size(), 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -524,14 +656,14 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) {
ASSERT_EQ(edge.ToVertex(), *vertex_to);
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::OLD), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -541,10 +673,10 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::OLD), 0);
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -554,20 +686,29 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
acc.Abort();
}
@@ -581,21 +722,21 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) {
ASSERT_TRUE(vertex_to);
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
ASSERT_FALSE(acc.Commit().HasError());
@@ -619,14 +760,14 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) {
ASSERT_EQ(edge.ToVertex(), *vertex_to);
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::OLD), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -636,10 +777,10 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::OLD), 0);
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -649,20 +790,29 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -678,12 +828,12 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) {
auto et = acc.NameToEdgeType("et5");
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -694,7 +844,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -705,7 +855,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -716,7 +866,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -726,26 +876,44 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_to)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -787,14 +955,14 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) {
ASSERT_EQ(edge.ToVertex(), *vertex_to);
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::OLD), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -804,10 +972,10 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::OLD), 0);
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -817,20 +985,29 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
acc.Abort();
}
@@ -844,21 +1021,21 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) {
ASSERT_TRUE(vertex_to);
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
ASSERT_FALSE(acc.Commit().HasError());
@@ -882,14 +1059,14 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) {
ASSERT_EQ(edge.ToVertex(), *vertex_to);
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::OLD), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -899,10 +1076,10 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::OLD), 0);
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -912,20 +1089,29 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -941,12 +1127,12 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) {
auto et = acc.NameToEdgeType("et5");
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -957,7 +1143,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -968,7 +1154,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -979,7 +1165,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -989,26 +1175,44 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_to)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -1044,10 +1248,10 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) {
ASSERT_EQ(edge.ToVertex(), *vertex);
// Check edges without filters
- ASSERT_EQ(vertex->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex->InDegree(storage::View::OLD), 0);
{
- auto ret = vertex->InEdges({}, storage::View::NEW);
+ auto ret = vertex->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1057,10 +1261,10 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) {
ASSERT_EQ(e.FromVertex(), *vertex);
ASSERT_EQ(e.ToVertex(), *vertex);
}
- ASSERT_EQ(vertex->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex->OutDegree(storage::View::OLD), 0);
{
- auto ret = vertex->OutEdges({}, storage::View::NEW);
+ auto ret = vertex->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1074,10 +1278,16 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) {
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->OutEdges({et, other_et}, storage::View::NEW)->size(), 1);
- ASSERT_EQ(vertex->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->InEdges({et, other_et}, storage::View::NEW)->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(
+ vertex->OutEdges(storage::View::NEW, {other_et}, &*vertex)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et}, &*vertex)->size(),
+ 0);
acc.Abort();
}
@@ -1089,13 +1299,13 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) {
ASSERT_TRUE(vertex);
// Check edges without filters
- ASSERT_EQ(vertex->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex->OutDegree(storage::View::NEW), 0);
ASSERT_FALSE(acc.Commit().HasError());
@@ -1117,10 +1327,10 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) {
ASSERT_EQ(edge.ToVertex(), *vertex);
// Check edges without filters
- ASSERT_EQ(vertex->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex->InDegree(storage::View::OLD), 0);
{
- auto ret = vertex->InEdges({}, storage::View::NEW);
+ auto ret = vertex->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1130,10 +1340,10 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) {
ASSERT_EQ(e.FromVertex(), *vertex);
ASSERT_EQ(e.ToVertex(), *vertex);
}
- ASSERT_EQ(vertex->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex->OutDegree(storage::View::OLD), 0);
{
- auto ret = vertex->OutEdges({}, storage::View::NEW);
+ auto ret = vertex->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1147,10 +1357,16 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) {
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->OutEdges({et, other_et}, storage::View::NEW)->size(), 1);
- ASSERT_EQ(vertex->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->InEdges({et, other_et}, storage::View::NEW)->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(
+ vertex->OutEdges(storage::View::NEW, {other_et}, &*vertex)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et}, &*vertex)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -1165,7 +1381,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) {
// Check edges without filters
{
- auto ret = vertex->InEdges({}, storage::View::OLD);
+ auto ret = vertex->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1176,7 +1392,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) {
ASSERT_EQ(e.ToVertex(), *vertex);
}
{
- auto ret = vertex->InEdges({}, storage::View::NEW);
+ auto ret = vertex->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1187,7 +1403,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) {
ASSERT_EQ(e.ToVertex(), *vertex);
}
{
- auto ret = vertex->OutEdges({}, storage::View::OLD);
+ auto ret = vertex->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1198,7 +1414,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) {
ASSERT_EQ(e.ToVertex(), *vertex);
}
{
- auto ret = vertex->OutEdges({}, storage::View::NEW);
+ auto ret = vertex->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1212,14 +1428,26 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) {
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->InEdges({et, other_et}, storage::View::OLD)->size(), 1);
- ASSERT_EQ(vertex->InEdges({et, other_et}, storage::View::NEW)->size(), 1);
- ASSERT_EQ(vertex->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->OutEdges({et, other_et}, storage::View::OLD)->size(), 1);
- ASSERT_EQ(vertex->OutEdges({et, other_et}, storage::View::NEW)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {other_et}, &*vertex)->size(),
+ 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et}, &*vertex)->size(),
+ 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(
+ vertex->OutEdges(storage::View::OLD, {other_et}, &*vertex)->size(), 0);
+ ASSERT_EQ(
+ vertex->OutEdges(storage::View::NEW, {other_et}, &*vertex)->size(), 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -1261,14 +1489,14 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) {
ASSERT_EQ(edge.ToVertex(), *vertex_to);
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::OLD), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1278,10 +1506,10 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::OLD), 0);
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1291,20 +1519,29 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -1320,12 +1557,12 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) {
auto et = acc.NameToEdgeType("et5");
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1336,7 +1573,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1347,7 +1584,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1358,7 +1595,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1368,26 +1605,44 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_to)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -1402,19 +1657,19 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) {
auto et = acc.NameToEdgeType("et5");
- auto edge = vertex_from->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex_from->OutEdges(storage::View::NEW).GetValue()[0];
auto res = acc.DeleteEdge(&edge);
ASSERT_TRUE(res.HasValue());
ASSERT_TRUE(res.GetValue());
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1424,10 +1679,10 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::NEW), 0);
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1437,22 +1692,31 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -1466,21 +1730,21 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) {
ASSERT_TRUE(vertex_to);
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
ASSERT_FALSE(acc.Commit().HasError());
@@ -1523,14 +1787,14 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) {
ASSERT_EQ(edge.ToVertex(), *vertex_to);
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::OLD), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1540,10 +1804,10 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::OLD), 0);
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1553,20 +1817,29 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -1582,12 +1855,12 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) {
auto et = acc.NameToEdgeType("et5");
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1598,7 +1871,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1609,7 +1882,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1620,7 +1893,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1630,26 +1903,44 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_to)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -1664,19 +1955,19 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) {
auto et = acc.NameToEdgeType("et5");
- auto edge = vertex_from->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex_from->OutEdges(storage::View::NEW).GetValue()[0];
auto res = acc.DeleteEdge(&edge);
ASSERT_TRUE(res.HasValue());
ASSERT_TRUE(res.GetValue());
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1686,10 +1977,10 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::NEW), 0);
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1699,22 +1990,31 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -1728,21 +2028,21 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) {
ASSERT_TRUE(vertex_to);
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
ASSERT_FALSE(acc.Commit().HasError());
@@ -1779,10 +2079,10 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) {
ASSERT_EQ(edge.ToVertex(), *vertex);
// Check edges without filters
- ASSERT_EQ(vertex->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex->InDegree(storage::View::OLD), 0);
{
- auto ret = vertex->InEdges({}, storage::View::NEW);
+ auto ret = vertex->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1792,10 +2092,10 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) {
ASSERT_EQ(e.FromVertex(), *vertex);
ASSERT_EQ(e.ToVertex(), *vertex);
}
- ASSERT_EQ(vertex->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex->OutDegree(storage::View::OLD), 0);
{
- auto ret = vertex->OutEdges({}, storage::View::NEW);
+ auto ret = vertex->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1809,10 +2109,16 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) {
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->OutEdges({et, other_et}, storage::View::NEW)->size(), 1);
- ASSERT_EQ(vertex->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->InEdges({et, other_et}, storage::View::NEW)->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(
+ vertex->OutEdges(storage::View::NEW, {other_et}, &*vertex)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et}, &*vertex)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -1827,7 +2133,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) {
// Check edges without filters
{
- auto ret = vertex->InEdges({}, storage::View::OLD);
+ auto ret = vertex->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1838,7 +2144,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) {
ASSERT_EQ(e.ToVertex(), *vertex);
}
{
- auto ret = vertex->InEdges({}, storage::View::NEW);
+ auto ret = vertex->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1849,7 +2155,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) {
ASSERT_EQ(e.ToVertex(), *vertex);
}
{
- auto ret = vertex->OutEdges({}, storage::View::OLD);
+ auto ret = vertex->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1860,7 +2166,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) {
ASSERT_EQ(e.ToVertex(), *vertex);
}
{
- auto ret = vertex->OutEdges({}, storage::View::NEW);
+ auto ret = vertex->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1874,14 +2180,26 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) {
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->InEdges({et, other_et}, storage::View::OLD)->size(), 1);
- ASSERT_EQ(vertex->InEdges({et, other_et}, storage::View::NEW)->size(), 1);
- ASSERT_EQ(vertex->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->OutEdges({et, other_et}, storage::View::OLD)->size(), 1);
- ASSERT_EQ(vertex->OutEdges({et, other_et}, storage::View::NEW)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {other_et}, &*vertex)->size(),
+ 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et}, &*vertex)->size(),
+ 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(
+ vertex->OutEdges(storage::View::OLD, {other_et}, &*vertex)->size(), 0);
+ ASSERT_EQ(
+ vertex->OutEdges(storage::View::NEW, {other_et}, &*vertex)->size(), 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -1894,7 +2212,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) {
auto et = acc.NameToEdgeType("et5");
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto res = acc.DeleteEdge(&edge);
ASSERT_TRUE(res.HasValue());
@@ -1902,7 +2220,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) {
// Check edges without filters
{
- auto ret = vertex->InEdges({}, storage::View::OLD);
+ auto ret = vertex->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1912,10 +2230,10 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) {
ASSERT_EQ(e.FromVertex(), *vertex);
ASSERT_EQ(e.ToVertex(), *vertex);
}
- ASSERT_EQ(vertex->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex->OutEdges({}, storage::View::OLD);
+ auto ret = vertex->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -1925,16 +2243,22 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) {
ASSERT_EQ(e.FromVertex(), *vertex);
ASSERT_EQ(e.ToVertex(), *vertex);
}
- ASSERT_EQ(vertex->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex->InEdges({et, other_et}, storage::View::OLD)->size(), 1);
- ASSERT_EQ(vertex->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex->OutEdges({et, other_et}, storage::View::OLD)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {other_et}, &*vertex)->size(),
+ 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(
+ vertex->OutEdges(storage::View::OLD, {other_et}, &*vertex)->size(), 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -1946,13 +2270,13 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) {
ASSERT_TRUE(vertex);
// Check edges without filters
- ASSERT_EQ(vertex->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex->OutDegree(storage::View::NEW), 0);
ASSERT_FALSE(acc.Commit().HasError());
@@ -1995,14 +2319,14 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
ASSERT_EQ(edge.ToVertex(), *vertex_to);
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::OLD), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2012,10 +2336,10 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::OLD), 0);
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2025,20 +2349,29 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -2054,12 +2387,12 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
auto et = acc.NameToEdgeType("et5");
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2070,7 +2403,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2081,7 +2414,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2092,7 +2425,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2102,26 +2435,44 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_to)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -2136,19 +2487,19 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
auto et = acc.NameToEdgeType("et5");
- auto edge = vertex_from->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex_from->OutEdges(storage::View::NEW).GetValue()[0];
auto res = acc.DeleteEdge(&edge);
ASSERT_TRUE(res.HasValue());
ASSERT_TRUE(res.GetValue());
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2158,10 +2509,10 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::NEW), 0);
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2171,22 +2522,31 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_to)->size(),
+ 0);
acc.Abort();
}
@@ -2202,12 +2562,12 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
auto et = acc.NameToEdgeType("et5");
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2218,7 +2578,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2229,7 +2589,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2240,7 +2600,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2250,26 +2610,44 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_to)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -2284,19 +2662,19 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
auto et = acc.NameToEdgeType("et5");
- auto edge = vertex_from->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex_from->OutEdges(storage::View::NEW).GetValue()[0];
auto res = acc.DeleteEdge(&edge);
ASSERT_TRUE(res.HasValue());
ASSERT_TRUE(res.GetValue());
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2306,10 +2684,10 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::NEW), 0);
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2319,22 +2697,31 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -2348,21 +2735,21 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) {
ASSERT_TRUE(vertex_to);
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
ASSERT_FALSE(acc.Commit().HasError());
@@ -2405,14 +2792,14 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
ASSERT_EQ(edge.ToVertex(), *vertex_to);
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::OLD), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2422,10 +2809,10 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::OLD), 0);
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2435,20 +2822,29 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -2464,12 +2860,12 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
auto et = acc.NameToEdgeType("et5");
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2480,7 +2876,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2491,7 +2887,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2502,7 +2898,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2512,26 +2908,44 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_to)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -2546,19 +2960,19 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
auto et = acc.NameToEdgeType("et5");
- auto edge = vertex_from->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex_from->OutEdges(storage::View::NEW).GetValue()[0];
auto res = acc.DeleteEdge(&edge);
ASSERT_TRUE(res.HasValue());
ASSERT_TRUE(res.GetValue());
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2568,10 +2982,10 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::NEW), 0);
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2581,22 +2995,31 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_to)->size(),
+ 0);
acc.Abort();
}
@@ -2612,12 +3035,12 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
auto et = acc.NameToEdgeType("et5");
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2628,7 +3051,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2640,7 +3063,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2651,7 +3074,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2661,26 +3084,44 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::NEW)->size(),
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_to)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -2695,19 +3136,19 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
auto et = acc.NameToEdgeType("et5");
- auto edge = vertex_from->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex_from->OutEdges(storage::View::NEW).GetValue()[0];
auto res = acc.DeleteEdge(&edge);
ASSERT_TRUE(res.HasValue());
ASSERT_TRUE(res.GetValue());
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2717,10 +3158,10 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::NEW), 0);
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2730,22 +3171,31 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex_from->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_from->OutEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD, {et, other_et})->size(),
1);
- ASSERT_EQ(vertex_to->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex_to->InEdges({et, other_et}, storage::View::OLD)->size(),
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_to)->size(), 1);
+ ASSERT_EQ(
+ vertex_from->OutEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {et, other_et})->size(),
1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_from)->size(),
+ 1);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD, {}, &*vertex_to)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -2759,21 +3209,21 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) {
ASSERT_TRUE(vertex_to);
// Check edges without filters
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->OutDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
ASSERT_FALSE(acc.Commit().HasError());
@@ -2810,10 +3260,10 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
ASSERT_EQ(edge.ToVertex(), *vertex);
// Check edges without filters
- ASSERT_EQ(vertex->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex->InDegree(storage::View::OLD), 0);
{
- auto ret = vertex->InEdges({}, storage::View::NEW);
+ auto ret = vertex->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2823,10 +3273,10 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
ASSERT_EQ(e.FromVertex(), *vertex);
ASSERT_EQ(e.ToVertex(), *vertex);
}
- ASSERT_EQ(vertex->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex->OutDegree(storage::View::OLD), 0);
{
- auto ret = vertex->OutEdges({}, storage::View::NEW);
+ auto ret = vertex->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2840,10 +3290,16 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->OutEdges({et, other_et}, storage::View::NEW)->size(), 1);
- ASSERT_EQ(vertex->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->InEdges({et, other_et}, storage::View::NEW)->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(
+ vertex->OutEdges(storage::View::NEW, {other_et}, &*vertex)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et}, &*vertex)->size(),
+ 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -2858,7 +3314,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
// Check edges without filters
{
- auto ret = vertex->InEdges({}, storage::View::OLD);
+ auto ret = vertex->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2869,7 +3325,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
ASSERT_EQ(e.ToVertex(), *vertex);
}
{
- auto ret = vertex->InEdges({}, storage::View::NEW);
+ auto ret = vertex->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2880,7 +3336,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
ASSERT_EQ(e.ToVertex(), *vertex);
}
{
- auto ret = vertex->OutEdges({}, storage::View::OLD);
+ auto ret = vertex->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2891,7 +3347,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
ASSERT_EQ(e.ToVertex(), *vertex);
}
{
- auto ret = vertex->OutEdges({}, storage::View::NEW);
+ auto ret = vertex->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2905,14 +3361,26 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->InEdges({et, other_et}, storage::View::OLD)->size(), 1);
- ASSERT_EQ(vertex->InEdges({et, other_et}, storage::View::NEW)->size(), 1);
- ASSERT_EQ(vertex->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->OutEdges({et, other_et}, storage::View::OLD)->size(), 1);
- ASSERT_EQ(vertex->OutEdges({et, other_et}, storage::View::NEW)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {other_et}, &*vertex)->size(),
+ 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et}, &*vertex)->size(),
+ 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(
+ vertex->OutEdges(storage::View::OLD, {other_et}, &*vertex)->size(), 0);
+ ASSERT_EQ(
+ vertex->OutEdges(storage::View::NEW, {other_et}, &*vertex)->size(), 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -2925,7 +3393,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
auto et = acc.NameToEdgeType("et5");
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto res = acc.DeleteEdge(&edge);
ASSERT_TRUE(res.HasValue());
@@ -2933,7 +3401,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
// Check edges without filters
{
- auto ret = vertex->InEdges({}, storage::View::OLD);
+ auto ret = vertex->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2943,10 +3411,10 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
ASSERT_EQ(e.FromVertex(), *vertex);
ASSERT_EQ(e.ToVertex(), *vertex);
}
- ASSERT_EQ(vertex->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex->OutEdges({}, storage::View::OLD);
+ auto ret = vertex->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2956,16 +3424,22 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
ASSERT_EQ(e.FromVertex(), *vertex);
ASSERT_EQ(e.ToVertex(), *vertex);
}
- ASSERT_EQ(vertex->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex->InEdges({et, other_et}, storage::View::OLD)->size(), 1);
- ASSERT_EQ(vertex->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex->OutEdges({et, other_et}, storage::View::OLD)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {other_et}, &*vertex)->size(),
+ 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(
+ vertex->OutEdges(storage::View::OLD, {other_et}, &*vertex)->size(), 0);
acc.Abort();
}
@@ -2980,7 +3454,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
// Check edges without filters
{
- auto ret = vertex->InEdges({}, storage::View::OLD);
+ auto ret = vertex->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -2991,7 +3465,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
ASSERT_EQ(e.ToVertex(), *vertex);
}
{
- auto ret = vertex->InEdges({}, storage::View::NEW);
+ auto ret = vertex->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3002,7 +3476,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
ASSERT_EQ(e.ToVertex(), *vertex);
}
{
- auto ret = vertex->OutEdges({}, storage::View::OLD);
+ auto ret = vertex->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3013,7 +3487,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
ASSERT_EQ(e.ToVertex(), *vertex);
}
{
- auto ret = vertex->OutEdges({}, storage::View::NEW);
+ auto ret = vertex->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3027,14 +3501,26 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex->InEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->InEdges({et, other_et}, storage::View::OLD)->size(), 1);
- ASSERT_EQ(vertex->InEdges({et, other_et}, storage::View::NEW)->size(), 1);
- ASSERT_EQ(vertex->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex->OutEdges({other_et}, storage::View::NEW)->size(), 0);
- ASSERT_EQ(vertex->OutEdges({et, other_et}, storage::View::OLD)->size(), 1);
- ASSERT_EQ(vertex->OutEdges({et, other_et}, storage::View::NEW)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {other_et}, &*vertex)->size(),
+ 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW, {other_et}, &*vertex)->size(),
+ 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(
+ vertex->OutEdges(storage::View::OLD, {other_et}, &*vertex)->size(), 0);
+ ASSERT_EQ(
+ vertex->OutEdges(storage::View::NEW, {other_et}, &*vertex)->size(), 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -3047,7 +3533,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
auto et = acc.NameToEdgeType("et5");
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto res = acc.DeleteEdge(&edge);
ASSERT_TRUE(res.HasValue());
@@ -3055,7 +3541,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
// Check edges without filters
{
- auto ret = vertex->InEdges({}, storage::View::OLD);
+ auto ret = vertex->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3065,10 +3551,10 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
ASSERT_EQ(e.FromVertex(), *vertex);
ASSERT_EQ(e.ToVertex(), *vertex);
}
- ASSERT_EQ(vertex->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex->OutEdges({}, storage::View::OLD);
+ auto ret = vertex->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3078,16 +3564,22 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
ASSERT_EQ(e.FromVertex(), *vertex);
ASSERT_EQ(e.ToVertex(), *vertex);
}
- ASSERT_EQ(vertex->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex->OutDegree(storage::View::NEW), 0);
auto other_et = acc.NameToEdgeType("other");
// Check edges with filters
- ASSERT_EQ(vertex->InEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex->InEdges({et, other_et}, storage::View::OLD)->size(), 1);
- ASSERT_EQ(vertex->OutEdges({other_et}, storage::View::OLD)->size(), 0);
- ASSERT_EQ(vertex->OutEdges({et, other_et}, storage::View::OLD)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD, {other_et}, &*vertex)->size(),
+ 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {other_et})->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {et, other_et})->size(), 1);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD, {}, &*vertex)->size(), 1);
+ ASSERT_EQ(
+ vertex->OutEdges(storage::View::OLD, {other_et}, &*vertex)->size(), 0);
ASSERT_FALSE(acc.Commit().HasError());
}
@@ -3099,13 +3591,13 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) {
ASSERT_TRUE(vertex);
// Check edges without filters
- ASSERT_EQ(vertex->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex->OutDegree(storage::View::NEW), 0);
ASSERT_FALSE(acc.Commit().HasError());
@@ -3139,10 +3631,10 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleCommit) {
gid_to = vertex_to.Gid();
// Check edges
- ASSERT_EQ(vertex_from.InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from.InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from.InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from.OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from.OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3153,7 +3645,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleCommit) {
ASSERT_EQ(e.ToVertex(), vertex_to);
}
{
- auto ret = vertex_to.InEdges({}, storage::View::NEW);
+ auto ret = vertex_to.InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3163,7 +3655,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleCommit) {
ASSERT_EQ(e.FromVertex(), vertex_from);
ASSERT_EQ(e.ToVertex(), vertex_to);
}
- ASSERT_EQ(vertex_to.OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to.OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to.OutDegree(storage::View::NEW), 0);
ASSERT_FALSE(acc.Commit().HasError());
@@ -3194,14 +3686,14 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleCommit) {
}
// Check edges
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW).GetError(),
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
ASSERT_EQ(vertex_from->InDegree(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3211,12 +3703,12 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleCommit) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::NEW).GetError(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
ASSERT_EQ(vertex_from->OutDegree(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3226,11 +3718,11 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleCommit) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
ASSERT_FALSE(acc.Commit().HasError());
@@ -3245,13 +3737,13 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleCommit) {
ASSERT_TRUE(vertex_to);
// Check edges
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
}
}
@@ -3308,7 +3800,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) {
// Check edges
{
- auto ret = vertex1.InEdges({}, storage::View::NEW);
+ auto ret = vertex1.InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -3330,7 +3822,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) {
}
}
{
- auto ret = vertex1.OutEdges({}, storage::View::NEW);
+ auto ret = vertex1.OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -3352,7 +3844,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) {
}
}
{
- auto ret = vertex2.InEdges({}, storage::View::NEW);
+ auto ret = vertex2.InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -3374,7 +3866,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) {
}
}
{
- auto ret = vertex2.OutEdges({}, storage::View::NEW);
+ auto ret = vertex2.OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -3428,7 +3920,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) {
// Check edges
{
- auto ret = vertex1->InEdges({}, storage::View::OLD);
+ auto ret = vertex1->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -3449,12 +3941,12 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) {
ASSERT_EQ(e.ToVertex(), *vertex1);
}
}
- ASSERT_EQ(vertex1->InEdges({}, storage::View::NEW).GetError(),
+ ASSERT_EQ(vertex1->InEdges(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
ASSERT_EQ(vertex1->InDegree(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
{
- auto ret = vertex1->OutEdges({}, storage::View::OLD);
+ auto ret = vertex1->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -3475,12 +3967,12 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) {
ASSERT_EQ(e.ToVertex(), *vertex1);
}
}
- ASSERT_EQ(vertex1->OutEdges({}, storage::View::NEW).GetError(),
+ ASSERT_EQ(vertex1->OutEdges(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
ASSERT_EQ(vertex1->OutDegree(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
{
- auto ret = vertex2->InEdges({}, storage::View::OLD);
+ auto ret = vertex2->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -3502,7 +3994,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) {
}
}
{
- auto ret = vertex2->InEdges({}, storage::View::NEW);
+ auto ret = vertex2->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3513,7 +4005,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) {
ASSERT_EQ(e.ToVertex(), *vertex2);
}
{
- auto ret = vertex2->OutEdges({}, storage::View::OLD);
+ auto ret = vertex2->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -3535,7 +4027,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) {
}
}
{
- auto ret = vertex2->OutEdges({}, storage::View::NEW);
+ auto ret = vertex2->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3561,7 +4053,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) {
// Check edges
{
- auto ret = vertex2->InEdges({}, storage::View::OLD);
+ auto ret = vertex2->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3572,7 +4064,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) {
ASSERT_EQ(e.ToVertex(), *vertex2);
}
{
- auto ret = vertex2->InEdges({}, storage::View::NEW);
+ auto ret = vertex2->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3583,7 +4075,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) {
ASSERT_EQ(e.ToVertex(), *vertex2);
}
{
- auto ret = vertex2->OutEdges({}, storage::View::OLD);
+ auto ret = vertex2->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3594,7 +4086,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) {
ASSERT_EQ(e.ToVertex(), *vertex2);
}
{
- auto ret = vertex2->OutEdges({}, storage::View::NEW);
+ auto ret = vertex2->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3634,10 +4126,10 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) {
gid_to = vertex_to.Gid();
// Check edges
- ASSERT_EQ(vertex_from.InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from.InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from.InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from.OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from.OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3648,7 +4140,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) {
ASSERT_EQ(e.ToVertex(), vertex_to);
}
{
- auto ret = vertex_to.InEdges({}, storage::View::NEW);
+ auto ret = vertex_to.InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3658,7 +4150,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) {
ASSERT_EQ(e.FromVertex(), vertex_from);
ASSERT_EQ(e.ToVertex(), vertex_to);
}
- ASSERT_EQ(vertex_to.OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to.OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to.OutDegree(storage::View::NEW), 0);
ASSERT_FALSE(acc.Commit().HasError());
@@ -3689,14 +4181,14 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) {
}
// Check edges
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW).GetError(),
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
ASSERT_EQ(vertex_from->InDegree(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3706,12 +4198,12 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::NEW).GetError(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
ASSERT_EQ(vertex_from->OutDegree(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3721,11 +4213,11 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
acc.Abort();
@@ -3742,10 +4234,10 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) {
auto et = acc.NameToEdgeType("et5");
// Check edges
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::NEW), 0);
{
- auto ret = vertex_from->OutEdges({}, storage::View::NEW);
+ auto ret = vertex_from->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3756,7 +4248,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) {
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
{
- auto ret = vertex_to->InEdges({}, storage::View::NEW);
+ auto ret = vertex_to->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3766,7 +4258,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
ASSERT_FALSE(acc.Commit().HasError());
@@ -3797,14 +4289,14 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) {
}
// Check edges
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_from->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_from->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_from->InEdges({}, storage::View::NEW).GetError(),
+ ASSERT_EQ(vertex_from->InEdges(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
ASSERT_EQ(vertex_from->InDegree(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
{
- auto ret = vertex_from->OutEdges({}, storage::View::OLD);
+ auto ret = vertex_from->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3814,12 +4306,12 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_from->OutEdges({}, storage::View::NEW).GetError(),
+ ASSERT_EQ(vertex_from->OutEdges(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
ASSERT_EQ(vertex_from->OutDegree(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
{
- auto ret = vertex_to->InEdges({}, storage::View::OLD);
+ auto ret = vertex_to->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -3829,11 +4321,11 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) {
ASSERT_EQ(e.FromVertex(), *vertex_from);
ASSERT_EQ(e.ToVertex(), *vertex_to);
}
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
ASSERT_FALSE(acc.Commit().HasError());
@@ -3848,13 +4340,13 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) {
ASSERT_TRUE(vertex_to);
// Check edges
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->InEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->InEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->InDegree(storage::View::NEW), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::OLD)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::OLD)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::OLD), 0);
- ASSERT_EQ(vertex_to->OutEdges({}, storage::View::NEW)->size(), 0);
+ ASSERT_EQ(vertex_to->OutEdges(storage::View::NEW)->size(), 0);
ASSERT_EQ(*vertex_to->OutDegree(storage::View::NEW), 0);
}
}
@@ -3911,7 +4403,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
// Check edges
{
- auto ret = vertex1.InEdges({}, storage::View::NEW);
+ auto ret = vertex1.InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -3933,7 +4425,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
}
}
{
- auto ret = vertex1.OutEdges({}, storage::View::NEW);
+ auto ret = vertex1.OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -3955,7 +4447,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
}
}
{
- auto ret = vertex2.InEdges({}, storage::View::NEW);
+ auto ret = vertex2.InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -3977,7 +4469,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
}
}
{
- auto ret = vertex2.OutEdges({}, storage::View::NEW);
+ auto ret = vertex2.OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -4031,7 +4523,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
// Check edges
{
- auto ret = vertex1->InEdges({}, storage::View::OLD);
+ auto ret = vertex1->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -4052,12 +4544,12 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
ASSERT_EQ(e.ToVertex(), *vertex1);
}
}
- ASSERT_EQ(vertex1->InEdges({}, storage::View::NEW).GetError(),
+ ASSERT_EQ(vertex1->InEdges(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
ASSERT_EQ(vertex1->InDegree(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
{
- auto ret = vertex1->OutEdges({}, storage::View::OLD);
+ auto ret = vertex1->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -4078,12 +4570,12 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
ASSERT_EQ(e.ToVertex(), *vertex1);
}
}
- ASSERT_EQ(vertex1->OutEdges({}, storage::View::NEW).GetError(),
+ ASSERT_EQ(vertex1->OutEdges(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
ASSERT_EQ(vertex1->OutDegree(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
{
- auto ret = vertex2->InEdges({}, storage::View::OLD);
+ auto ret = vertex2->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -4105,7 +4597,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
}
}
{
- auto ret = vertex2->InEdges({}, storage::View::NEW);
+ auto ret = vertex2->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -4116,7 +4608,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
ASSERT_EQ(e.ToVertex(), *vertex2);
}
{
- auto ret = vertex2->OutEdges({}, storage::View::OLD);
+ auto ret = vertex2->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -4138,7 +4630,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
}
}
{
- auto ret = vertex2->OutEdges({}, storage::View::NEW);
+ auto ret = vertex2->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -4167,7 +4659,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
// Check edges
{
- auto ret = vertex1->InEdges({}, storage::View::OLD);
+ auto ret = vertex1->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -4189,7 +4681,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
}
}
{
- auto ret = vertex1->InEdges({}, storage::View::NEW);
+ auto ret = vertex1->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -4211,7 +4703,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
}
}
{
- auto ret = vertex1->OutEdges({}, storage::View::OLD);
+ auto ret = vertex1->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -4233,7 +4725,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
}
}
{
- auto ret = vertex1->OutEdges({}, storage::View::NEW);
+ auto ret = vertex1->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -4255,7 +4747,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
}
}
{
- auto ret = vertex2->InEdges({}, storage::View::OLD);
+ auto ret = vertex2->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -4277,7 +4769,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
}
}
{
- auto ret = vertex2->InEdges({}, storage::View::NEW);
+ auto ret = vertex2->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -4299,7 +4791,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
}
}
{
- auto ret = vertex2->OutEdges({}, storage::View::OLD);
+ auto ret = vertex2->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -4321,7 +4813,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
}
}
{
- auto ret = vertex2->OutEdges({}, storage::View::NEW);
+ auto ret = vertex2->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -4375,7 +4867,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
// Check edges
{
- auto ret = vertex1->InEdges({}, storage::View::OLD);
+ auto ret = vertex1->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -4396,12 +4888,12 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
ASSERT_EQ(e.ToVertex(), *vertex1);
}
}
- ASSERT_EQ(vertex1->InEdges({}, storage::View::NEW).GetError(),
+ ASSERT_EQ(vertex1->InEdges(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
ASSERT_EQ(vertex1->InDegree(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
{
- auto ret = vertex1->OutEdges({}, storage::View::OLD);
+ auto ret = vertex1->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -4422,12 +4914,12 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
ASSERT_EQ(e.ToVertex(), *vertex1);
}
}
- ASSERT_EQ(vertex1->OutEdges({}, storage::View::NEW).GetError(),
+ ASSERT_EQ(vertex1->OutEdges(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
ASSERT_EQ(vertex1->OutDegree(storage::View::NEW).GetError(),
storage::Error::DELETED_OBJECT);
{
- auto ret = vertex2->InEdges({}, storage::View::OLD);
+ auto ret = vertex2->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -4449,7 +4941,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
}
}
{
- auto ret = vertex2->InEdges({}, storage::View::NEW);
+ auto ret = vertex2->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -4460,7 +4952,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
ASSERT_EQ(e.ToVertex(), *vertex2);
}
{
- auto ret = vertex2->OutEdges({}, storage::View::OLD);
+ auto ret = vertex2->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
std::sort(edges.begin(), edges.end(), [](const auto &a, const auto &b) {
@@ -4482,7 +4974,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
}
}
{
- auto ret = vertex2->OutEdges({}, storage::View::NEW);
+ auto ret = vertex2->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -4508,7 +5000,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
// Check edges
{
- auto ret = vertex2->InEdges({}, storage::View::OLD);
+ auto ret = vertex2->InEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -4519,7 +5011,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
ASSERT_EQ(e.ToVertex(), *vertex2);
}
{
- auto ret = vertex2->InEdges({}, storage::View::NEW);
+ auto ret = vertex2->InEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -4530,7 +5022,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
ASSERT_EQ(e.ToVertex(), *vertex2);
}
{
- auto ret = vertex2->OutEdges({}, storage::View::OLD);
+ auto ret = vertex2->OutEdges(storage::View::OLD);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -4541,7 +5033,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) {
ASSERT_EQ(e.ToVertex(), *vertex2);
}
{
- auto ret = vertex2->OutEdges({}, storage::View::NEW);
+ auto ret = vertex2->OutEdges(storage::View::NEW);
ASSERT_TRUE(ret.HasValue());
auto edges = ret.GetValue();
ASSERT_EQ(edges.size(), 1);
@@ -4609,7 +5101,7 @@ TEST(StorageWithProperties, EdgePropertyCommit) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto property = acc.NameToProperty("property5");
@@ -4640,7 +5132,7 @@ TEST(StorageWithProperties, EdgePropertyCommit) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto property = acc.NameToProperty("property5");
@@ -4673,7 +5165,7 @@ TEST(StorageWithProperties, EdgePropertyCommit) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto property = acc.NameToProperty("property5");
@@ -4715,7 +5207,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto property = acc.NameToProperty("property5");
@@ -4759,7 +5251,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto property = acc.NameToProperty("property5");
@@ -4781,7 +5273,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto property = acc.NameToProperty("property5");
@@ -4825,7 +5317,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto property = acc.NameToProperty("property5");
@@ -4858,7 +5350,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto property = acc.NameToProperty("property5");
@@ -4903,7 +5395,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto property = acc.NameToProperty("property5");
@@ -4936,7 +5428,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto property = acc.NameToProperty("property5");
@@ -4981,7 +5473,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto property = acc.NameToProperty("property5");
@@ -5023,7 +5515,7 @@ TEST(StorageWithProperties, EdgePropertySerializationError) {
{
auto vertex = acc1.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto property1 = acc1.NameToProperty("property1");
auto property2 = acc1.NameToProperty("property2");
@@ -5057,7 +5549,7 @@ TEST(StorageWithProperties, EdgePropertySerializationError) {
{
auto vertex = acc2.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto property1 = acc2.NameToProperty("property1");
auto property2 = acc2.NameToProperty("property2");
@@ -5085,7 +5577,7 @@ TEST(StorageWithProperties, EdgePropertySerializationError) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto property1 = acc.NameToProperty("property1");
auto property2 = acc.NameToProperty("property2");
@@ -5135,7 +5627,7 @@ TEST(StorageWithProperties, EdgePropertyClear) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
ASSERT_EQ(edge.GetProperty(property1, storage::View::OLD)->ValueString(),
"value");
@@ -5170,7 +5662,7 @@ TEST(StorageWithProperties, EdgePropertyClear) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto res = edge.SetProperty(property2, storage::PropertyValue(42));
ASSERT_TRUE(res.HasValue());
@@ -5182,7 +5674,7 @@ TEST(StorageWithProperties, EdgePropertyClear) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
ASSERT_EQ(edge.GetProperty(property1, storage::View::OLD)->ValueString(),
"value");
@@ -5218,7 +5710,7 @@ TEST(StorageWithProperties, EdgePropertyClear) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
ASSERT_TRUE(edge.GetProperty(property1, storage::View::NEW)->IsNull());
ASSERT_TRUE(edge.GetProperty(property2, storage::View::NEW)->IsNull());
@@ -5248,7 +5740,7 @@ TEST(StorageWithoutProperties, EdgePropertyAbort) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto property = acc.NameToProperty("property5");
@@ -5280,7 +5772,7 @@ TEST(StorageWithoutProperties, EdgePropertyAbort) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
auto property = acc.NameToProperty("property5");
@@ -5317,7 +5809,7 @@ TEST(StorageWithoutProperties, EdgePropertyClear) {
auto acc = store.Access();
auto vertex = acc.FindVertex(gid, storage::View::OLD);
ASSERT_TRUE(vertex);
- auto edge = vertex->OutEdges({}, storage::View::NEW).GetValue()[0];
+ auto edge = vertex->OutEdges(storage::View::NEW).GetValue()[0];
ASSERT_EQ(edge.ClearProperties().GetError(),
storage::Error::PROPERTIES_DISABLED);
diff --git a/tests/unit/storage_v2_gc.cpp b/tests/unit/storage_v2_gc.cpp
index df7d20612..02ccd2a79 100644
--- a/tests/unit/storage_v2_gc.cpp
+++ b/tests/unit/storage_v2_gc.cpp
@@ -129,7 +129,7 @@ TEST(StorageV2Gc, Sanity) {
auto vertex = acc.FindVertex(vertices[i], storage::View::NEW);
EXPECT_EQ(vertex.has_value(), i % 5 != 0 && i % 3 != 0);
if (vertex.has_value()) {
- auto out_edges = vertex->OutEdges({}, storage::View::NEW);
+ auto out_edges = vertex->OutEdges(storage::View::NEW);
if (i % 5 != 4 && i % 3 != 2) {
EXPECT_EQ(out_edges.GetValue().size(), 1);
EXPECT_EQ(*vertex->OutDegree(storage::View::NEW), 1);
@@ -138,7 +138,7 @@ TEST(StorageV2Gc, Sanity) {
EXPECT_TRUE(out_edges->empty());
}
- auto in_edges = vertex->InEdges({}, storage::View::NEW);
+ auto in_edges = vertex->InEdges(storage::View::NEW);
if (i % 5 != 1 && i % 3 != 1) {
EXPECT_EQ(in_edges.GetValue().size(), 1);
EXPECT_EQ(*vertex->InDegree(storage::View::NEW), 1);