Feature/deserialized api tests

power_grid_model_c/power_grid_model_cpp/include/power_grid_model_cpp/dataset.hpp

@@ -11,6 +11,7 @@
 #include "handle.hpp"
 
 #include "power_grid_model_c/dataset.h"
+
 namespace power_grid_model_cpp {
 
 class DatasetInfo {
@@ -43,6 +44,16 @@ class DatasetInfo {
         return handle_.call_with(PGM_dataset_info_total_elements, info_, component_idx);
     }
 
+    Idx component_idx(std::string_view component) const {
+        Idx const n_comp = n_components();
+        for (Idx idx = 0; idx < n_comp; ++idx) {
+            if (component_name(idx) == component) {
+                return idx;
+            }
+        }
+        return -1;
+    }
+
   private:
     Handle handle_{};
     RawDatasetInfo const* info_;
@@ -171,6 +182,21 @@ class DatasetConst {
     detail::UniquePtr<RawConstDataset, &PGM_destroy_dataset_const> dataset_;
     DatasetInfo info_;
 };
+
+struct OwningMemory {
+    std::vector<Buffer> buffers;
+    std::vector<std::vector<Idx>> indptrs;
+};
+
+struct OwningDatasetMutable {
+    DatasetMutable dataset;
+    OwningMemory storage{};
+};
+
+struct OwningDatasetConst {
+    DatasetConst dataset;
+    OwningMemory storage{};
+};
 } // namespace power_grid_model_cpp
 
 #endif // POWER_GRID_MODEL_CPP_DATASET_HPP

power_grid_model_c/power_grid_model_cpp/include/power_grid_model_cpp/serialization.hpp

@@ -9,6 +9,7 @@
 #include "basics.hpp"
 #include "dataset.hpp"
 #include "handle.hpp"
+#include "meta_data.hpp"
 
 #include "power_grid_model_c/serialization.h"
 
@@ -90,6 +91,34 @@ class Serializer {
     power_grid_model_cpp::Handle handle_{};
     detail::UniquePtr<RawSerializer, &PGM_destroy_serializer> serializer_;
 };
+
+inline OwningDatasetConst create_owning_dataset(DatasetWritable& writable_dataset) {
+    auto const& info = writable_dataset.get_info();
+    bool const is_batch = info.is_batch();
+    Idx const batch_size = info.batch_size();
+    auto const& dataset_name = info.name();
+    DatasetMutable dataset_mutable{dataset_name, is_batch, batch_size};
+    DatasetConst dataset_const{dataset_mutable};
+    OwningMemory storage{};
+
+    for (Idx component_idx{}; component_idx < info.n_components(); ++component_idx) {
+        auto const& component_name = info.component_name(component_idx);
+        auto const& component_meta = MetaData::get_component_by_name(dataset_name, component_name);
+        Idx const component_elements_per_scenario = info.component_elements_per_scenario(component_idx);
+        Idx const component_size = info.component_total_elements(component_idx);
+
+        auto& current_indptr =
+            storage.indptrs.emplace_back(info.component_elements_per_scenario(component_idx) < 0 ? batch_size + 1 : 0);
+        if (!current_indptr.empty()) {
+            current_indptr.at(0) = 0;
+            current_indptr.at(batch_size) = component_size;
+        }
+        Idx* const indptr = current_indptr.empty() ? nullptr : current_indptr.data();
+        auto& current_buffer = storage.buffers.emplace_back(component_meta, component_size);
+        writable_dataset.set_buffer(component_name, indptr, current_buffer);
+    }
+    return OwningDatasetConst{.dataset = writable_dataset, .storage = std::move(storage)};
+}
 } // namespace power_grid_model_cpp
 
 #endif // POWER_GRID_MODEL_CPP_SERIALIZATION_HPP

tests/cpp_unit_tests/test_math_solver_common.hpp

@@ -4,6 +4,10 @@
 
 // In this unit test the powerflow solvers are tested
 
+#pragma once
+#ifndef POWER_GRID_MODEL_TESTS_CPP_UNIT_TESTS_TEST_MATH_SOLVER_COMMON_HPP
+#define POWER_GRID_MODEL_TESTS_CPP_UNIT_TESTS_TEST_MATH_SOLVER_COMMON_HPP
+
 #include <power_grid_model/calculation_parameters.hpp>
 #include <power_grid_model/common/exception.hpp>
 #include <power_grid_model/common/three_phase_tensor.hpp>
@@ -265,3 +269,5 @@ template <symmetry_tag sym_type> struct SteadyStateSolverTestGrid {
 };
 
 } // namespace power_grid_model
+
+#endif // POWER_GRID_MODEL_TESTS_CPP_UNIT_TESTS_TEST_MATH_SOLVER_COMMON_HPP

tests/cpp_unit_tests/test_math_solver_pf.hpp

@@ -4,6 +4,10 @@
 
 // In this unit test the powerflow solvers are tested
 
+#pragma once
+#ifndef POWER_GRID_MODEL_TESTS_CPP_UNIT_TESTS_TEST_MATH_SOLVER_PF_HPP
+#define POWER_GRID_MODEL_TESTS_CPP_UNIT_TESTS_TEST_MATH_SOLVER_PF_HPP
+
 #include "test_math_solver_common.hpp"
 
 #include <power_grid_model/common/calculation_info.hpp>
@@ -142,3 +146,5 @@ TEST_CASE_TEMPLATE_DEFINE("Test math solver - PF", SolverType, test_math_solver_
 }
 
 } // namespace power_grid_model
+
+#endif // POWER_GRID_MODEL_TESTS_CPP_UNIT_TESTS_TEST_MATH_SOLVER_PF_HPP

tests/cpp_unit_tests/test_math_solver_se.hpp

@@ -4,6 +4,10 @@
 
 // In this unit test the powerflow solvers are tested
 
+#pragma once
+#ifndef POWER_GRID_MODEL_TESTS_CPP_UNIT_TESTS_TEST_MATH_SOLVER_SE_HPP
+#define POWER_GRID_MODEL_TESTS_CPP_UNIT_TESTS_TEST_MATH_SOLVER_SE_HPP
+
 #include "test_math_solver_common.hpp"
 
 #include <power_grid_model/common/calculation_info.hpp>
@@ -516,3 +520,5 @@ TEST_CASE_TEMPLATE_DEFINE("Test math solver - SE, measurements", SolverType, tes
 }
 
 } // namespace power_grid_model
+
+#endif // POWER_GRID_MODEL_TESTS_CPP_UNIT_TESTS_TEST_MATH_SOLVER_SE_HPP

tests/cpp_unit_tests/test_optimizer.hpp

@@ -2,6 +2,10 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
+#pragma once
+#ifndef POWER_GRID_MODEL_TESTS_CPP_UNIT_TESTS_TEST_OPTIMIZER_HPP
+#define POWER_GRID_MODEL_TESTS_CPP_UNIT_TESTS_TEST_OPTIMIZER_HPP
+
 #include <power_grid_model/auxiliary/meta_data.hpp>
 #include <power_grid_model/auxiliary/meta_gen/gen_getters.hpp>
 #include <power_grid_model/container.hpp>
@@ -246,3 +250,5 @@ template <> struct get_attributes_list<optimizer::test::StubTransformerUpdate> {
 };
 } // namespace meta_data
 } // namespace power_grid_model
+
+#endif // POWER_GRID_MODEL_TESTS_CPP_UNIT_TESTS_TEST_OPTIMIZER_HPP

tests/cpp_validation_tests/test_validation.cpp

@@ -4,7 +4,7 @@
 
 #define PGM_ENABLE_EXPERIMENTAL
 
-#include "power_grid_model_cpp.hpp"
+#include <power_grid_model_cpp.hpp>
 
 #include <doctest/doctest.h>
 #include <nlohmann/json.hpp>
@@ -60,75 +60,29 @@ auto read_json(std::filesystem::path const& path) {
     return j;
 }
 
-struct OwningMemory {
-    std::vector<Buffer> buffers;
-    std::vector<std::vector<Idx>> indptrs;
-};
-
-struct OwningDataset {
-    std::optional<DatasetMutable> dataset;
-    std::optional<DatasetConst> const_dataset;
-    OwningMemory storage{};
-};
+OwningDatasetMutable create_result_dataset(OwningDatasetConst const& input, std::string const& dataset_name,
+                                           bool is_batch = false, Idx batch_size = 1) {
+    DatasetInfo const& input_info = input.dataset.get_info();
 
-OwningDataset create_owning_dataset(DatasetWritable& writable_dataset) {
-    auto const& info = writable_dataset.get_info();
-    bool const is_batch = info.is_batch();
-    Idx const batch_size = info.batch_size();
-    auto const& dataset_name = info.name();
-    OwningDataset owning_dataset{.dataset{DatasetMutable{dataset_name, is_batch, batch_size}},
-                                 .const_dataset = std::nullopt};
-
-    for (Idx component_idx{}; component_idx < info.n_components(); ++component_idx) {
-        auto const& component_name = info.component_name(component_idx);
-        auto const& component_meta = MetaData::get_component_by_name(dataset_name, component_name);
-        Idx const component_elements_per_scenario = info.component_elements_per_scenario(component_idx);
-        Idx const component_size = info.component_total_elements(component_idx);
-
-        auto& current_indptr = owning_dataset.storage.indptrs.emplace_back(
-            info.component_elements_per_scenario(component_idx) < 0 ? batch_size + 1 : 0);
-        if (!current_indptr.empty()) {
-            current_indptr.at(0) = 0;
-            current_indptr.at(batch_size) = component_size;
-        }
-        Idx* const indptr = current_indptr.empty() ? nullptr : current_indptr.data();
-        auto& current_buffer = owning_dataset.storage.buffers.emplace_back(component_meta, component_size);
-        writable_dataset.set_buffer(component_name, indptr, current_buffer);
-        owning_dataset.dataset.value().add_buffer(component_name, component_elements_per_scenario, component_size,
-                                                  indptr, current_buffer);
-    }
-    owning_dataset.const_dataset = writable_dataset;
-    return owning_dataset;
-}
-
-OwningDataset create_result_dataset(OwningDataset const& input, std::string const& dataset_name, bool is_batch = false,
-                                    Idx batch_size = 1) {
-    OwningDataset owning_dataset{.dataset{DatasetMutable{dataset_name, is_batch, batch_size}},
-                                 .const_dataset = std::nullopt};
-
-    if (!input.const_dataset.has_value()) {
-        throw OptionalNotInitialized("DatasetConst");
-    }
-    DatasetInfo const& input_info = input.const_dataset.value().get_info();
+    OwningDatasetMutable result{.dataset{dataset_name, is_batch, batch_size}, .storage{}};
 
     for (Idx component_idx{}; component_idx != input_info.n_components(); ++component_idx) {
         auto const& component_name = input_info.component_name(component_idx);
         auto const& component_meta = MetaData::get_component_by_name(dataset_name, component_name);
         Idx const component_elements_per_scenario = input_info.component_elements_per_scenario(component_idx);
         Idx const component_size = input_info.component_total_elements(component_idx);
 
-        auto& current_indptr = owning_dataset.storage.indptrs.emplace_back(
+        auto& current_indptr = result.storage.indptrs.emplace_back(
             input_info.component_elements_per_scenario(component_idx) < 0 ? batch_size + 1 : 0);
         Idx const* const indptr = current_indptr.empty() ? nullptr : current_indptr.data();
-        auto& current_buffer = owning_dataset.storage.buffers.emplace_back(component_meta, component_size);
-        owning_dataset.dataset.value().add_buffer(component_name, component_elements_per_scenario, component_size,
-                                                  indptr, current_buffer);
+        auto& current_buffer = result.storage.buffers.emplace_back(component_meta, component_size);
+        result.dataset.add_buffer(component_name, component_elements_per_scenario, component_size, indptr,
+                                  current_buffer);
     }
-    owning_dataset.const_dataset = owning_dataset.dataset.value();
-    return owning_dataset;
+    return result;
 }
 
-OwningDataset load_dataset(std::filesystem::path const& path) {
+OwningDatasetConst load_dataset(std::filesystem::path const& path) {
 // Issue in msgpack, reported in https://github.com/msgpack/msgpack-c/issues/1098
 // May be a Clang Analyzer bug
 #ifndef __clang_analyzer__ // TODO(mgovers): re-enable this when issue in msgpack is fixed
@@ -255,23 +209,17 @@ void check_individual_attribute(Buffer const& buffer, Buffer const& ref_buffer,
     }
 }
 
-void assert_result(OwningDataset const& owning_result, OwningDataset const& owning_reference_result,
+void assert_result(OwningDatasetMutable const& owning_result, OwningDatasetConst const& owning_reference_result,
                    std::map<std::string, double, std::less<>> atol, double rtol) {
     using namespace std::string_literals;
 
-    if (!owning_result.const_dataset.has_value()) {
-        throw OptionalNotInitialized("DatasetConst");
-    }
-    DatasetConst const& result = owning_result.const_dataset.value();
+    DatasetConst const result{owning_result.dataset};
     auto const& result_info = result.get_info();
     auto const& result_name = result_info.name();
     Idx const result_batch_size = result_info.batch_size();
     auto const& storage = owning_result.storage;
 
-    if (!owning_reference_result.const_dataset.has_value()) {
-        throw OptionalNotInitialized("DatasetConst");
-    }
-    DatasetConst const& reference_result = owning_reference_result.const_dataset.value();
+    DatasetConst const& reference_result = owning_reference_result.dataset;
     auto const& reference_result_info = reference_result.get_info();
     auto const& reference_result_name = reference_result_info.name();
     auto const& reference_storage = owning_reference_result.storage;
@@ -490,10 +438,10 @@ void add_cases(std::filesystem::path const& case_dir, std::string const& calcula
 // test case with parameter
 struct ValidationCase {
     CaseParam param;
-    OwningDataset input;
-    std::optional<OwningDataset> output;
-    std::optional<OwningDataset> update_batch;
-    std::optional<OwningDataset> output_batch;
+    OwningDatasetConst input;
+    std::optional<OwningDatasetConst> output;
+    std::optional<OwningDatasetConst> update_batch;
+    std::optional<OwningDatasetConst> output_batch;
 };
 
 ValidationCase create_validation_case(CaseParam const& param, std::string const& output_type) {
@@ -574,8 +522,8 @@ void validate_single_case(CaseParam const& param) {
 
         // create and run model
         auto const& options = get_options(param);
-        Model model{50.0, validation_case.input.const_dataset.value()};
-        model.calculate(options, result.dataset.value());
+        Model model{50.0, validation_case.input.dataset};
+        model.calculate(options, result.dataset);
 
         // check results
         assert_result(result, validation_case.output.value(), param.atol, param.rtol);
@@ -586,21 +534,20 @@ void validate_batch_case(CaseParam const& param) {
     execute_test(param, [&]() {
         auto const output_prefix = get_output_type(param.calculation_type, param.sym);
         auto const validation_case = create_validation_case(param, output_prefix);
-        auto const& info = validation_case.update_batch.value().const_dataset.value().get_info();
+        auto const& info = validation_case.update_batch.value().dataset.get_info();
         Idx const batch_size = info.batch_size();
         auto const batch_result =
             create_result_dataset(validation_case.output_batch.value(), output_prefix, true, batch_size);
 
         // create model
-        Model model{50.0, validation_case.input.const_dataset.value()};
+        Model model{50.0, validation_case.input.dataset};
 
         // check results after whole update is finished
         for (Idx const threading : {-1, 0, 1, 2}) {
             CAPTURE(threading);
             // set options and run
             auto const& options = get_options(param, threading);
-            model.calculate(options, batch_result.dataset.value(),
-                            validation_case.update_batch.value().const_dataset.value());
+            model.calculate(options, batch_result.dataset, validation_case.update_batch.value().dataset);
 
             // check results
             assert_result(batch_result, validation_case.output_batch.value(), param.atol, param.rtol);

tests/native_api_tests/load_dataset.hpp

@@ -0,0 +1,21 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <[email protected]>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+#ifndef POWER_GRID_MODEL_TESTS_NATIVE_API_TESTS_LOAD_DATASET_HPP
+#define POWER_GRID_MODEL_TESTS_NATIVE_API_TESTS_LOAD_DATASET_HPP
+
+#include <power_grid_model_cpp/serialization.hpp>
+
+namespace power_grid_model_cpp_test {
+inline power_grid_model_cpp::OwningDatasetConst load_dataset(std::string const& json_string) {
+    power_grid_model_cpp::Deserializer deserializer{json_string, PGM_json};
+    auto& writable_dataset = deserializer.get_dataset();
+    auto owning_dataset = power_grid_model_cpp::create_owning_dataset(writable_dataset);
+    deserializer.parse_to_buffer();
+    return owning_dataset;
+}
+} // namespace power_grid_model_cpp_test
+
+#endif // POWER_GRID_MODEL_TESTS_NATIVE_API_TESTS_LOAD_DATASET_HPP