WIP: Add tests for reflection table

Author: dimitrivlachos

tests/CMakeLists.txt

@@ -8,8 +8,12 @@ target_link_libraries(test_read_h5_array GTest::gtest_main dx2 hdf5::hdf5)
 add_executable(test_write_h5_array test_write_h5_array.cxx)
 target_link_libraries(test_write_h5_array GTest::gtest_main dx2 hdf5::hdf5)
 
+add_executable(test_reflection_table test_reflection_table.cxx)
+target_link_libraries(test_reflection_table GTest::gtest_main dx2)
+
 include(GoogleTest)
 
 gtest_discover_tests(test_crystal PROPERTIES LABELS dx2tests)
 gtest_discover_tests(test_read_h5_array WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/tests" PROPERTIES LABELS dx2tests)
 gtest_discover_tests(test_write_h5_array WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/tests" PROPERTIES LABELS dx2tests)
+gtest_discover_tests(test_reflection_table WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/tests" PROPERTIES LABELS dx2tests)

tests/test_reflection_table.cxx

@@ -0,0 +1,166 @@
+#include <dx2/reflection.hpp>
+#include <filesystem>
+#include <gtest/gtest.h>
+#include <iostream>
+#include <optional>
+#include <string>
+#include <vector>
+
+/*
+ * Test fixture for ReflectionTable tests. This fixture sets up the test
+ * environment for the ReflectionTable class and provides a common path
+ * to the test file.
+ */
+class ReflectionTableTest : public ::testing::Test {
+protected:
+  std::filesystem::path test_file_path;
+
+  void SetUp() override {
+    test_file_path = std::filesystem::current_path() / "data/cut_strong.refl";
+  }
+};
+
+TEST_F(ReflectionTableTest, LoadsAllColumns) {
+  ReflectionTable table(test_file_path.string());
+
+  auto names = table.get_column_names();
+  std::cout << "Loaded column names:\n";
+  for (const auto &name : names) {
+    std::cout << "  - " << name << "\n";
+  }
+
+  EXPECT_FALSE(names.empty());
+  EXPECT_NE(std::find(names.begin(), names.end(), "xyzobs.px.value"),
+            names.end());
+}
+
+TEST_F(ReflectionTableTest, TryGetColumnSucceedsOnCorrectType) {
+  ReflectionTable table(test_file_path.string());
+
+  auto px = table.get_column<double>("xyzobs.px.value");
+  ASSERT_TRUE(px.has_value());
+
+  const auto &span = px.value();
+  std::cout << "xyzobs.px.value shape: " << span.extent(0) << "x"
+            << span.extent(1) << "\n";
+  EXPECT_EQ(span.extent(1), 3);
+  EXPECT_GT(span.extent(0), 0);
+}
+
+TEST_F(ReflectionTableTest, TryGetColumnFailsOnWrongType) {
+  ReflectionTable table(test_file_path.string());
+
+  auto col = table.get_column<int>("xyzobs.px.value");
+  std::cout << "Column retrieval (int): "
+            << (col.has_value() ? "found" : "not found") << "\n";
+  EXPECT_FALSE(col.has_value());
+}
+
+TEST_F(ReflectionTableTest, SelectSubsetUsingFindRows) {
+  ReflectionTable table(test_file_path.string());
+
+  auto px = table.get_column<double>("xyzobs.px.value");
+  ASSERT_TRUE(px);
+
+  const auto &span = px.value();
+
+  auto selected = table.find_rows([&](size_t i) {
+    return span(i, 2) > 1.0; // z > 1.0
+  });
+
+  std::cout << "Selected " << selected.size() << " rows where z > 1.0\n";
+  EXPECT_FALSE(selected.empty());
+
+  auto filtered = table.select(selected);
+  auto filtered_px = filtered.get_column<double>("xyzobs.px.value");
+  ASSERT_TRUE(filtered_px);
+  const auto &filtered_span = filtered_px.value();
+
+  for (size_t i = 0; i < std::min<size_t>(filtered_span.extent(0), 5); ++i) {
+    std::cout << "z[" << i << "] = " << filtered_span(i, 2) << "\n";
+  }
+
+  for (size_t i = 0; i < filtered_span.extent(0); ++i) {
+    EXPECT_GT(filtered_span(i, 2), 1.0);
+  }
+}
+
+TEST_F(ReflectionTableTest, SelectWithMaskReturnsSameResultAsExplicitIndices) {
+  ReflectionTable table(test_file_path.string());
+
+  auto px = table.get_column<double>("xyzobs.px.value");
+  ASSERT_TRUE(px);
+  const auto &span = px.value();
+
+  std::vector<bool> mask(span.extent(0), false);
+  std::vector<size_t> indices;
+
+  for (size_t i = 0; i < span.extent(0); ++i) {
+    if (span(i, 2) > 1.0) {
+      mask[i] = true;
+      indices.push_back(i);
+    }
+  }
+
+  std::cout << "Mask selected " << indices.size() << " rows\n";
+
+  auto table_from_mask = table.select(mask);
+  auto table_from_indices = table.select(indices);
+
+  auto mask_span =
+      table_from_mask.get_column<double>("xyzobs.px.value").value();
+  auto idx_span =
+      table_from_indices.get_column<double>("xyzobs.px.value").value();
+
+  ASSERT_EQ(mask_span.extent(0), idx_span.extent(0));
+  ASSERT_EQ(mask_span.extent(1), idx_span.extent(1));
+
+  for (size_t i = 0; i < std::min<size_t>(mask_span.extent(0), 3); ++i) {
+    std::cout << "Row " << i << ": "
+              << "mask_z = " << mask_span(i, 2)
+              << ", idx_z = " << idx_span(i, 2) << "\n";
+  }
+
+  for (size_t i = 0; i < mask_span.extent(0); ++i) {
+    for (size_t j = 0; j < mask_span.extent(1); ++j) {
+      EXPECT_EQ(mask_span(i, j), idx_span(i, j));
+    }
+  }
+}
+
+TEST_F(ReflectionTableTest, SelectEmptyReturnsEmptyTable) {
+  ReflectionTable table(test_file_path.string());
+  ReflectionTable empty = table.select(std::vector<size_t>{});
+
+  std::cout << "Selecting with empty row set...\n";
+  for (const auto &name : table.get_column_names()) {
+    auto span = empty.get_column<double>(name);
+    if (span) {
+      std::cout << "  " << name << " has " << span->extent(0) << " rows\n";
+      EXPECT_EQ(span.value().extent(0), 0);
+    }
+  }
+}
+
+TEST_F(ReflectionTableTest, AllDatasetsLoadSuccessfully) {
+  ReflectionTable table(test_file_path.string());
+
+  std::vector<std::string> expected = get_datasets_in_group(
+      test_file_path.string(), "/dials/processing/group_0");
+
+  std::vector<std::string> loaded = table.get_column_names();
+
+  for (const std::string &full_dataset_path : expected) {
+    std::string name = get_dataset_name(full_dataset_path);
+
+    // Make sure it's present
+    auto it = std::find(loaded.begin(), loaded.end(), name);
+    EXPECT_NE(it, loaded.end()) << "Dataset not loaded: " << name;
+
+    if (it != loaded.end()) {
+      std::cout << "✅ Dataset loaded: " << name << "\n";
+    } else {
+      std::cerr << "❌ Dataset missing: " << name << "\n";
+    }
+  }
+}