ENH: SIMPL Backwards Compatibility Test Redesign

test/CMakeLists.txt

@@ -9,6 +9,8 @@ set(${PLUGIN_NAME}UnitTest_SRCS
     MergeColoniesTest.cpp
     ComputeLocalAverageCAxisMisalignmentsTest.cpp
     ComputeMicroTextureRegionsTest.cpp
+    ComputeSaltykovSizesTest.cpp
+    GroupMicroTextureRegionsTest.cpp
 )
 set(DISABLED_TESTS
 

test/ComputeLocalAverageCAxisMisalignmentsTest.cpp

@@ -22,15 +22,20 @@
 
 #include <catch2/catch.hpp>
 
+#include "simplnx/Core/Application.hpp"
 #include "simplnx/Parameters/ArraySelectionParameter.hpp"
 #include "simplnx/Parameters/BoolParameter.hpp"
 #include "simplnx/Parameters/DataGroupSelectionParameter.hpp"
 #include "simplnx/Parameters/StringParameter.hpp"
+#include "simplnx/Pipeline/Pipeline.hpp"
+#include "simplnx/Pipeline/PipelineFilter.hpp"
 #include "simplnx/UnitTest/UnitTestCommon.hpp"
 
 #include "SimplnxReview/Filters/ComputeLocalAverageCAxisMisalignmentsFilter.hpp"
 #include "SimplnxReview/SimplnxReview_test_dirs.hpp"
 
+#include <fstream>
+
 using namespace nx::core;
 
 TEST_CASE("SimplnxReview::ComputeLocalAverageCAxisMisalignmentsFilter: Valid Filter Execution", "[SimplnxReview][ComputeLocalAverageCAxisMisalignmentsFilter][.][UNIMPLEMENTED][!mayfail]")
@@ -65,3 +70,50 @@ TEST_CASE("SimplnxReview::ComputeLocalAverageCAxisMisalignmentsFilter: Valid Fil
 //{
 //
 // }
+
+TEST_CASE("SimplnxReview::ComputeLocalAverageCAxisMisalignmentsFilter: SIMPL Backwards Compatibility", "[SimplnxReview][ComputeLocalAverageCAxisMisalignmentsFilter][BackwardsCompatibility]")
+{
+  auto app = Application::GetOrCreateInstance();
+  UnitTest::LoadPlugins();
+  auto filterList = app->getFilterList();
+
+  const fs::path conversionDir = fs::path(nx::core::unit_test::k_SourceDir.view()) / "test" / "simpl_conversion";
+
+  const std::vector<std::pair<std::string, fs::path>> fixtures = {
+      {"SIMPL 6.5 (UUID)", conversionDir / "6_5" / "ComputeLocalAverageCAxisMisalignmentsFilter.json"},
+      {"SIMPL 6.4 (Filter_Name)", conversionDir / "6_4" / "ComputeLocalAverageCAxisMisalignmentsFilter.json"},
+  };
+
+  for(const auto& [label, fixturePath] : fixtures)
+  {
+    DYNAMIC_SECTION(label)
+    {
+      auto pipelineResult = Pipeline::FromSIMPLFile(fixturePath, filterList);
+      REQUIRE(pipelineResult.valid());
+
+      auto& pipeline = pipelineResult.value();
+      REQUIRE(pipeline.size() == 1);
+
+      auto* pipelineFilter = dynamic_cast<PipelineFilter*>(pipeline.at(0));
+      REQUIRE(pipelineFilter != nullptr);
+
+      const IFilter* filter = pipelineFilter->getFilter();
+      REQUIRE(filter != nullptr);
+      REQUIRE(filter->uuid() == FilterTraits<ComputeLocalAverageCAxisMisalignmentsFilter>::uuid);
+
+      CHECK(pipelineFilter->getComments().empty());
+
+      const Arguments args = pipelineFilter->getArguments();
+      CHECK(args.value<DataPath>(ComputeLocalAverageCAxisMisalignmentsFilter::k_AvgCAxisMisalignmentsPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+      CHECK(args.value<DataPath>(ComputeLocalAverageCAxisMisalignmentsFilter::k_CAxisMisalignmentListPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+      CHECK(args.value<bool>(ComputeLocalAverageCAxisMisalignmentsFilter::k_CalcBiasedAvg_Key) == true);
+      CHECK(args.value<bool>(ComputeLocalAverageCAxisMisalignmentsFilter::k_CalcUnbiasedAvg_Key) == true);
+      CHECK(args.value<DataPath>(ComputeLocalAverageCAxisMisalignmentsFilter::k_FeatureParentIdsPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+      CHECK(args.value<std::string>(ComputeLocalAverageCAxisMisalignmentsFilter::k_LocalCAxisMisalignmentsName_Key) == "TestName");
+      CHECK(args.value<DataPath>(ComputeLocalAverageCAxisMisalignmentsFilter::k_NeighborListPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+      CHECK(args.value<std::string>(ComputeLocalAverageCAxisMisalignmentsFilter::k_NumFeaturesPerParentName_Key) == "TestName");
+      CHECK(args.value<DataPath>(ComputeLocalAverageCAxisMisalignmentsFilter::k_NewCellFeatureAttributeMatrixPath_Key) == DataPath({"DataContainer"}));
+      CHECK(args.value<std::string>(ComputeLocalAverageCAxisMisalignmentsFilter::k_UnbiasedLocalCAxisMisalignmentsName_Key) == "TestName");
+    }
+  }
+}

test/ComputeMicroTextureRegionsTest.cpp

@@ -22,14 +22,19 @@
 
 #include <catch2/catch.hpp>
 
+#include "simplnx/Core/Application.hpp"
 #include "simplnx/Parameters/ArraySelectionParameter.hpp"
 #include "simplnx/Parameters/DataGroupSelectionParameter.hpp"
 #include "simplnx/Parameters/StringParameter.hpp"
+#include "simplnx/Pipeline/Pipeline.hpp"
+#include "simplnx/Pipeline/PipelineFilter.hpp"
 #include "simplnx/UnitTest/UnitTestCommon.hpp"
 
 #include "SimplnxReview/Filters/ComputeMicroTextureRegionsFilter.hpp"
 #include "SimplnxReview/SimplnxReview_test_dirs.hpp"
 
+#include <fstream>
+
 using namespace nx::core;
 
 TEST_CASE("SimplnxReview::ComputeMicroTextureRegionsFilter: Valid Filter Execution", "[SimplnxReview][ComputeMicroTextureRegionsFilter][.][UNIMPLEMENTED][!mayfail]")
@@ -58,3 +63,44 @@ TEST_CASE("SimplnxReview::ComputeMicroTextureRegionsFilter: Valid Filter Executi
 //{
 //
 // }
+
+TEST_CASE("SimplnxReview::ComputeMicroTextureRegionsFilter: SIMPL Backwards Compatibility", "[SimplnxReview][ComputeMicroTextureRegionsFilter][BackwardsCompatibility]")
+{
+  auto app = Application::GetOrCreateInstance();
+  UnitTest::LoadPlugins();
+  auto filterList = app->getFilterList();
+
+  const fs::path conversionDir = fs::path(nx::core::unit_test::k_SourceDir.view()) / "test" / "simpl_conversion";
+
+  const std::vector<std::pair<std::string, fs::path>> fixtures = {
+      {"SIMPL 6.5 (UUID)", conversionDir / "6_5" / "ComputeMicroTextureRegionsFilter.json"},
+      {"SIMPL 6.4 (Filter_Name)", conversionDir / "6_4" / "ComputeMicroTextureRegionsFilter.json"},
+  };
+
+  for(const auto& [label, fixturePath] : fixtures)
+  {
+    DYNAMIC_SECTION(label)
+    {
+      auto pipelineResult = Pipeline::FromSIMPLFile(fixturePath, filterList);
+      REQUIRE(pipelineResult.valid());
+
+      auto& pipeline = pipelineResult.value();
+      REQUIRE(pipeline.size() == 1);
+
+      auto* pipelineFilter = dynamic_cast<PipelineFilter*>(pipeline.at(0));
+      REQUIRE(pipelineFilter != nullptr);
+
+      const IFilter* filter = pipelineFilter->getFilter();
+      REQUIRE(filter != nullptr);
+      REQUIRE(filter->uuid() == FilterTraits<ComputeMicroTextureRegionsFilter>::uuid);
+
+      CHECK(pipelineFilter->getComments().empty());
+
+      const Arguments args = pipelineFilter->getArguments();
+      CHECK(args.value<DataPath>(ComputeMicroTextureRegionsFilter::k_CellFeatureAttributeMatrixPath_Key) == DataPath({"DataContainer"}));
+      CHECK(args.value<std::string>(ComputeMicroTextureRegionsFilter::k_MicroTextureRegionFractionOccupiedArrayName_Key) == "TestName");
+      CHECK(args.value<std::string>(ComputeMicroTextureRegionsFilter::k_MicroTextureRegionNumCellsArrayName_Key) == "TestName");
+      CHECK(args.value<DataPath>(ComputeMicroTextureRegionsFilter::k_FeatureIdsArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+    }
+  }
+}

test/ComputeSaltykovSizesTest.cpp

@@ -0,0 +1,52 @@
+#include <catch2/catch.hpp>
+
+#include "simplnx/Core/Application.hpp"
+#include "simplnx/Pipeline/Pipeline.hpp"
+#include "simplnx/Pipeline/PipelineFilter.hpp"
+#include "simplnx/UnitTest/UnitTestCommon.hpp"
+
+#include "SimplnxReview/Filters/ComputeSaltykovSizesFilter.hpp"
+#include "SimplnxReview/SimplnxReview_test_dirs.hpp"
+
+#include <fstream>
+
+using namespace nx::core;
+
+TEST_CASE("SimplnxReview::ComputeSaltykovSizesFilter: SIMPL Backwards Compatibility", "[SimplnxReview][ComputeSaltykovSizesFilter][BackwardsCompatibility]")
+{
+  auto app = Application::GetOrCreateInstance();
+  UnitTest::LoadPlugins();
+  auto filterList = app->getFilterList();
+
+  const fs::path conversionDir = fs::path(nx::core::unit_test::k_SourceDir.view()) / "test" / "simpl_conversion";
+
+  const std::vector<std::pair<std::string, fs::path>> fixtures = {
+      {"SIMPL 6.5 (UUID)", conversionDir / "6_5" / "ComputeSaltykovSizesFilter.json"},
+      {"SIMPL 6.4 (Filter_Name)", conversionDir / "6_4" / "ComputeSaltykovSizesFilter.json"},
+  };
+
+  for(const auto& [label, fixturePath] : fixtures)
+  {
+    DYNAMIC_SECTION(label)
+    {
+      auto pipelineResult = Pipeline::FromSIMPLFile(fixturePath, filterList);
+      REQUIRE(pipelineResult.valid());
+
+      auto& pipeline = pipelineResult.value();
+      REQUIRE(pipeline.size() == 1);
+
+      auto* pipelineFilter = dynamic_cast<PipelineFilter*>(pipeline.at(0));
+      REQUIRE(pipelineFilter != nullptr);
+
+      const IFilter* filter = pipelineFilter->getFilter();
+      REQUIRE(filter != nullptr);
+      REQUIRE(filter->uuid() == FilterTraits<ComputeSaltykovSizesFilter>::uuid);
+
+      CHECK(pipelineFilter->getComments().empty());
+
+      const Arguments args = pipelineFilter->getArguments();
+      CHECK(args.value<DataPath>(ComputeSaltykovSizesFilter::k_EquivalentDiametersArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+      CHECK(args.value<std::string>(ComputeSaltykovSizesFilter::k_SaltykovEquivalentDiametersName_Key) == "TestArray");
+    }
+  }
+}

test/GroupMicroTextureRegionsTest.cpp

@@ -22,14 +22,20 @@
 
 #include <catch2/catch.hpp>
 
+#include "simplnx/Core/Application.hpp"
 #include "simplnx/Parameters/ArraySelectionParameter.hpp"
 #include "simplnx/Parameters/BoolParameter.hpp"
 #include "simplnx/Parameters/NumberParameter.hpp"
 #include "simplnx/Parameters/StringParameter.hpp"
+#include "simplnx/Pipeline/Pipeline.hpp"
+#include "simplnx/Pipeline/PipelineFilter.hpp"
+#include "simplnx/UnitTest/UnitTestCommon.hpp"
 
 #include "SimplnxReview/Filters/GroupMicroTextureRegionsFilter.hpp"
 #include "SimplnxReview/SimplnxReview_test_dirs.hpp"
 
+#include <fstream>
+
 using namespace nx::core;
 
 TEST_CASE("SimplnxReview::GroupMicroTextureRegionsFilter: Valid Filter Execution", "[OrientationAnalysis][GroupMicroTextureRegionsFilter][.][UNIMPLEMENTED][!mayfail]")
@@ -68,3 +74,54 @@ TEST_CASE("SimplnxReview::GroupMicroTextureRegionsFilter: Valid Filter Execution
 //{
 //
 // }
+
+TEST_CASE("SimplnxReview::GroupMicroTextureRegionsFilter: SIMPL Backwards Compatibility", "[SimplnxReview][GroupMicroTextureRegionsFilter][BackwardsCompatibility]")
+{
+  auto app = Application::GetOrCreateInstance();
+  UnitTest::LoadPlugins();
+  auto filterList = app->getFilterList();
+
+  const fs::path conversionDir = fs::path(nx::core::unit_test::k_SourceDir.view()) / "test" / "simpl_conversion";
+
+  const std::vector<std::pair<std::string, fs::path>> fixtures = {
+      {"SIMPL 6.5 (UUID)", conversionDir / "6_5" / "GroupMicroTextureRegionsFilter.json"},
+      {"SIMPL 6.4 (Filter_Name)", conversionDir / "6_4" / "GroupMicroTextureRegionsFilter.json"},
+  };
+
+  for(const auto& [label, fixturePath] : fixtures)
+  {
+    DYNAMIC_SECTION(label)
+    {
+      auto pipelineResult = Pipeline::FromSIMPLFile(fixturePath, filterList);
+      REQUIRE(pipelineResult.valid());
+
+      auto& pipeline = pipelineResult.value();
+      REQUIRE(pipeline.size() == 1);
+
+      auto* pipelineFilter = dynamic_cast<PipelineFilter*>(pipeline.at(0));
+      REQUIRE(pipelineFilter != nullptr);
+
+      const IFilter* filter = pipelineFilter->getFilter();
+      REQUIRE(filter != nullptr);
+      REQUIRE(filter->uuid() == FilterTraits<GroupMicroTextureRegionsFilter>::uuid);
+
+      CHECK(pipelineFilter->getComments().empty());
+
+      const Arguments args = pipelineFilter->getArguments();
+      CHECK(args.value<std::string>(GroupMicroTextureRegionsFilter::k_ActiveArrayName_Key) == "TestName");
+      CHECK(args.value<DataPath>(GroupMicroTextureRegionsFilter::k_AvgQuatsArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+      CHECK(args.value<float32>(GroupMicroTextureRegionsFilter::k_CAxisTolerance_Key) == 2.5f);
+      CHECK(args.value<std::string>(GroupMicroTextureRegionsFilter::k_CellParentIdsArrayName_Key) == "TestName");
+      CHECK(args.value<DataPath>(GroupMicroTextureRegionsFilter::k_ContiguousNeighborListArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+      CHECK(args.value<DataPath>(GroupMicroTextureRegionsFilter::k_CrystalStructuresArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+      CHECK(args.value<DataPath>(GroupMicroTextureRegionsFilter::k_FeatureIdsArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+      CHECK(args.value<std::string>(GroupMicroTextureRegionsFilter::k_FeatureParentIdsArrayName_Key) == "TestName");
+      CHECK(args.value<DataPath>(GroupMicroTextureRegionsFilter::k_FeaturePhasesArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+      CHECK(args.value<DataPath>(GroupMicroTextureRegionsFilter::k_NewCellFeatureAttributeMatrixName_Key) == DataPath({"TestName"}));
+      CHECK(args.value<DataPath>(GroupMicroTextureRegionsFilter::k_NonContiguousNeighborListArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+      CHECK(args.value<bool>(GroupMicroTextureRegionsFilter::k_UseNonContiguousNeighbors_Key) == true);
+      CHECK(args.value<bool>(GroupMicroTextureRegionsFilter::k_UseRunningAverage_Key) == true);
+      CHECK(args.value<DataPath>(GroupMicroTextureRegionsFilter::k_VolumesArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+    }
+  }
+}

test/MergeColoniesTest.cpp

@@ -1,13 +1,18 @@
 #include <catch2/catch.hpp>
 
+#include "simplnx/Core/Application.hpp"
 #include "simplnx/Parameters/ArrayCreationParameter.hpp"
 #include "simplnx/Parameters/BoolParameter.hpp"
 #include "simplnx/Parameters/DataObjectNameParameter.hpp"
+#include "simplnx/Pipeline/Pipeline.hpp"
+#include "simplnx/Pipeline/PipelineFilter.hpp"
 #include "simplnx/UnitTest/UnitTestCommon.hpp"
 
 #include "SimplnxReview/Filters/MergeColoniesFilter.hpp"
 #include "SimplnxReview/SimplnxReview_test_dirs.hpp"
 
+#include <fstream>
+
 using namespace nx::core;
 
 TEST_CASE("SimplnxReview::MergeColoniesFilter: Valid Filter Execution", "[SimplnxReview][MergeColoniesFilter]")
@@ -33,3 +38,55 @@ TEST_CASE("SimplnxReview::MergeColoniesFilter: Valid Filter Execution", "[Simpln
   args.insertOrAssign(MergeColoniesFilter::k_FeatureParentIdsArrayName_Key, std::make_any<DataObjectNameParameter::ValueType>(""));
   args.insertOrAssign(MergeColoniesFilter::k_ActiveArrayName_Key, std::make_any<DataObjectNameParameter::ValueType>(""));
 }
+
+TEST_CASE("SimplnxReview::MergeColoniesFilter: SIMPL Backwards Compatibility", "[SimplnxReview][MergeColoniesFilter][BackwardsCompatibility]")
+{
+  auto app = Application::GetOrCreateInstance();
+  UnitTest::LoadPlugins();
+  auto filterList = app->getFilterList();
+
+  const fs::path conversionDir = fs::path(nx::core::unit_test::k_SourceDir.view()) / "test" / "simpl_conversion";
+
+  const std::vector<std::pair<std::string, fs::path>> fixtures = {
+      {"SIMPL 6.5 (UUID)", conversionDir / "6_5" / "MergeColoniesFilter.json"},
+      {"SIMPL 6.4 (Filter_Name)", conversionDir / "6_4" / "MergeColoniesFilter.json"},
+  };
+
+  for(const auto& [label, fixturePath] : fixtures)
+  {
+    DYNAMIC_SECTION(label)
+    {
+      auto pipelineResult = Pipeline::FromSIMPLFile(fixturePath, filterList);
+      REQUIRE(pipelineResult.valid());
+
+      auto& pipeline = pipelineResult.value();
+      REQUIRE(pipeline.size() == 1);
+
+      auto* pipelineFilter = dynamic_cast<PipelineFilter*>(pipeline.at(0));
+      REQUIRE(pipelineFilter != nullptr);
+
+      const IFilter* filter = pipelineFilter->getFilter();
+      REQUIRE(filter != nullptr);
+      REQUIRE(filter->uuid() == FilterTraits<MergeColoniesFilter>::uuid);
+
+      CHECK(pipelineFilter->getComments().empty());
+
+      const Arguments args = pipelineFilter->getArguments();
+      CHECK(args.value<std::string>(MergeColoniesFilter::k_ActiveArrayName_Key) == "TestName");
+      CHECK(args.value<float32>(MergeColoniesFilter::k_AngleTolerance_Key) == 2.5f);
+      CHECK(args.value<DataPath>(MergeColoniesFilter::k_AvgQuatsArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+      CHECK(args.value<float32>(MergeColoniesFilter::k_AxisTolerance_Key) == 2.5f);
+      CHECK(args.value<std::string>(MergeColoniesFilter::k_CellParentIdsArrayName_Key) == "TestName");
+      CHECK(args.value<DataPath>(MergeColoniesFilter::k_CellPhasesArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+      CHECK(args.value<DataPath>(MergeColoniesFilter::k_ContiguousNeighborListArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+      CHECK(args.value<DataPath>(MergeColoniesFilter::k_CrystalStructuresArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+      CHECK(args.value<DataPath>(MergeColoniesFilter::k_FeatureIdsArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+      CHECK(args.value<std::string>(MergeColoniesFilter::k_FeatureParentIdsArrayName_Key) == "TestName");
+      CHECK(args.value<DataPath>(MergeColoniesFilter::k_FeaturePhasesArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+      // AMPathBuilderFilterParameterConverter - verified by successful pipeline loading
+      CHECK(args.value<DataPath>(MergeColoniesFilter::k_NewCellFeatureAttributeMatrixName_Key) == DataPath({"DataContainer", "TestName"}));
+      CHECK(args.value<DataPath>(MergeColoniesFilter::k_NonContiguousNeighborListArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"}));
+      CHECK(args.value<bool>(MergeColoniesFilter::k_UseNonContiguousNeighbors_Key) == true);
+    }
+  }
+}

test/simpl_conversion/6_4/ComputeLocalAverageCAxisMisalignmentsFilter.json

@@ -0,0 +1,40 @@
+{
+  "PipelineBuilder": {
+    "Name": "Compute Local Average C-Axis Misalignments 6.4 Backwards Compatibility Test",
+    "Number_Filters": 1,
+    "Version": 6
+  },
+  "0": {
+    "Filter_Enabled": true,
+    "Filter_Human_Label": "Find Local Average C-Axis Misalignments",
+    "Filter_Name": "FindLocalAverageCAxisMisalignments",
+    "AvgCAxisMisalignmentsArrayPath": {
+      "Data Container Name": "DataContainer",
+      "Attribute Matrix Name": "CellData",
+      "Data Array Name": "TestArray"
+    },
+    "CAxisMisalignmentListArrayPath": {
+      "Data Container Name": "DataContainer",
+      "Attribute Matrix Name": "CellData",
+      "Data Array Name": "TestArray"
+    },
+    "CalcBiasedAvg": 1,
+    "CalcUnbiasedAvg": 1,
+    "FeatureParentIdsArrayPath": {
+      "Data Container Name": "DataContainer",
+      "Attribute Matrix Name": "CellData",
+      "Data Array Name": "TestArray"
+    },
+    "LocalCAxisMisalignmentsArrayName": "TestName",
+    "NeighborListArrayPath": {
+      "Data Container Name": "DataContainer",
+      "Attribute Matrix Name": "CellData",
+      "Data Array Name": "TestArray"
+    },
+    "NumFeaturesPerParentArrayName": "TestName",
+    "NewCellFeatureAttributeMatrixName": {
+      "Data Container Name": "DataContainer"
+    },
+    "UnbiasedLocalCAxisMisalignmentsArrayName": "TestName"
+  }
+}