From 5f659867bdd76e9fb6cf3db7fdcf0fa7626bce9e Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 6 Nov 2025 07:23:01 +0000 Subject: [PATCH 1/9] Initial plan From 3081d8d09cb1f7e239380f2c30da1a437252190a Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 6 Nov 2025 07:31:30 +0000 Subject: [PATCH 2/9] Refactor edge_range test to use GoogleTest matchers Co-authored-by: niklas-uhl <23433189+niklas-uhl@users.noreply.github.com> --- tests/edge_range.cpp | 28 +++++++++++++--------------- 1 file changed, 13 insertions(+), 15 deletions(-) diff --git a/tests/edge_range.cpp b/tests/edge_range.cpp index 836c97e..40ad44a 100644 --- a/tests/edge_range.cpp +++ b/tests/edge_range.cpp @@ -2,6 +2,7 @@ #include "kagen/kagen.h" +#include #include #include "tests/gather.h" @@ -12,28 +13,25 @@ using namespace kagen; void check_edge_range(const Graph& graph) { + using ::testing::ElementsAreArray; + Edgelist edgelist = graph.edges; if (graph.representation == GraphRepresentation::CSR) { edgelist = BuildEdgeListFromCSR(graph.vertex_range, graph.xadj, graph.adjncy); } EdgeRange edge_range(graph); - { - std::size_t expected_index = 0; - for (auto it = edge_range.begin(); it != edge_range.end(); ++it) { - auto edge = *it; - EXPECT_EQ(it.edge_index(), expected_index); - EXPECT_EQ(*it, edge); - ++expected_index; - } - } + // Collect edges from edge_range into a vector for comparison + std::vector edges_from_range(edge_range.begin(), edge_range.end()); - { - EXPECT_EQ(edge_range.size(), edgelist.size()); - for (std::size_t i = 0; auto elem: edge_range) { - EXPECT_EQ(elem, edgelist[i]); - ++i; - } + // Check that edge_range produces the same edges as edgelist + EXPECT_THAT(edges_from_range, ElementsAreArray(edgelist)); + + // Check that edge indices are consecutive starting from 0 + std::size_t expected_index = 0; + for (auto it = edge_range.begin(); it != edge_range.end(); ++it) { + EXPECT_EQ(it.edge_index(), expected_index); + ++expected_index; } } From 15125b9d1b51acab5e840bb42b36bed9369818ae Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 6 Nov 2025 07:32:49 +0000 Subject: [PATCH 3/9] Use matchers for edge index verification as well Co-authored-by: niklas-uhl <23433189+niklas-uhl@users.noreply.github.com> --- tests/edge_range.cpp | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/tests/edge_range.cpp b/tests/edge_range.cpp index 40ad44a..ba358d3 100644 --- a/tests/edge_range.cpp +++ b/tests/edge_range.cpp @@ -5,6 +5,8 @@ #include #include +#include + #include "tests/gather.h" #include "tests/utils.h" #include "tools/converter.h" @@ -27,12 +29,17 @@ void check_edge_range(const Graph& graph) { // Check that edge_range produces the same edges as edgelist EXPECT_THAT(edges_from_range, ElementsAreArray(edgelist)); - // Check that edge indices are consecutive starting from 0 - std::size_t expected_index = 0; + // Collect edge indices to verify they are consecutive starting from 0 + std::vector edge_indices; for (auto it = edge_range.begin(); it != edge_range.end(); ++it) { - EXPECT_EQ(it.edge_index(), expected_index); - ++expected_index; + edge_indices.push_back(it.edge_index()); } + + // Generate expected indices: [0, 1, 2, ..., n-1] + std::vector expected_indices(edge_indices.size()); + std::iota(expected_indices.begin(), expected_indices.end(), 0); + + EXPECT_THAT(edge_indices, ElementsAreArray(expected_indices)); } void check_edge_range(KaGen& generator, SInt n, SInt m) { From 74f5a411c5a1adfef8691485da2cd254b712b37d Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 6 Nov 2025 07:49:30 +0000 Subject: [PATCH 4/9] Remove check_edge_range helper and inline logic into tests Co-authored-by: niklas-uhl <23433189+niklas-uhl@users.noreply.github.com> --- tests/edge_range.cpp | 174 +++++++++++++++++++++++++------------------ 1 file changed, 103 insertions(+), 71 deletions(-) diff --git a/tests/edge_range.cpp b/tests/edge_range.cpp index ba358d3..a845090 100644 --- a/tests/edge_range.cpp +++ b/tests/edge_range.cpp @@ -5,8 +5,6 @@ #include #include -#include - #include "tests/gather.h" #include "tests/utils.h" #include "tools/converter.h" @@ -14,100 +12,134 @@ using namespace kagen; -void check_edge_range(const Graph& graph) { +TEST(EdgeRangeTest, iterate_edgelist_representation) { using ::testing::ElementsAreArray; - Edgelist edgelist = graph.edges; - if (graph.representation == GraphRepresentation::CSR) { - edgelist = BuildEdgeListFromCSR(graph.vertex_range, graph.xadj, graph.adjncy); - } - EdgeRange edge_range(graph); - - // Collect edges from edge_range into a vector for comparison - std::vector edges_from_range(edge_range.begin(), edge_range.end()); - - // Check that edge_range produces the same edges as edgelist - EXPECT_THAT(edges_from_range, ElementsAreArray(edgelist)); - - // Collect edge indices to verify they are consecutive starting from 0 - std::vector edge_indices; - for (auto it = edge_range.begin(); it != edge_range.end(); ++it) { - edge_indices.push_back(it.edge_index()); - } - - // Generate expected indices: [0, 1, 2, ..., n-1] - std::vector expected_indices(edge_indices.size()); - std::iota(expected_indices.begin(), expected_indices.end(), 0); - - EXPECT_THAT(edge_indices, ElementsAreArray(expected_indices)); -} - -void check_edge_range(KaGen& generator, SInt n, SInt m) { - // GNM - { - kagen::Graph graph = generator.GenerateUndirectedGNM(n, m); - check_edge_range(graph); - } - // RMAT - { - kagen::Graph graph = generator.GenerateRMAT(n, m, 0.56, 0.19, 0.19); - check_edge_range(graph); - } - // RGG2D - { - kagen::Graph graph = generator.GenerateRGG2D_NM(n, m); - check_edge_range(graph); - } - // RGG3D - { - kagen::Graph graph = generator.GenerateRGG3D_NM(n, m); - check_edge_range(graph); - } - // RHG - { - kagen::Graph graph = generator.GenerateRHG_NM(2.6, n, m); - check_edge_range(graph); - } - // GRID2D - { - kagen::Graph graph = generator.GenerateGrid2D_NM(n, m); - check_edge_range(graph); - } - // GRID2D - { - kagen::Graph graph = generator.GenerateGrid3D_NM(n, m); - check_edge_range(graph); - } -} - -TEST(EdgeRangeTest, iterate_edgelist_representation) { kagen::KaGen generator(MPI_COMM_WORLD); generator.UseEdgeListRepresentation(); const SInt n = 1000; const SInt m = 16 * n; - check_edge_range(generator, n, m); + + auto check = [](const Graph& graph) { + Edgelist expected = graph.edges; + if (graph.representation == GraphRepresentation::CSR) { + expected = BuildEdgeListFromCSR(graph.vertex_range, graph.xadj, graph.adjncy); + } + EdgeRange edge_range(graph); + + // Check edges match and indices are consecutive + EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); + + std::size_t idx = 0; + for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { + EXPECT_EQ(it.edge_index(), idx); + } + }; + + check(generator.GenerateUndirectedGNM(n, m)); + check(generator.GenerateRMAT(n, m, 0.56, 0.19, 0.19)); + check(generator.GenerateRGG2D_NM(n, m)); + check(generator.GenerateRGG3D_NM(n, m)); + check(generator.GenerateRHG_NM(2.6, n, m)); + check(generator.GenerateGrid2D_NM(n, m)); + check(generator.GenerateGrid3D_NM(n, m)); } TEST(EdgeRangeTest, iterate_sparse_edgelist_representation) { + using ::testing::ElementsAreArray; + kagen::KaGen generator(MPI_COMM_WORLD); generator.UseEdgeListRepresentation(); const SInt n = 1000; const SInt m = 2 * n; - check_edge_range(generator, n, m); + + auto check = [](const Graph& graph) { + Edgelist expected = graph.edges; + if (graph.representation == GraphRepresentation::CSR) { + expected = BuildEdgeListFromCSR(graph.vertex_range, graph.xadj, graph.adjncy); + } + EdgeRange edge_range(graph); + + // Check edges match and indices are consecutive + EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); + + std::size_t idx = 0; + for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { + EXPECT_EQ(it.edge_index(), idx); + } + }; + + check(generator.GenerateUndirectedGNM(n, m)); + check(generator.GenerateRMAT(n, m, 0.56, 0.19, 0.19)); + check(generator.GenerateRGG2D_NM(n, m)); + check(generator.GenerateRGG3D_NM(n, m)); + check(generator.GenerateRHG_NM(2.6, n, m)); + check(generator.GenerateGrid2D_NM(n, m)); + check(generator.GenerateGrid3D_NM(n, m)); } TEST(EdgeRangeTest, iterate_csr_representation) { + using ::testing::ElementsAreArray; + kagen::KaGen generator(MPI_COMM_WORLD); generator.UseCSRRepresentation(); const SInt n = 1000; const SInt m = 16 * n; - check_edge_range(generator, n, m); + + auto check = [](const Graph& graph) { + Edgelist expected = graph.edges; + if (graph.representation == GraphRepresentation::CSR) { + expected = BuildEdgeListFromCSR(graph.vertex_range, graph.xadj, graph.adjncy); + } + EdgeRange edge_range(graph); + + // Check edges match and indices are consecutive + EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); + + std::size_t idx = 0; + for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { + EXPECT_EQ(it.edge_index(), idx); + } + }; + + check(generator.GenerateUndirectedGNM(n, m)); + check(generator.GenerateRMAT(n, m, 0.56, 0.19, 0.19)); + check(generator.GenerateRGG2D_NM(n, m)); + check(generator.GenerateRGG3D_NM(n, m)); + check(generator.GenerateRHG_NM(2.6, n, m)); + check(generator.GenerateGrid2D_NM(n, m)); + check(generator.GenerateGrid3D_NM(n, m)); } TEST(EdgeRangeTest, iterate_sparse_csr_representation) { + using ::testing::ElementsAreArray; + kagen::KaGen generator(MPI_COMM_WORLD); generator.UseCSRRepresentation(); const SInt n = 1000; const SInt m = 2 * n; - check_edge_range(generator, n, m); + + auto check = [](const Graph& graph) { + Edgelist expected = graph.edges; + if (graph.representation == GraphRepresentation::CSR) { + expected = BuildEdgeListFromCSR(graph.vertex_range, graph.xadj, graph.adjncy); + } + EdgeRange edge_range(graph); + + // Check edges match and indices are consecutive + EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); + + std::size_t idx = 0; + for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { + EXPECT_EQ(it.edge_index(), idx); + } + }; + + check(generator.GenerateUndirectedGNM(n, m)); + check(generator.GenerateRMAT(n, m, 0.56, 0.19, 0.19)); + check(generator.GenerateRGG2D_NM(n, m)); + check(generator.GenerateRGG3D_NM(n, m)); + check(generator.GenerateRHG_NM(2.6, n, m)); + check(generator.GenerateGrid2D_NM(n, m)); + check(generator.GenerateGrid3D_NM(n, m)); } From f31168a7c150ea33f228fe63bad96b653ee731c8 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 6 Nov 2025 08:02:20 +0000 Subject: [PATCH 5/9] Remove unnecessary CSR check from edgelist tests Co-authored-by: niklas-uhl <23433189+niklas-uhl@users.noreply.github.com> --- tests/edge_range.cpp | 6 ------ 1 file changed, 6 deletions(-) diff --git a/tests/edge_range.cpp b/tests/edge_range.cpp index a845090..22214da 100644 --- a/tests/edge_range.cpp +++ b/tests/edge_range.cpp @@ -22,9 +22,6 @@ TEST(EdgeRangeTest, iterate_edgelist_representation) { auto check = [](const Graph& graph) { Edgelist expected = graph.edges; - if (graph.representation == GraphRepresentation::CSR) { - expected = BuildEdgeListFromCSR(graph.vertex_range, graph.xadj, graph.adjncy); - } EdgeRange edge_range(graph); // Check edges match and indices are consecutive @@ -55,9 +52,6 @@ TEST(EdgeRangeTest, iterate_sparse_edgelist_representation) { auto check = [](const Graph& graph) { Edgelist expected = graph.edges; - if (graph.representation == GraphRepresentation::CSR) { - expected = BuildEdgeListFromCSR(graph.vertex_range, graph.xadj, graph.adjncy); - } EdgeRange edge_range(graph); // Check edges match and indices are consecutive From d323aace37e81f4b0786b8d756ee01f91ff56fb6 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 6 Nov 2025 08:10:33 +0000 Subject: [PATCH 6/9] Convert tests to parameterized tests by generator type and remove always-true conditionals Co-authored-by: niklas-uhl <23433189+niklas-uhl@users.noreply.github.com> --- tests/edge_range.cpp | 183 ++++++++++++++++++++----------------------- 1 file changed, 85 insertions(+), 98 deletions(-) diff --git a/tests/edge_range.cpp b/tests/edge_range.cpp index 22214da..af9bbf1 100644 --- a/tests/edge_range.cpp +++ b/tests/edge_range.cpp @@ -5,6 +5,9 @@ #include #include +#include +#include + #include "tests/gather.h" #include "tests/utils.h" #include "tools/converter.h" @@ -12,128 +15,112 @@ using namespace kagen; -TEST(EdgeRangeTest, iterate_edgelist_representation) { +using GeneratorFunc = std::function; + +struct EdgeRangeTestFixture : public ::testing::TestWithParam> {}; + +INSTANTIATE_TEST_SUITE_P( + EdgeRangeTests, EdgeRangeTestFixture, + ::testing::Values( + std::make_tuple("GNM", GeneratorFunc([](KaGen& gen, SInt n, SInt m) { return gen.GenerateUndirectedGNM(n, m); })), + std::make_tuple("RMAT", GeneratorFunc([](KaGen& gen, SInt n, SInt m) { return gen.GenerateRMAT(n, m, 0.56, 0.19, 0.19); })), + std::make_tuple("RGG2D", GeneratorFunc([](KaGen& gen, SInt n, SInt m) { return gen.GenerateRGG2D_NM(n, m); })), + std::make_tuple("RGG3D", GeneratorFunc([](KaGen& gen, SInt n, SInt m) { return gen.GenerateRGG3D_NM(n, m); })), + std::make_tuple("RHG", GeneratorFunc([](KaGen& gen, SInt n, SInt m) { return gen.GenerateRHG_NM(2.6, n, m); })), + std::make_tuple("Grid2D", GeneratorFunc([](KaGen& gen, SInt n, SInt m) { return gen.GenerateGrid2D_NM(n, m); })), + std::make_tuple("Grid3D", GeneratorFunc([](KaGen& gen, SInt n, SInt m) { return gen.GenerateGrid3D_NM(n, m); }))), + [](const ::testing::TestParamInfo& info) { + return std::get<0>(info.param); + }); + +TEST_P(EdgeRangeTestFixture, iterate_edgelist_representation) { using ::testing::ElementsAreArray; - kagen::KaGen generator(MPI_COMM_WORLD); - generator.UseEdgeListRepresentation(); + auto [name, generate] = GetParam(); const SInt n = 1000; const SInt m = 16 * n; - auto check = [](const Graph& graph) { - Edgelist expected = graph.edges; - EdgeRange edge_range(graph); - - // Check edges match and indices are consecutive - EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); - - std::size_t idx = 0; - for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { - EXPECT_EQ(it.edge_index(), idx); - } - }; - - check(generator.GenerateUndirectedGNM(n, m)); - check(generator.GenerateRMAT(n, m, 0.56, 0.19, 0.19)); - check(generator.GenerateRGG2D_NM(n, m)); - check(generator.GenerateRGG3D_NM(n, m)); - check(generator.GenerateRHG_NM(2.6, n, m)); - check(generator.GenerateGrid2D_NM(n, m)); - check(generator.GenerateGrid3D_NM(n, m)); + kagen::KaGen generator(MPI_COMM_WORLD); + generator.UseEdgeListRepresentation(); + Graph graph = generate(generator, n, m); + + Edgelist expected = graph.edges; + EdgeRange edge_range(graph); + + // Check edges match and indices are consecutive + EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); + + std::size_t idx = 0; + for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { + EXPECT_EQ(it.edge_index(), idx); + } } -TEST(EdgeRangeTest, iterate_sparse_edgelist_representation) { +TEST_P(EdgeRangeTestFixture, iterate_sparse_edgelist_representation) { using ::testing::ElementsAreArray; - kagen::KaGen generator(MPI_COMM_WORLD); - generator.UseEdgeListRepresentation(); + auto [name, generate] = GetParam(); const SInt n = 1000; const SInt m = 2 * n; - auto check = [](const Graph& graph) { - Edgelist expected = graph.edges; - EdgeRange edge_range(graph); - - // Check edges match and indices are consecutive - EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); - - std::size_t idx = 0; - for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { - EXPECT_EQ(it.edge_index(), idx); - } - }; - - check(generator.GenerateUndirectedGNM(n, m)); - check(generator.GenerateRMAT(n, m, 0.56, 0.19, 0.19)); - check(generator.GenerateRGG2D_NM(n, m)); - check(generator.GenerateRGG3D_NM(n, m)); - check(generator.GenerateRHG_NM(2.6, n, m)); - check(generator.GenerateGrid2D_NM(n, m)); - check(generator.GenerateGrid3D_NM(n, m)); + kagen::KaGen generator(MPI_COMM_WORLD); + generator.UseEdgeListRepresentation(); + Graph graph = generate(generator, n, m); + + Edgelist expected = graph.edges; + EdgeRange edge_range(graph); + + // Check edges match and indices are consecutive + EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); + + std::size_t idx = 0; + for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { + EXPECT_EQ(it.edge_index(), idx); + } } -TEST(EdgeRangeTest, iterate_csr_representation) { +TEST_P(EdgeRangeTestFixture, iterate_csr_representation) { using ::testing::ElementsAreArray; - kagen::KaGen generator(MPI_COMM_WORLD); - generator.UseCSRRepresentation(); + auto [name, generate] = GetParam(); const SInt n = 1000; const SInt m = 16 * n; - auto check = [](const Graph& graph) { - Edgelist expected = graph.edges; - if (graph.representation == GraphRepresentation::CSR) { - expected = BuildEdgeListFromCSR(graph.vertex_range, graph.xadj, graph.adjncy); - } - EdgeRange edge_range(graph); - - // Check edges match and indices are consecutive - EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); - - std::size_t idx = 0; - for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { - EXPECT_EQ(it.edge_index(), idx); - } - }; - - check(generator.GenerateUndirectedGNM(n, m)); - check(generator.GenerateRMAT(n, m, 0.56, 0.19, 0.19)); - check(generator.GenerateRGG2D_NM(n, m)); - check(generator.GenerateRGG3D_NM(n, m)); - check(generator.GenerateRHG_NM(2.6, n, m)); - check(generator.GenerateGrid2D_NM(n, m)); - check(generator.GenerateGrid3D_NM(n, m)); + kagen::KaGen generator(MPI_COMM_WORLD); + generator.UseCSRRepresentation(); + Graph graph = generate(generator, n, m); + + Edgelist expected = BuildEdgeListFromCSR(graph.vertex_range, graph.xadj, graph.adjncy); + EdgeRange edge_range(graph); + + // Check edges match and indices are consecutive + EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); + + std::size_t idx = 0; + for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { + EXPECT_EQ(it.edge_index(), idx); + } } -TEST(EdgeRangeTest, iterate_sparse_csr_representation) { +TEST_P(EdgeRangeTestFixture, iterate_sparse_csr_representation) { using ::testing::ElementsAreArray; - kagen::KaGen generator(MPI_COMM_WORLD); - generator.UseCSRRepresentation(); + auto [name, generate] = GetParam(); const SInt n = 1000; const SInt m = 2 * n; - auto check = [](const Graph& graph) { - Edgelist expected = graph.edges; - if (graph.representation == GraphRepresentation::CSR) { - expected = BuildEdgeListFromCSR(graph.vertex_range, graph.xadj, graph.adjncy); - } - EdgeRange edge_range(graph); - - // Check edges match and indices are consecutive - EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); - - std::size_t idx = 0; - for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { - EXPECT_EQ(it.edge_index(), idx); - } - }; - - check(generator.GenerateUndirectedGNM(n, m)); - check(generator.GenerateRMAT(n, m, 0.56, 0.19, 0.19)); - check(generator.GenerateRGG2D_NM(n, m)); - check(generator.GenerateRGG3D_NM(n, m)); - check(generator.GenerateRHG_NM(2.6, n, m)); - check(generator.GenerateGrid2D_NM(n, m)); - check(generator.GenerateGrid3D_NM(n, m)); + kagen::KaGen generator(MPI_COMM_WORLD); + generator.UseCSRRepresentation(); + Graph graph = generate(generator, n, m); + + Edgelist expected = BuildEdgeListFromCSR(graph.vertex_range, graph.xadj, graph.adjncy); + EdgeRange edge_range(graph); + + // Check edges match and indices are consecutive + EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); + + std::size_t idx = 0; + for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { + EXPECT_EQ(it.edge_index(), idx); + } } From e00466c623784f996a0045e2037f1fdd68891d75 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 6 Nov 2025 08:30:08 +0000 Subject: [PATCH 7/9] Use custom matcher for edge index check without allocating vector Co-authored-by: niklas-uhl <23433189+niklas-uhl@users.noreply.github.com> --- tests/edge_range.cpp | 35 +++++++++++++++-------------------- 1 file changed, 15 insertions(+), 20 deletions(-) diff --git a/tests/edge_range.cpp b/tests/edge_range.cpp index af9bbf1..f9f4097 100644 --- a/tests/edge_range.cpp +++ b/tests/edge_range.cpp @@ -17,6 +17,17 @@ using namespace kagen; using GeneratorFunc = std::function; +MATCHER(HasConsecutiveEdgeIndices, "") { + std::size_t expected_idx = 0; + for (auto it = arg.begin(); it != arg.end(); ++it, ++expected_idx) { + if (it.edge_index() != expected_idx) { + *result_listener << "edge at position " << expected_idx << " has edge_index() = " << it.edge_index(); + return false; + } + } + return true; +} + struct EdgeRangeTestFixture : public ::testing::TestWithParam> {}; INSTANTIATE_TEST_SUITE_P( @@ -49,11 +60,7 @@ TEST_P(EdgeRangeTestFixture, iterate_edgelist_representation) { // Check edges match and indices are consecutive EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); - - std::size_t idx = 0; - for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { - EXPECT_EQ(it.edge_index(), idx); - } + EXPECT_THAT(edge_range, HasConsecutiveEdgeIndices()); } TEST_P(EdgeRangeTestFixture, iterate_sparse_edgelist_representation) { @@ -72,11 +79,7 @@ TEST_P(EdgeRangeTestFixture, iterate_sparse_edgelist_representation) { // Check edges match and indices are consecutive EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); - - std::size_t idx = 0; - for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { - EXPECT_EQ(it.edge_index(), idx); - } + EXPECT_THAT(edge_range, HasConsecutiveEdgeIndices()); } TEST_P(EdgeRangeTestFixture, iterate_csr_representation) { @@ -95,11 +98,7 @@ TEST_P(EdgeRangeTestFixture, iterate_csr_representation) { // Check edges match and indices are consecutive EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); - - std::size_t idx = 0; - for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { - EXPECT_EQ(it.edge_index(), idx); - } + EXPECT_THAT(edge_range, HasConsecutiveEdgeIndices()); } TEST_P(EdgeRangeTestFixture, iterate_sparse_csr_representation) { @@ -118,9 +117,5 @@ TEST_P(EdgeRangeTestFixture, iterate_sparse_csr_representation) { // Check edges match and indices are consecutive EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); - - std::size_t idx = 0; - for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { - EXPECT_EQ(it.edge_index(), idx); - } + EXPECT_THAT(edge_range, HasConsecutiveEdgeIndices()); } From 0c143fbecd69f756de3f3fbdd4494a8ce400600f Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 6 Nov 2025 08:43:03 +0000 Subject: [PATCH 8/9] Revert custom matcher, use explicit loop for edge index check Co-authored-by: niklas-uhl <23433189+niklas-uhl@users.noreply.github.com> --- tests/edge_range.cpp | 35 ++++++++++++++++++++--------------- 1 file changed, 20 insertions(+), 15 deletions(-) diff --git a/tests/edge_range.cpp b/tests/edge_range.cpp index f9f4097..af9bbf1 100644 --- a/tests/edge_range.cpp +++ b/tests/edge_range.cpp @@ -17,17 +17,6 @@ using namespace kagen; using GeneratorFunc = std::function; -MATCHER(HasConsecutiveEdgeIndices, "") { - std::size_t expected_idx = 0; - for (auto it = arg.begin(); it != arg.end(); ++it, ++expected_idx) { - if (it.edge_index() != expected_idx) { - *result_listener << "edge at position " << expected_idx << " has edge_index() = " << it.edge_index(); - return false; - } - } - return true; -} - struct EdgeRangeTestFixture : public ::testing::TestWithParam> {}; INSTANTIATE_TEST_SUITE_P( @@ -60,7 +49,11 @@ TEST_P(EdgeRangeTestFixture, iterate_edgelist_representation) { // Check edges match and indices are consecutive EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); - EXPECT_THAT(edge_range, HasConsecutiveEdgeIndices()); + + std::size_t idx = 0; + for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { + EXPECT_EQ(it.edge_index(), idx); + } } TEST_P(EdgeRangeTestFixture, iterate_sparse_edgelist_representation) { @@ -79,7 +72,11 @@ TEST_P(EdgeRangeTestFixture, iterate_sparse_edgelist_representation) { // Check edges match and indices are consecutive EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); - EXPECT_THAT(edge_range, HasConsecutiveEdgeIndices()); + + std::size_t idx = 0; + for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { + EXPECT_EQ(it.edge_index(), idx); + } } TEST_P(EdgeRangeTestFixture, iterate_csr_representation) { @@ -98,7 +95,11 @@ TEST_P(EdgeRangeTestFixture, iterate_csr_representation) { // Check edges match and indices are consecutive EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); - EXPECT_THAT(edge_range, HasConsecutiveEdgeIndices()); + + std::size_t idx = 0; + for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { + EXPECT_EQ(it.edge_index(), idx); + } } TEST_P(EdgeRangeTestFixture, iterate_sparse_csr_representation) { @@ -117,5 +118,9 @@ TEST_P(EdgeRangeTestFixture, iterate_sparse_csr_representation) { // Check edges match and indices are consecutive EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); - EXPECT_THAT(edge_range, HasConsecutiveEdgeIndices()); + + std::size_t idx = 0; + for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { + EXPECT_EQ(it.edge_index(), idx); + } } From 6229c4755daa98cfa3ffd515d04587e512666853 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 6 Nov 2025 09:01:53 +0000 Subject: [PATCH 9/9] Use Pointwise matcher with EdgeIndexMatches for edge index verification Co-authored-by: niklas-uhl <23433189+niklas-uhl@users.noreply.github.com> --- tests/edge_range.cpp | 46 ++++++++++++++++++++++++++++++++------------ 1 file changed, 34 insertions(+), 12 deletions(-) diff --git a/tests/edge_range.cpp b/tests/edge_range.cpp index af9bbf1..721cffe 100644 --- a/tests/edge_range.cpp +++ b/tests/edge_range.cpp @@ -6,6 +6,7 @@ #include #include +#include #include #include "tests/gather.h" @@ -17,6 +18,11 @@ using namespace kagen; using GeneratorFunc = std::function; +MATCHER(EdgeIndexMatches, "") { + auto [iter, expected_idx] = arg; + return iter.edge_index() == expected_idx; +} + struct EdgeRangeTestFixture : public ::testing::TestWithParam> {}; INSTANTIATE_TEST_SUITE_P( @@ -35,6 +41,7 @@ INSTANTIATE_TEST_SUITE_P( TEST_P(EdgeRangeTestFixture, iterate_edgelist_representation) { using ::testing::ElementsAreArray; + using ::testing::Pointwise; auto [name, generate] = GetParam(); const SInt n = 1000; @@ -50,14 +57,18 @@ TEST_P(EdgeRangeTestFixture, iterate_edgelist_representation) { // Check edges match and indices are consecutive EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); - std::size_t idx = 0; - for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { - EXPECT_EQ(it.edge_index(), idx); + std::vector iterators; + for (auto it = edge_range.begin(); it != edge_range.end(); ++it) { + iterators.push_back(it); } + std::vector expected_indices(edge_range.size()); + std::iota(expected_indices.begin(), expected_indices.end(), 0); + EXPECT_THAT(iterators, Pointwise(EdgeIndexMatches(), expected_indices)); } TEST_P(EdgeRangeTestFixture, iterate_sparse_edgelist_representation) { using ::testing::ElementsAreArray; + using ::testing::Pointwise; auto [name, generate] = GetParam(); const SInt n = 1000; @@ -73,14 +84,18 @@ TEST_P(EdgeRangeTestFixture, iterate_sparse_edgelist_representation) { // Check edges match and indices are consecutive EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); - std::size_t idx = 0; - for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { - EXPECT_EQ(it.edge_index(), idx); + std::vector iterators; + for (auto it = edge_range.begin(); it != edge_range.end(); ++it) { + iterators.push_back(it); } + std::vector expected_indices(edge_range.size()); + std::iota(expected_indices.begin(), expected_indices.end(), 0); + EXPECT_THAT(iterators, Pointwise(EdgeIndexMatches(), expected_indices)); } TEST_P(EdgeRangeTestFixture, iterate_csr_representation) { using ::testing::ElementsAreArray; + using ::testing::Pointwise; auto [name, generate] = GetParam(); const SInt n = 1000; @@ -96,14 +111,18 @@ TEST_P(EdgeRangeTestFixture, iterate_csr_representation) { // Check edges match and indices are consecutive EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); - std::size_t idx = 0; - for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { - EXPECT_EQ(it.edge_index(), idx); + std::vector iterators; + for (auto it = edge_range.begin(); it != edge_range.end(); ++it) { + iterators.push_back(it); } + std::vector expected_indices(edge_range.size()); + std::iota(expected_indices.begin(), expected_indices.end(), 0); + EXPECT_THAT(iterators, Pointwise(EdgeIndexMatches(), expected_indices)); } TEST_P(EdgeRangeTestFixture, iterate_sparse_csr_representation) { using ::testing::ElementsAreArray; + using ::testing::Pointwise; auto [name, generate] = GetParam(); const SInt n = 1000; @@ -119,8 +138,11 @@ TEST_P(EdgeRangeTestFixture, iterate_sparse_csr_representation) { // Check edges match and indices are consecutive EXPECT_THAT(std::vector(edge_range.begin(), edge_range.end()), ElementsAreArray(expected)); - std::size_t idx = 0; - for (auto it = edge_range.begin(); it != edge_range.end(); ++it, ++idx) { - EXPECT_EQ(it.edge_index(), idx); + std::vector iterators; + for (auto it = edge_range.begin(); it != edge_range.end(); ++it) { + iterators.push_back(it); } + std::vector expected_indices(edge_range.size()); + std::iota(expected_indices.begin(), expected_indices.end(), 0); + EXPECT_THAT(iterators, Pointwise(EdgeIndexMatches(), expected_indices)); }