From a7a53358c2b4a1709c5e78a7a73e264d7a070e3c Mon Sep 17 00:00:00 2001 From: Michael Jackson Date: Thu, 16 Apr 2026 11:52:09 -0400 Subject: [PATCH] ENH: SIMPL Backwards Compatibility Test Redesign MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The original backwards compatibility test was a single 1,100-line monolithic test file (BackwardsCompatibilityTest.cpp) that validated SIMPL 6.5/6.6 pipeline conversion for all filters at once. It relied on two large hand-maintained data structures: - k_ParamMap (~500 lines) — a global map of parameter type UUIDs to expected exemplar values, with custom std::any comparator lambdas for each parameter type - k_KeyIgnoreMap (~180 lines) — a manual list of NX-only parameter keys per filter that the test had to skip The core maintenance problem: whenever a developer added a new parameter to any filter, they had to also update k_KeyIgnoreMap with that parameter's key, or the centralized test would fail. This was unintuitive, error-prone, and completely disconnected from the filter being changed. The ignore list grew with every filter enhancement and provided no signal about what it was actually protecting. --- test/CMakeLists.txt | 2 + ...puteLocalAverageCAxisMisalignmentsTest.cpp | 52 +++++++++++++++++ test/ComputeMicroTextureRegionsTest.cpp | 46 +++++++++++++++ test/ComputeSaltykovSizesTest.cpp | 52 +++++++++++++++++ test/GroupMicroTextureRegionsTest.cpp | 57 +++++++++++++++++++ test/MergeColoniesTest.cpp | 57 +++++++++++++++++++ ...eLocalAverageCAxisMisalignmentsFilter.json | 40 +++++++++++++ .../6_4/ComputeMicroTextureRegionsFilter.json | 22 +++++++ .../6_4/ComputeSaltykovSizesFilter.json | 22 +++++++ .../6_4/GroupMicroTextureRegionsFilter.json | 54 ++++++++++++++++++ .../6_4/MergeColoniesFilter.json | 54 ++++++++++++++++++ ...eLocalAverageCAxisMisalignmentsFilter.json | 41 +++++++++++++ .../6_5/ComputeMicroTextureRegionsFilter.json | 23 ++++++++ .../6_5/ComputeSaltykovSizesFilter.json | 23 ++++++++ .../6_5/GroupMicroTextureRegionsFilter.json | 55 ++++++++++++++++++ .../6_5/MergeColoniesFilter.json | 55 ++++++++++++++++++ 16 files changed, 655 insertions(+) create mode 100644 test/ComputeSaltykovSizesTest.cpp create mode 100644 test/simpl_conversion/6_4/ComputeLocalAverageCAxisMisalignmentsFilter.json create mode 100644 test/simpl_conversion/6_4/ComputeMicroTextureRegionsFilter.json create mode 100644 test/simpl_conversion/6_4/ComputeSaltykovSizesFilter.json create mode 100644 test/simpl_conversion/6_4/GroupMicroTextureRegionsFilter.json create mode 100644 test/simpl_conversion/6_4/MergeColoniesFilter.json create mode 100644 test/simpl_conversion/6_5/ComputeLocalAverageCAxisMisalignmentsFilter.json create mode 100644 test/simpl_conversion/6_5/ComputeMicroTextureRegionsFilter.json create mode 100644 test/simpl_conversion/6_5/ComputeSaltykovSizesFilter.json create mode 100644 test/simpl_conversion/6_5/GroupMicroTextureRegionsFilter.json create mode 100644 test/simpl_conversion/6_5/MergeColoniesFilter.json diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 7811af1..3ed7925 100644 --- a/test/CMakeLists.txt +++ b/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 diff --git a/test/ComputeLocalAverageCAxisMisalignmentsTest.cpp b/test/ComputeLocalAverageCAxisMisalignmentsTest.cpp index 79a5d90..63cd450 100644 --- a/test/ComputeLocalAverageCAxisMisalignmentsTest.cpp +++ b/test/ComputeLocalAverageCAxisMisalignmentsTest.cpp @@ -22,15 +22,20 @@ #include +#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 + 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> 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(pipeline.at(0)); + REQUIRE(pipelineFilter != nullptr); + + const IFilter* filter = pipelineFilter->getFilter(); + REQUIRE(filter != nullptr); + REQUIRE(filter->uuid() == FilterTraits::uuid); + + CHECK(pipelineFilter->getComments().empty()); + + const Arguments args = pipelineFilter->getArguments(); + CHECK(args.value(ComputeLocalAverageCAxisMisalignmentsFilter::k_AvgCAxisMisalignmentsPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + CHECK(args.value(ComputeLocalAverageCAxisMisalignmentsFilter::k_CAxisMisalignmentListPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + CHECK(args.value(ComputeLocalAverageCAxisMisalignmentsFilter::k_CalcBiasedAvg_Key) == true); + CHECK(args.value(ComputeLocalAverageCAxisMisalignmentsFilter::k_CalcUnbiasedAvg_Key) == true); + CHECK(args.value(ComputeLocalAverageCAxisMisalignmentsFilter::k_FeatureParentIdsPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + CHECK(args.value(ComputeLocalAverageCAxisMisalignmentsFilter::k_LocalCAxisMisalignmentsName_Key) == "TestName"); + CHECK(args.value(ComputeLocalAverageCAxisMisalignmentsFilter::k_NeighborListPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + CHECK(args.value(ComputeLocalAverageCAxisMisalignmentsFilter::k_NumFeaturesPerParentName_Key) == "TestName"); + CHECK(args.value(ComputeLocalAverageCAxisMisalignmentsFilter::k_NewCellFeatureAttributeMatrixPath_Key) == DataPath({"DataContainer"})); + CHECK(args.value(ComputeLocalAverageCAxisMisalignmentsFilter::k_UnbiasedLocalCAxisMisalignmentsName_Key) == "TestName"); + } + } +} diff --git a/test/ComputeMicroTextureRegionsTest.cpp b/test/ComputeMicroTextureRegionsTest.cpp index 5633ae7..714288e 100644 --- a/test/ComputeMicroTextureRegionsTest.cpp +++ b/test/ComputeMicroTextureRegionsTest.cpp @@ -22,14 +22,19 @@ #include +#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 + 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> 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(pipeline.at(0)); + REQUIRE(pipelineFilter != nullptr); + + const IFilter* filter = pipelineFilter->getFilter(); + REQUIRE(filter != nullptr); + REQUIRE(filter->uuid() == FilterTraits::uuid); + + CHECK(pipelineFilter->getComments().empty()); + + const Arguments args = pipelineFilter->getArguments(); + CHECK(args.value(ComputeMicroTextureRegionsFilter::k_CellFeatureAttributeMatrixPath_Key) == DataPath({"DataContainer"})); + CHECK(args.value(ComputeMicroTextureRegionsFilter::k_MicroTextureRegionFractionOccupiedArrayName_Key) == "TestName"); + CHECK(args.value(ComputeMicroTextureRegionsFilter::k_MicroTextureRegionNumCellsArrayName_Key) == "TestName"); + CHECK(args.value(ComputeMicroTextureRegionsFilter::k_FeatureIdsArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + } + } +} diff --git a/test/ComputeSaltykovSizesTest.cpp b/test/ComputeSaltykovSizesTest.cpp new file mode 100644 index 0000000..a0a5b36 --- /dev/null +++ b/test/ComputeSaltykovSizesTest.cpp @@ -0,0 +1,52 @@ +#include + +#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 + +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> 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(pipeline.at(0)); + REQUIRE(pipelineFilter != nullptr); + + const IFilter* filter = pipelineFilter->getFilter(); + REQUIRE(filter != nullptr); + REQUIRE(filter->uuid() == FilterTraits::uuid); + + CHECK(pipelineFilter->getComments().empty()); + + const Arguments args = pipelineFilter->getArguments(); + CHECK(args.value(ComputeSaltykovSizesFilter::k_EquivalentDiametersArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + CHECK(args.value(ComputeSaltykovSizesFilter::k_SaltykovEquivalentDiametersName_Key) == "TestArray"); + } + } +} diff --git a/test/GroupMicroTextureRegionsTest.cpp b/test/GroupMicroTextureRegionsTest.cpp index 6438d54..c82fb86 100644 --- a/test/GroupMicroTextureRegionsTest.cpp +++ b/test/GroupMicroTextureRegionsTest.cpp @@ -22,14 +22,20 @@ #include +#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 + 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> 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(pipeline.at(0)); + REQUIRE(pipelineFilter != nullptr); + + const IFilter* filter = pipelineFilter->getFilter(); + REQUIRE(filter != nullptr); + REQUIRE(filter->uuid() == FilterTraits::uuid); + + CHECK(pipelineFilter->getComments().empty()); + + const Arguments args = pipelineFilter->getArguments(); + CHECK(args.value(GroupMicroTextureRegionsFilter::k_ActiveArrayName_Key) == "TestName"); + CHECK(args.value(GroupMicroTextureRegionsFilter::k_AvgQuatsArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + CHECK(args.value(GroupMicroTextureRegionsFilter::k_CAxisTolerance_Key) == 2.5f); + CHECK(args.value(GroupMicroTextureRegionsFilter::k_CellParentIdsArrayName_Key) == "TestName"); + CHECK(args.value(GroupMicroTextureRegionsFilter::k_ContiguousNeighborListArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + CHECK(args.value(GroupMicroTextureRegionsFilter::k_CrystalStructuresArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + CHECK(args.value(GroupMicroTextureRegionsFilter::k_FeatureIdsArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + CHECK(args.value(GroupMicroTextureRegionsFilter::k_FeatureParentIdsArrayName_Key) == "TestName"); + CHECK(args.value(GroupMicroTextureRegionsFilter::k_FeaturePhasesArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + CHECK(args.value(GroupMicroTextureRegionsFilter::k_NewCellFeatureAttributeMatrixName_Key) == DataPath({"TestName"})); + CHECK(args.value(GroupMicroTextureRegionsFilter::k_NonContiguousNeighborListArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + CHECK(args.value(GroupMicroTextureRegionsFilter::k_UseNonContiguousNeighbors_Key) == true); + CHECK(args.value(GroupMicroTextureRegionsFilter::k_UseRunningAverage_Key) == true); + CHECK(args.value(GroupMicroTextureRegionsFilter::k_VolumesArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + } + } +} diff --git a/test/MergeColoniesTest.cpp b/test/MergeColoniesTest.cpp index aadaf22..9f54d06 100644 --- a/test/MergeColoniesTest.cpp +++ b/test/MergeColoniesTest.cpp @@ -1,13 +1,18 @@ #include +#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 + 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("")); args.insertOrAssign(MergeColoniesFilter::k_ActiveArrayName_Key, std::make_any("")); } + +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> 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(pipeline.at(0)); + REQUIRE(pipelineFilter != nullptr); + + const IFilter* filter = pipelineFilter->getFilter(); + REQUIRE(filter != nullptr); + REQUIRE(filter->uuid() == FilterTraits::uuid); + + CHECK(pipelineFilter->getComments().empty()); + + const Arguments args = pipelineFilter->getArguments(); + CHECK(args.value(MergeColoniesFilter::k_ActiveArrayName_Key) == "TestName"); + CHECK(args.value(MergeColoniesFilter::k_AngleTolerance_Key) == 2.5f); + CHECK(args.value(MergeColoniesFilter::k_AvgQuatsArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + CHECK(args.value(MergeColoniesFilter::k_AxisTolerance_Key) == 2.5f); + CHECK(args.value(MergeColoniesFilter::k_CellParentIdsArrayName_Key) == "TestName"); + CHECK(args.value(MergeColoniesFilter::k_CellPhasesArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + CHECK(args.value(MergeColoniesFilter::k_ContiguousNeighborListArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + CHECK(args.value(MergeColoniesFilter::k_CrystalStructuresArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + CHECK(args.value(MergeColoniesFilter::k_FeatureIdsArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + CHECK(args.value(MergeColoniesFilter::k_FeatureParentIdsArrayName_Key) == "TestName"); + CHECK(args.value(MergeColoniesFilter::k_FeaturePhasesArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + // AMPathBuilderFilterParameterConverter - verified by successful pipeline loading + CHECK(args.value(MergeColoniesFilter::k_NewCellFeatureAttributeMatrixName_Key) == DataPath({"DataContainer", "TestName"})); + CHECK(args.value(MergeColoniesFilter::k_NonContiguousNeighborListArrayPath_Key) == DataPath({"DataContainer", "CellData", "TestArray"})); + CHECK(args.value(MergeColoniesFilter::k_UseNonContiguousNeighbors_Key) == true); + } + } +} diff --git a/test/simpl_conversion/6_4/ComputeLocalAverageCAxisMisalignmentsFilter.json b/test/simpl_conversion/6_4/ComputeLocalAverageCAxisMisalignmentsFilter.json new file mode 100644 index 0000000..826caf0 --- /dev/null +++ b/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" + } +} diff --git a/test/simpl_conversion/6_4/ComputeMicroTextureRegionsFilter.json b/test/simpl_conversion/6_4/ComputeMicroTextureRegionsFilter.json new file mode 100644 index 0000000..02a97e2 --- /dev/null +++ b/test/simpl_conversion/6_4/ComputeMicroTextureRegionsFilter.json @@ -0,0 +1,22 @@ +{ + "PipelineBuilder": { + "Name": "Compute Micro Texture Regions 6.4 Backwards Compatibility Test", + "Number_Filters": 1, + "Version": 6 + }, + "0": { + "Filter_Enabled": true, + "Filter_Human_Label": "Find MicroTexture Regions", + "Filter_Name": "FindMicroTextureRegions", + "CellFeatureAttributeMatrixName": { + "Data Container Name": "DataContainer" + }, + "MicroTextureRegionFractionOccupiedArrayName": "TestName", + "MicroTextureRegionNumCellsArrayName": "TestName", + "FeatureIdsArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + } + } +} diff --git a/test/simpl_conversion/6_4/ComputeSaltykovSizesFilter.json b/test/simpl_conversion/6_4/ComputeSaltykovSizesFilter.json new file mode 100644 index 0000000..49d50fc --- /dev/null +++ b/test/simpl_conversion/6_4/ComputeSaltykovSizesFilter.json @@ -0,0 +1,22 @@ +{ + "PipelineBuilder": { + "Name": "Compute Saltykov Sizes 6.4 Backwards Compatibility Test", + "Number_Filters": 1, + "Version": 6 + }, + "0": { + "Filter_Enabled": true, + "Filter_Human_Label": "Find Saltykov Sizes", + "Filter_Name": "FindSaltykovSizes", + "EquivalentDiametersArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "SaltykovEquivalentDiametersArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + } + } +} diff --git a/test/simpl_conversion/6_4/GroupMicroTextureRegionsFilter.json b/test/simpl_conversion/6_4/GroupMicroTextureRegionsFilter.json new file mode 100644 index 0000000..e9a2f5e --- /dev/null +++ b/test/simpl_conversion/6_4/GroupMicroTextureRegionsFilter.json @@ -0,0 +1,54 @@ +{ + "PipelineBuilder": { + "Name": "Group Micro Texture Regions 6.4 Backwards Compatibility Test", + "Number_Filters": 1, + "Version": 6 + }, + "0": { + "Filter_Enabled": true, + "Filter_Human_Label": "Group MicroTexture Regions", + "Filter_Name": "GroupMicroTextureRegions", + "ActiveArrayName": "TestName", + "AvgQuatsArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "CAxisTolerance": 2.5, + "CellParentIdsArrayName": "TestName", + "ContiguousNeighborListArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "CrystalStructuresArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "FeatureIdsArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "FeatureParentIdsArrayName": "TestName", + "FeaturePhasesArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "NewCellFeatureAttributeMatrixName": "TestName", + "NonContiguousNeighborListArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "UseNonContiguousNeighbors": 1, + "UseRunningAverage": 1, + "VolumesArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + } + } +} diff --git a/test/simpl_conversion/6_4/MergeColoniesFilter.json b/test/simpl_conversion/6_4/MergeColoniesFilter.json new file mode 100644 index 0000000..310318a --- /dev/null +++ b/test/simpl_conversion/6_4/MergeColoniesFilter.json @@ -0,0 +1,54 @@ +{ + "PipelineBuilder": { + "Name": "Merge Colonies 6.4 Backwards Compatibility Test", + "Number_Filters": 1, + "Version": 6 + }, + "0": { + "Filter_Enabled": true, + "Filter_Human_Label": "Merge Colonies", + "Filter_Name": "MergeColonies", + "ActiveArrayName": "TestName", + "AngleTolerance": 2.5, + "AvgQuatsArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "AxisTolerance": 2.5, + "CellParentIdsArrayName": "TestName", + "CellPhasesArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "ContiguousNeighborListArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "CrystalStructuresArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "FeatureIdsArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "FeatureParentIdsArrayName": "TestName", + "FeaturePhasesArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "NewCellFeatureAttributeMatrixName": "TestName", + "NonContiguousNeighborListArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "UseNonContiguousNeighbors": 1 + } +} diff --git a/test/simpl_conversion/6_5/ComputeLocalAverageCAxisMisalignmentsFilter.json b/test/simpl_conversion/6_5/ComputeLocalAverageCAxisMisalignmentsFilter.json new file mode 100644 index 0000000..480323f --- /dev/null +++ b/test/simpl_conversion/6_5/ComputeLocalAverageCAxisMisalignmentsFilter.json @@ -0,0 +1,41 @@ +{ + "PipelineBuilder": { + "Name": "Compute Local Average C-Axis Misalignments Backwards Compatibility Test", + "Number_Filters": 1, + "Version": 6 + }, + "0": { + "Filter_Enabled": true, + "Filter_Human_Label": "Find Local Average C-Axis Misalignments", + "Filter_Name": "FindLocalAverageCAxisMisalignments", + "Filter_Uuid": "{49b2dd47-bb29-50d4-a051-5bad9b6b9f80}", + "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" + } +} diff --git a/test/simpl_conversion/6_5/ComputeMicroTextureRegionsFilter.json b/test/simpl_conversion/6_5/ComputeMicroTextureRegionsFilter.json new file mode 100644 index 0000000..7fd8bee --- /dev/null +++ b/test/simpl_conversion/6_5/ComputeMicroTextureRegionsFilter.json @@ -0,0 +1,23 @@ +{ + "PipelineBuilder": { + "Name": "Compute Micro Texture Regions Backwards Compatibility Test", + "Number_Filters": 1, + "Version": 6 + }, + "0": { + "Filter_Enabled": true, + "Filter_Human_Label": "Find MicroTexture Regions", + "Filter_Name": "FindMicroTextureRegions", + "Filter_Uuid": "{90f8e3b1-2460-5862-95a1-a9e06f5ee75e}", + "CellFeatureAttributeMatrixName": { + "Data Container Name": "DataContainer" + }, + "MicroTextureRegionFractionOccupiedArrayName": "TestName", + "MicroTextureRegionNumCellsArrayName": "TestName", + "FeatureIdsArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + } + } +} diff --git a/test/simpl_conversion/6_5/ComputeSaltykovSizesFilter.json b/test/simpl_conversion/6_5/ComputeSaltykovSizesFilter.json new file mode 100644 index 0000000..cb24842 --- /dev/null +++ b/test/simpl_conversion/6_5/ComputeSaltykovSizesFilter.json @@ -0,0 +1,23 @@ +{ + "PipelineBuilder": { + "Name": "Compute Saltykov Sizes Backwards Compatibility Test", + "Number_Filters": 1, + "Version": 6 + }, + "0": { + "Filter_Enabled": true, + "Filter_Human_Label": "Find Saltykov Sizes", + "Filter_Name": "FindSaltykovSizes", + "Filter_Uuid": "{cc76cffe-81ad-5ece-be2a-ce127c5fa6d7}", + "EquivalentDiametersArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "SaltykovEquivalentDiametersArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + } + } +} diff --git a/test/simpl_conversion/6_5/GroupMicroTextureRegionsFilter.json b/test/simpl_conversion/6_5/GroupMicroTextureRegionsFilter.json new file mode 100644 index 0000000..6fa40c7 --- /dev/null +++ b/test/simpl_conversion/6_5/GroupMicroTextureRegionsFilter.json @@ -0,0 +1,55 @@ +{ + "PipelineBuilder": { + "Name": "Group Micro Texture Regions Backwards Compatibility Test", + "Number_Filters": 1, + "Version": 6 + }, + "0": { + "Filter_Enabled": true, + "Filter_Human_Label": "Group MicroTexture Regions", + "Filter_Name": "GroupMicroTextureRegions", + "Filter_Uuid": "{5e18a9e2-e342-56ac-a54e-3bd0ca8b9c53}", + "ActiveArrayName": "TestName", + "AvgQuatsArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "CAxisTolerance": 2.5, + "CellParentIdsArrayName": "TestName", + "ContiguousNeighborListArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "CrystalStructuresArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "FeatureIdsArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "FeatureParentIdsArrayName": "TestName", + "FeaturePhasesArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "NewCellFeatureAttributeMatrixName": "TestName", + "NonContiguousNeighborListArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "UseNonContiguousNeighbors": 1, + "UseRunningAverage": 1, + "VolumesArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + } + } +} diff --git a/test/simpl_conversion/6_5/MergeColoniesFilter.json b/test/simpl_conversion/6_5/MergeColoniesFilter.json new file mode 100644 index 0000000..dcfc62c --- /dev/null +++ b/test/simpl_conversion/6_5/MergeColoniesFilter.json @@ -0,0 +1,55 @@ +{ + "PipelineBuilder": { + "Name": "Merge Colonies Backwards Compatibility Test", + "Number_Filters": 1, + "Version": 6 + }, + "0": { + "Filter_Enabled": true, + "Filter_Human_Label": "Merge Colonies", + "Filter_Name": "MergeColonies", + "Filter_Uuid": "{2c4a6d83-6a1b-56d8-9f65-9453b28845b9}", + "ActiveArrayName": "TestName", + "AngleTolerance": 2.5, + "AvgQuatsArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "AxisTolerance": 2.5, + "CellParentIdsArrayName": "TestName", + "CellPhasesArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "ContiguousNeighborListArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "CrystalStructuresArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "FeatureIdsArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "FeatureParentIdsArrayName": "TestName", + "FeaturePhasesArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "NewCellFeatureAttributeMatrixName": "TestName", + "NonContiguousNeighborListArrayPath": { + "Data Container Name": "DataContainer", + "Attribute Matrix Name": "CellData", + "Data Array Name": "TestArray" + }, + "UseNonContiguousNeighbors": 1 + } +}