hypergraph io tests

Author: SpectraL519

include/gl/io/graph_fio.hpp

@@ -9,18 +9,26 @@
 #include <filesystem>
 #include <fstream>
 
-namespace gl::io {
+namespace gl {
+namespace io {
 
 struct write {};
 
 struct append {};
 
-namespace detail {
+} // namespace io
+
+namespace traits {
 
 template <typename T>
-concept c_io_save_mode = traits::c_one_of<T, write, append>;
+concept c_io_save_mode = traits::c_one_of<T, io::write, io::append>;
+
+} // namespace traits
+
+namespace io {
+namespace detail {
 
-template <c_io_save_mode Mode>
+template <traits::c_io_save_mode Mode>
 requires(std::same_as<Mode, write>)
 [[nodiscard]] std::ofstream open_outfile(const std::filesystem::path& path) {
     if (std::filesystem::exists(path))
@@ -37,7 +45,7 @@ requires(std::same_as<Mode, write>)
     return file;
 }
 
-template <c_io_save_mode Mode>
+template <traits::c_io_save_mode Mode>
 requires(std::same_as<Mode, append>)
 [[nodiscard]] std::ofstream open_outfile(const std::filesystem::path& path) {
     if (not std::filesystem::exists(path))
@@ -87,7 +95,7 @@ requires(std::same_as<Mode, append>)
 
 } // namespace detail
 
-template <traits::c_graph GraphType, detail::c_io_save_mode Mode = write>
+template <traits::c_graph GraphType, traits::c_io_save_mode Mode = write>
 void save(
     const GraphType& graph,
     const std::filesystem::path& path = "graph.gsf",
@@ -114,4 +122,5 @@ template <traits::c_graph GraphType>
     return graph;
 }
 
-} // namespace gl::io
+} // namespace io
+} // namespace gl

include/hgl/io.hpp

@@ -5,3 +5,4 @@
 #pragma once
 
 #include "hgl/io/core.hpp"
+#include "hgl/io/hypergraph_fio.hpp"

include/hgl/io/hypergraph_fio.hpp

@@ -0,0 +1,55 @@
+// Copyright (c) 2024-2026 Jakub Musiał
+// This file is part of the CPP-GL project (https://github.com/SpectraL519/cpp-gl).
+// Licensed under the MIT License. See the LICENSE file in the project root for full license information.
+
+#pragma once
+
+#include "gl/io/graph_fio.hpp"
+#include "gl/io/options.hpp"
+#include "gl/io/options_manip.hpp"
+#include "hgl/hypergraph.hpp"
+
+#include <filesystem>
+#include <fstream>
+#include <initializer_list>
+
+namespace hgl::io {
+
+using gl::io::append;
+using gl::io::write;
+
+namespace detail {
+
+using gl::io::detail::open_infile;
+using gl::io::detail::open_outfile;
+
+} // namespace detail
+
+template <traits::c_hypergraph HypergraphType, traits::c_io_save_mode Mode = write>
+void save(
+    const HypergraphType& hypergraph,
+    const std::filesystem::path& path = "hypergraph.hgsf",
+    const std::initializer_list<gl::io::options_manip>& options = {}
+) {
+    std::ofstream file = detail::open_outfile<Mode>(path);
+
+    file << gl::io::spec_fmt;
+    for (auto option : options)
+        file << option;
+
+    file << hypergraph;
+}
+
+template <traits::c_hypergraph HypergraphType>
+[[nodiscard]] HypergraphType load(const std::filesystem::path& path = "hypergraph.hgsf") {
+    std::ifstream file = detail::open_infile(path);
+
+    file >> gl::io::spec_fmt;
+
+    HypergraphType hypergraph;
+    file >> hypergraph;
+
+    return hypergraph;
+}
+
+} // namespace hgl::io

tests/include/testing/common/io.hpp

@@ -3,6 +3,7 @@
 #include "doctest.h"
 
 #include <concepts>
+#include <filesystem>
 #include <ranges>
 #include <sstream>
 #include <string_view>
@@ -23,3 +24,22 @@ struct StringMaker<R> {
 };
 
 } // namespace doctest
+
+namespace fs = std::filesystem;
+
+#define GL_REQUIRE_THROWS_FS_ERROR(expr, errc)                                                 \
+    try {                                                                                      \
+        expr;                                                                                  \
+        FAIL("Expected `std::filesystem::filesystem_error` but no exception was thrown");      \
+    }                                                                                          \
+    catch (const fs::filesystem_error& e) {                                                    \
+        const auto expected_code = std::make_error_code(errc);                                 \
+        if (e.code() != expected_code) {                                                       \
+            FAIL(std::format(                                                                  \
+                "Expected error code {}, but got {}.", expected_code.value(), e.code().value() \
+            ));                                                                                \
+        }                                                                                      \
+    }                                                                                          \
+    catch (...) {                                                                              \
+        FAIL("Expected `std::filesystem::filesystem_error` but caught a different exception"); \
+    }

tests/include/testing/gl/io_common.hpp tests/include/testing/gl/io.hpptests/include/testing/gl/io_common.hpp renamed to tests/include/testing/gl/io.hpp

@@ -0,0 +1,65 @@
+#pragma once
+
+#include "doctest.h"
+
+#include <hgl/hypergraph.hpp>
+
+#include <algorithm>
+
+namespace hgl_testing {
+
+template <hgl::traits::c_hypergraph HypergraphType>
+void verify_hypergraph_structure(const HypergraphType& actual, const HypergraphType& expected) {
+    REQUIRE_EQ(actual.order(), expected.order());
+    REQUIRE_EQ(actual.size(), expected.size());
+
+    for (const auto& he_actual : actual.hyperedges()) {
+        const auto id = he_actual.id();
+        REQUIRE(expected.has_hyperedge(id));
+
+        if constexpr (std::same_as<typename HypergraphType::directional_tag, hgl::undirected_t>) {
+            auto actual_vs = actual.incident_vertex_ids(id) | std::ranges::to<std::vector>();
+            auto expected_vs = expected.incident_vertex_ids(id) | std::ranges::to<std::vector>();
+            CHECK(std::ranges::is_permutation(actual_vs, expected_vs));
+        }
+        else if constexpr (std::same_as<
+                               typename HypergraphType::directional_tag,
+                               hgl::bf_directed_t>) {
+            auto actual_tail = actual.tail_vertex_ids(id) | std::ranges::to<std::vector>();
+            auto expected_tail = expected.tail_vertex_ids(id) | std::ranges::to<std::vector>();
+            CHECK(std::ranges::is_permutation(actual_tail, expected_tail));
+
+            auto actual_head = actual.head_vertex_ids(id) | std::ranges::to<std::vector>();
+            auto expected_head = expected.head_vertex_ids(id) | std::ranges::to<std::vector>();
+            CHECK(std::ranges::is_permutation(actual_head, expected_head));
+        }
+    }
+}
+
+template <hgl::traits::c_hypergraph HypergraphType>
+void verify_vertex_properties(const HypergraphType& actual, const HypergraphType& expected) {
+    const auto properties_proj = [](const auto& item) { return item.properties(); };
+
+    CHECK(std::ranges::equal(
+        actual.vertices(),
+        expected.vertices(),
+        std::ranges::equal_to{},
+        properties_proj,
+        properties_proj
+    ));
+}
+
+template <hgl::traits::c_hypergraph HypergraphType>
+void verify_hyperedge_properties(const HypergraphType& actual, const HypergraphType& expected) {
+    const auto properties_proj = [](const auto& item) { return item.properties(); };
+
+    CHECK(std::ranges::equal(
+        actual.hyperedges(),
+        expected.hyperedges(),
+        std::ranges::equal_to{},
+        properties_proj,
+        properties_proj
+    ));
+}
+
+} // namespace hgl_testing

tests/include/testing/hgl/io.hpp

@@ -1,6 +1,7 @@
+#include "testing/common/io.hpp"
 #include "testing/gl/constants.hpp"
 #include "testing/gl/functional.hpp"
-#include "testing/gl/io_common.hpp"
+#include "testing/gl/io.hpp"
 
 #include <gl/graph.hpp>
 #include <gl/io/graph_fio.hpp>
@@ -10,27 +11,8 @@
 
 #include <print>
 
-namespace fs = std::filesystem;
-
 namespace gl_testing {
 
-#define GL_REQUIRE_THROWS_FS_ERROR(expr, errc)                                                 \
-    try {                                                                                      \
-        expr;                                                                                  \
-        FAIL("Expected `std::filesystem::filesystem_error` but no exception was thrown");      \
-    }                                                                                          \
-    catch (const fs::filesystem_error& e) {                                                    \
-        const auto expected_code = std::make_error_code(errc);                                 \
-        if (e.code() != expected_code) {                                                       \
-            FAIL(std::format(                                                                  \
-                "Expected error code {}, but got {}.", expected_code.value(), e.code().value() \
-            ));                                                                                \
-        }                                                                                      \
-    }                                                                                          \
-    catch (...) {                                                                              \
-        FAIL("Expected `std::filesystem::filesystem_error` but caught a different exception"); \
-    }
-
 TEST_SUITE_BEGIN("test_graph_file_io");
 
 // Tests covering only the io functionality with the graph specification format enabled

tests/source/gl/test_graph_file_io.cpp

@@ -1,6 +1,6 @@
 #include "gl/io/options.hpp"
 #include "testing/gl/constants.hpp"
-#include "testing/gl/io_common.hpp"
+#include "testing/gl/io.hpp"
 
 #include <gl/graph.hpp>
 #include <gl/io.hpp>
@@ -227,7 +227,7 @@ TEST_CASE_FIXTURE(
     "io operators should properly write and read the graph from a stream with both vertex and edge "
     "properties"
 ) {
-    ss << gl::io::with_vertex_properties << gl::io::with_edge_properties << sut_out;
+    ss << gl::io::with_properties << sut_out;
     ss >> sut_in;
 
     verify_graph_structure(sut_in, sut_out);