Skip to content

Commit 53abeef

Browse files
nyoungbqimikejackson
nyoungbq
authored and
imikejackson
committed
- Clean up extraneous preflight checks that were preformed by parameters
- Add a test case to test a real world dataset against 6.5 output - Cleaned up test namespace - merged old test case file into new test file
1 parent d49f623 commit 53abeef

3 files changed

Lines changed: 101 additions & 115 deletions

File tree

‎src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/BadDataNeighborOrientationCheckFilter.cpp‎

Lines changed: 3 additions & 88 deletions
Original file line numberDiff line numberDiff line change
@@ -1,26 +1,18 @@
11
#include "BadDataNeighborOrientationCheckFilter.hpp"
22
#include "OrientationAnalysis/Filters/Algorithms/BadDataNeighborOrientationCheck.hpp"
33

4-
#include "simplnx/DataStructure/DataArray.hpp"
54
#include "simplnx/DataStructure/DataPath.hpp"
65
#include "simplnx/DataStructure/Geometry/ImageGeom.hpp"
76
#include "simplnx/Parameters/ArraySelectionParameter.hpp"
87
#include "simplnx/Parameters/DataGroupSelectionParameter.hpp"
98
#include "simplnx/Parameters/GeometrySelectionParameter.hpp"
10-
11-
#include "simplnx/Utilities/SIMPLConversion.hpp"
12-
139
#include "simplnx/Parameters/NumberParameter.hpp"
14-
#include "simplnx/Utilities/FilterUtilities.hpp"
10+
#include "simplnx/Utilities/SIMPLConversion.hpp"
1511

1612
using namespace nx::core;
1713

1814
namespace
1915
{
20-
constexpr int32 k_MissingGeomError = -6800;
21-
constexpr int32 k_MissingInputArray = -6801;
22-
constexpr int32 k_IncorrectInputArray = -6802;
23-
constexpr int32 k_InvalidNumTuples = -6803;
2416
constexpr int32 k_InconsistentTupleCount = -6809;
2517
} // namespace
2618

@@ -100,106 +92,29 @@ IFilter::UniquePointer BadDataNeighborOrientationCheckFilter::clone() const
10092
IFilter::PreflightResult BadDataNeighborOrientationCheckFilter::preflightImpl(const DataStructure& dataStructure, const Arguments& filterArgs, const MessageHandler& messageHandler,
10193
const std::atomic_bool& shouldCancel, const ExecutionContext& executionContext) const
10294
{
103-
auto pMisorientationToleranceValue = filterArgs.value<float32>(k_MisorientationTolerance_Key);
104-
auto pNumberOfNeighborsValue = filterArgs.value<int32>(k_NumberOfNeighbors_Key);
105-
auto pImageGeomPathValue = filterArgs.value<DataPath>(k_ImageGeometryPath_Key);
10695
auto pQuatsArrayPathValue = filterArgs.value<DataPath>(k_QuatsArrayPath_Key);
10796
auto pGoodVoxelsArrayPathValue = filterArgs.value<DataPath>(k_MaskArrayPath_Key);
10897
auto pCellPhasesArrayPathValue = filterArgs.value<DataPath>(k_CellPhasesArrayPath_Key);
109-
auto pCrystalStructuresArrayPathValue = filterArgs.value<DataPath>(k_CrystalStructuresArrayPath_Key);
11098

11199
nx::core::Result<OutputActions> resultOutputActions;
112100

113-
std::vector<PreflightValue> preflightUpdatedValues;
114-
115101
std::vector<DataPath> dataArrayPaths;
116-
117-
auto* imageGeomPtr = dataStructure.getDataAs<ImageGeom>(pImageGeomPathValue);
118-
if(imageGeomPtr == nullptr)
119-
{
120-
return {MakeErrorResult<OutputActions>(k_MissingGeomError, fmt::format("Could not find input image geometry at path '{}'", pImageGeomPathValue.toString()))};
121-
}
122-
123-
// Validate the mask array
124-
auto* goodVoxelsPtr = dataStructure.getDataAs<IDataArray>(pGoodVoxelsArrayPathValue);
125-
if(nullptr == goodVoxelsPtr)
126-
{
127-
return {MakeErrorResult<OutputActions>(k_MissingInputArray, fmt::format("Could not find mask array at path '{}'", pGoodVoxelsArrayPathValue.toString()))};
128-
}
129-
130-
auto* goodVoxelsBoolPtr = dataStructure.getDataAs<IDataArray>(pGoodVoxelsArrayPathValue);
131-
if(goodVoxelsBoolPtr->getNumberOfComponents() != 1)
132-
{
133-
return {MakeErrorResult<OutputActions>(k_IncorrectInputArray, "Mask Input Array must be a 1 component array")};
134-
}
135102
dataArrayPaths.push_back(pGoodVoxelsArrayPathValue);
136-
137-
// validate the cell phases array
138-
auto* cellPhasesPtr = dataStructure.getDataAs<IDataArray>(pCellPhasesArrayPathValue);
139-
if(nullptr == cellPhasesPtr)
140-
{
141-
return {MakeErrorResult<OutputActions>(k_MissingInputArray, fmt::format("Could not find cell phases array at path '{}'", pCellPhasesArrayPathValue.toString()))};
142-
}
143-
auto* cellPhasesInt32Ptr = dataStructure.getDataAs<Int32Array>(pCellPhasesArrayPathValue);
144-
if(nullptr == cellPhasesInt32Ptr)
145-
{
146-
return {nonstd::make_unexpected(
147-
std::vector<Error>{Error{k_IncorrectInputArray, fmt::format("Cell phases array at path '{}' is not of the correct type. It must be Int32.", pCellPhasesArrayPathValue.toString())}})};
148-
}
149-
if(cellPhasesInt32Ptr->getNumberOfComponents() != 1)
150-
{
151-
return {MakeErrorResult<OutputActions>(k_IncorrectInputArray, "Cell phases Input Array must be a 1 component Int32 array")};
152-
}
153103
dataArrayPaths.push_back(pCellPhasesArrayPathValue);
154-
155-
// validate the crystal structures array
156-
auto* crystalStructuresPtr = dataStructure.getDataAs<IDataArray>(pCrystalStructuresArrayPathValue);
157-
if(nullptr == crystalStructuresPtr)
158-
{
159-
return {MakeErrorResult<OutputActions>(k_MissingInputArray, fmt::format("Could not find crystal structures array at path '{}'", pCrystalStructuresArrayPathValue.toString()))};
160-
}
161-
auto* crystalStructuresUInt32Ptr = dataStructure.getDataAs<UInt32Array>(pCrystalStructuresArrayPathValue);
162-
if(nullptr == crystalStructuresUInt32Ptr)
163-
{
164-
return {nonstd::make_unexpected(
165-
std::vector<Error>{Error{k_IncorrectInputArray, fmt::format("Crystal structures array at path '{}' is not of the correct type. It must be UInt32.", pCellPhasesArrayPathValue.toString())}})};
166-
}
167-
if(crystalStructuresUInt32Ptr->getNumberOfComponents() != 1)
168-
{
169-
return {MakeErrorResult<OutputActions>(k_IncorrectInputArray, "Crystal structures Input Array must be a 1 component UInt32 array")};
170-
}
171-
172-
// validate the quaternions array
173-
auto* quatsPtr = dataStructure.getDataAs<IDataArray>(pQuatsArrayPathValue);
174-
if(nullptr == quatsPtr)
175-
{
176-
return {MakeErrorResult<OutputActions>(k_MissingInputArray, fmt::format("Could not find quaternions array at path '{}'", pQuatsArrayPathValue.toString()))};
177-
}
178-
auto* quatsFloat32Ptr = dataStructure.getDataAs<Float32Array>(pQuatsArrayPathValue);
179-
if(nullptr == quatsFloat32Ptr)
180-
{
181-
return {nonstd::make_unexpected(
182-
std::vector<Error>{Error{k_IncorrectInputArray, fmt::format("Quaternions array at path '{}' is not of the correct type. It must be Float32.", pCellPhasesArrayPathValue.toString())}})};
183-
}
184-
if(quatsFloat32Ptr->getNumberOfComponents() != 4)
185-
{
186-
return {MakeErrorResult<OutputActions>(k_IncorrectInputArray, "Quaternion Input Array must be a 4 component Float32 array")};
187-
}
188104
dataArrayPaths.push_back(pQuatsArrayPathValue);
189105

190106
// validate the number of tuples
191107
auto tupleValidityCheck = dataStructure.validateNumberOfTuples(dataArrayPaths);
192108
if(!tupleValidityCheck)
193109
{
194-
return {MakeErrorResult<OutputActions>(k_InconsistentTupleCount,
195-
fmt::format("The following DataArrays all must have equal number of tuples but this was not satisfied.\n{}", tupleValidityCheck.error()))};
110+
return MakePreflightErrorResult(k_InconsistentTupleCount, fmt::format("The following DataArrays all must have equal number of tuples but this was not satisfied.\n{}", tupleValidityCheck.error()));
196111
}
197112

198113
resultOutputActions.value().modifiedActions.emplace_back(
199114
DataObjectModification{pGoodVoxelsArrayPathValue, DataObjectModification::ModifiedType::Modified, dataStructure.getData(pGoodVoxelsArrayPathValue)->getDataObjectType()});
200115

201116
// Return both the resultOutputActions and the preflightUpdatedValues via std::move()
202-
return {std::move(resultOutputActions), std::move(preflightUpdatedValues)};
117+
return {std::move(resultOutputActions)};
203118
}
204119

205120
//------------------------------------------------------------------------------

‎src/Plugins/OrientationAnalysis/test/BadDataNeighborOrientationCheckTest.cpp‎

Lines changed: 97 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -13,8 +13,27 @@
1313

1414
namespace fs = std::filesystem;
1515
using namespace nx::core;
16-
using namespace nx::core::Constants;
17-
using namespace nx::core::UnitTest;
16+
17+
namespace VerificationConstants
18+
{
19+
const std::string k_ImageName = "6_5_ImageDataContainer";
20+
const DataPath k_ImagePath = DataPath({k_ImageName});
21+
22+
const DataPath k_CellDataPath = k_ImagePath.createChildPath(Constants::k_CellData);
23+
const DataPath k_CellEnsembleDataPath = k_ImagePath.createChildPath(Constants::k_CellEnsembleData);
24+
25+
// Cell Data
26+
const std::string k_QuatsName = "Quats";
27+
const DataPath k_QuatsArrayPath = k_CellDataPath.createChildPath(k_QuatsName);
28+
const std::string k_MaskName = "Mask";
29+
const DataPath k_MaskArrayPath = k_CellDataPath.createChildPath(k_MaskName);
30+
const std::string k_PhasesName = "Phases";
31+
const DataPath k_PhasesArrayPath = k_CellDataPath.createChildPath(k_PhasesName);
32+
33+
const std::string k_CStuctsName = "CrystalStructures";
34+
const DataPath k_CStuctsArrayPath = k_CellEnsembleDataPath.createChildPath(k_CStuctsName);
35+
} // namespace VerificationConstants
36+
1837
/**
1938
* Read H5Ebsd File
2039
* MultiThreshold Objects
@@ -35,21 +54,21 @@ using namespace nx::core::UnitTest;
3554
TEST_CASE("OrientationAnalysis::BadDataNeighborOrientationCheckFilter: Small IN100 Pipeline", "[OrientationAnalysis][BadDataNeighborOrientationCheckFilter]")
3655
{
3756
UnitTest::LoadPlugins();
38-
const nx::core::UnitTest::TestFileSentinel testDataSentinel(nx::core::unit_test::k_CMakeExecutable, nx::core::unit_test::k_TestFilesDir, "bad_data_neighbor_orientation_check.tar.gz",
39-
"bad_data_neighbor_orientation_check.dream3d");
57+
const nx::core::UnitTest::TestFileSentinel testDataSentinel(nx::core::unit_test::k_CMakeExecutable, nx::core::unit_test::k_TestFilesDir, "BadDataNeighborOrientationCheck.tar.gz",
58+
"BadDataNeighborOrientationCheck");
4059

4160
const nx::core::UnitTest::TestFileSentinel testDataSentinel1(nx::core::unit_test::k_CMakeExecutable, nx::core::unit_test::k_TestFilesDir, "Small_IN100_dream3d_v3.tar.gz", "Small_IN100.dream3d");
4261

4362
UnitTest::LoadPlugins();
4463
auto* filterList = Application::Instance()->getFilterList();
4564

4665
// Read Exemplar DREAM3D File Filter
47-
auto exemplarFilePath = fs::path(fmt::format("{}/bad_data_neighbor_orientation_check.dream3d", unit_test::k_TestFilesDir));
48-
DataStructure exemplarDataStructure = LoadDataStructure(exemplarFilePath);
66+
auto exemplarFilePath = fs::path(fmt::format("{}/BadDataNeighborOrientationCheck/original_test_data/bad_data_neighbor_orientation_check.dream3d", unit_test::k_TestFilesDir));
67+
DataStructure exemplarDataStructure = UnitTest::LoadDataStructure(exemplarFilePath);
4968

5069
// Read the Small IN100 Data set
5170
auto baseDataFilePath = fs::path(fmt::format("{}/Small_IN100.dream3d", unit_test::k_TestFilesDir));
52-
DataStructure dataStructure = LoadDataStructure(baseDataFilePath);
71+
DataStructure dataStructure = UnitTest::LoadDataStructure(baseDataFilePath);
5372

5473
// MultiThreshold Objects Filter (From SimplnxCore Plugins)
5574
SmallIn100::ExecuteMultiThresholdObjects(dataStructure, *filterList);
@@ -75,11 +94,11 @@ TEST_CASE("OrientationAnalysis::BadDataNeighborOrientationCheckFilter: Small IN1
7594
// Create default Parameters for the filter.
7695
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_MisorientationTolerance_Key, std::make_any<float32>(5.0f));
7796
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_NumberOfNeighbors_Key, std::make_any<int32>(4));
78-
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_ImageGeometryPath_Key, std::make_any<DataPath>(k_DataContainerPath));
79-
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_QuatsArrayPath_Key, std::make_any<DataPath>(k_QuatsArrayPath));
80-
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_MaskArrayPath_Key, std::make_any<DataPath>(k_MaskArrayPath));
81-
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_CellPhasesArrayPath_Key, std::make_any<DataPath>(k_PhasesArrayPath));
82-
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_CrystalStructuresArrayPath_Key, std::make_any<DataPath>(k_CrystalStructuresArrayPath));
97+
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_ImageGeometryPath_Key, std::make_any<DataPath>(Constants::k_DataContainerPath));
98+
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_QuatsArrayPath_Key, std::make_any<DataPath>(Constants::k_QuatsArrayPath));
99+
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_MaskArrayPath_Key, std::make_any<DataPath>(Constants::k_MaskArrayPath));
100+
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_CellPhasesArrayPath_Key, std::make_any<DataPath>(Constants::k_PhasesArrayPath));
101+
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_CrystalStructuresArrayPath_Key, std::make_any<DataPath>(Constants::k_CrystalStructuresArrayPath));
83102

84103
// Preflight the filter and check result
85104
auto preflightResult = filter->preflight(dataStructure, args);
@@ -92,13 +111,13 @@ TEST_CASE("OrientationAnalysis::BadDataNeighborOrientationCheckFilter: Small IN1
92111

93112
// Loop and compare each array from the 'Exemplar Data / CellData' to the 'Data Container / CellData' group
94113
{
95-
auto& cellDataGroup = dataStructure.getDataRefAs<AttributeMatrix>(k_CellAttributeMatrix);
114+
auto& cellDataGroup = dataStructure.getDataRefAs<AttributeMatrix>(Constants::k_CellAttributeMatrix);
96115
std::vector<DataPath> selectedCellArrays;
97116

98117
// Create the vector of selected cell DataPaths
99118
for(auto& child : cellDataGroup)
100119
{
101-
selectedCellArrays.push_back(k_CellAttributeMatrix.createChildPath(child.second->getName()));
120+
selectedCellArrays.push_back(Constants::k_CellAttributeMatrix.createChildPath(child.second->getName()));
102121
}
103122

104123
for(const auto& cellArrayPath : selectedCellArrays)
@@ -108,7 +127,7 @@ TEST_CASE("OrientationAnalysis::BadDataNeighborOrientationCheckFilter: Small IN1
108127

109128
// Now generate the path to the exemplar data set in the exemplar data structure.
110129
std::vector<std::string> generatedPathVector = cellArrayPath.getPathVector();
111-
generatedPathVector[0] = k_ExemplarDataContainer;
130+
generatedPathVector[0] = Constants::k_ExemplarDataContainer;
112131
DataPath exemplarDataArrayPath(generatedPathVector);
113132

114133
// Check to see if there is something to compare against in the exemplar file.
@@ -131,47 +150,47 @@ TEST_CASE("OrientationAnalysis::BadDataNeighborOrientationCheckFilter: Small IN1
131150
switch(type)
132151
{
133152
case DataType::boolean: {
134-
CompareDataArrays<bool>(generatedDataArray, exemplarDataArray);
153+
UnitTest::CompareDataArrays<bool>(generatedDataArray, exemplarDataArray);
135154
break;
136155
}
137156
case DataType::int8: {
138-
CompareDataArrays<int8>(generatedDataArray, exemplarDataArray);
157+
UnitTest::CompareDataArrays<int8>(generatedDataArray, exemplarDataArray);
139158
break;
140159
}
141160
case DataType::int16: {
142-
CompareDataArrays<int16>(generatedDataArray, exemplarDataArray);
161+
UnitTest::CompareDataArrays<int16>(generatedDataArray, exemplarDataArray);
143162
break;
144163
}
145164
case DataType::int32: {
146-
CompareDataArrays<int32>(generatedDataArray, exemplarDataArray);
165+
UnitTest::CompareDataArrays<int32>(generatedDataArray, exemplarDataArray);
147166
break;
148167
}
149168
case DataType::int64: {
150-
CompareDataArrays<int64>(generatedDataArray, exemplarDataArray);
169+
UnitTest::CompareDataArrays<int64>(generatedDataArray, exemplarDataArray);
151170
break;
152171
}
153172
case DataType::uint8: {
154-
CompareDataArrays<uint8>(generatedDataArray, exemplarDataArray);
173+
UnitTest::CompareDataArrays<uint8>(generatedDataArray, exemplarDataArray);
155174
break;
156175
}
157176
case DataType::uint16: {
158-
CompareDataArrays<uint16>(generatedDataArray, exemplarDataArray);
177+
UnitTest::CompareDataArrays<uint16>(generatedDataArray, exemplarDataArray);
159178
break;
160179
}
161180
case DataType::uint32: {
162-
CompareDataArrays<uint32>(generatedDataArray, exemplarDataArray);
181+
UnitTest::CompareDataArrays<uint32>(generatedDataArray, exemplarDataArray);
163182
break;
164183
}
165184
case DataType::uint64: {
166-
CompareDataArrays<uint64>(generatedDataArray, exemplarDataArray);
185+
UnitTest::CompareDataArrays<uint64>(generatedDataArray, exemplarDataArray);
167186
break;
168187
}
169188
case DataType::float32: {
170-
CompareDataArrays<float32>(generatedDataArray, exemplarDataArray);
189+
UnitTest::CompareDataArrays<float32>(generatedDataArray, exemplarDataArray);
171190
break;
172191
}
173192
case DataType::float64: {
174-
CompareDataArrays<float64>(generatedDataArray, exemplarDataArray);
193+
UnitTest::CompareDataArrays<float64>(generatedDataArray, exemplarDataArray);
175194
break;
176195
}
177196
default: {
@@ -187,3 +206,55 @@ TEST_CASE("OrientationAnalysis::BadDataNeighborOrientationCheckFilter: Small IN1
187206

188207
UnitTest::CheckArraysInheritTupleDims(dataStructure, SmallIn100::k_TupleCheckIgnoredPaths);
189208
}
209+
210+
TEST_CASE("OrientationAnalysis::BadDataNeighborOrientationCheckFilter: Verification Test", "[OrientationAnalysis][BadDataNeighborOrientationCheckFilter]")
211+
{
212+
const nx::core::UnitTest::TestFileSentinel testDataSentinel(nx::core::unit_test::k_CMakeExecutable, nx::core::unit_test::k_TestFilesDir, "BadDataNeighborOrientationCheck.tar.gz",
213+
"BadDataNeighborOrientationCheck");
214+
215+
// Read the Small IN100 Data set
216+
auto baseDataFilePath = fs::path(fmt::format("{}/BadDataNeighborOrientationCheck/Input/6_5_state_file_P12_PW_ANG.dream3d", unit_test::k_TestFilesDir));
217+
DataStructure dataStructure = UnitTest::LoadDataStructure(baseDataFilePath);
218+
219+
// Bad Data Neighbor Orientation Check Filter
220+
{
221+
BadDataNeighborOrientationCheckFilter filter;
222+
Arguments args;
223+
224+
// Create default Parameters for the filter.
225+
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_MisorientationTolerance_Key, std::make_any<float32>(5.0f));
226+
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_NumberOfNeighbors_Key, std::make_any<int32>(4));
227+
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_ImageGeometryPath_Key, std::make_any<DataPath>(VerificationConstants::k_ImagePath));
228+
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_QuatsArrayPath_Key, std::make_any<DataPath>(VerificationConstants::k_QuatsArrayPath));
229+
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_MaskArrayPath_Key, std::make_any<DataPath>(VerificationConstants::k_MaskArrayPath));
230+
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_CellPhasesArrayPath_Key, std::make_any<DataPath>(VerificationConstants::k_PhasesArrayPath));
231+
args.insertOrAssign(BadDataNeighborOrientationCheckFilter::k_CrystalStructuresArrayPath_Key, std::make_any<DataPath>(VerificationConstants::k_CStuctsArrayPath));
232+
233+
// Preflight the filter and check result
234+
auto preflightResult = filter.preflight(dataStructure, args);
235+
SIMPLNX_RESULT_REQUIRE_VALID(preflightResult.outputActions);
236+
237+
// Execute the filter and check the result
238+
auto executeResult = filter.execute(dataStructure, args);
239+
SIMPLNX_RESULT_REQUIRE_VALID(executeResult.result);
240+
}
241+
242+
// Read Exemplar DREAM3D File Filter
243+
auto exemplar65FilePath = fs::path(fmt::format("{}/BadDataNeighborOrientationCheck/6_5_Output/EBSD_Example_ANG_Public_Domain.dream3d", unit_test::k_TestFilesDir));
244+
DataStructure exemplar65DataStructure = UnitTest::LoadDataStructure(exemplar65FilePath);
245+
246+
UnitTest::CompareDataArrays<bool>(dataStructure.getDataRefAs<BoolArray>(VerificationConstants::k_MaskArrayPath),
247+
exemplar65DataStructure.getDataRefAs<BoolArray>(VerificationConstants::k_MaskArrayPath));
248+
249+
auto exemplar74FilePath = fs::path(fmt::format("{}/BadDataNeighborOrientationCheck/7_4_Output/EBSD_Example_ANG_Public_Domain.dream3d", unit_test::k_TestFilesDir));
250+
DataStructure exemplar74DataStructure = UnitTest::LoadDataStructure(exemplar65FilePath);
251+
252+
UnitTest::CompareDataArrays<bool>(dataStructure.getDataRefAs<BoolArray>(VerificationConstants::k_MaskArrayPath),
253+
exemplar74DataStructure.getDataRefAs<BoolArray>(VerificationConstants::k_MaskArrayPath));
254+
255+
#ifdef SIMPLNX_WRITE_TEST_OUTPUT
256+
WriteTestDataStructure(dataStructure, fmt::format("{}/verification/bad_data_neighbor_orientation_check.dream3d", unit_test::k_BinaryTestOutputDir));
257+
#endif
258+
259+
UnitTest::CheckArraysInheritTupleDims(dataStructure, SmallIn100::k_TupleCheckIgnoredPaths);
260+
}

0 commit comments

Comments
 (0)