Merge topic 'sort-not-stable'

d938226cd Fix tests that relied on stable sort

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !2249

vtkm/worklet/testing/UnitTestCellSetDualGraph.cxx

@@ -7,7 +7,7 @@
 //  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
-#include <vtkm/cont/testing/MakeTestDataSet.h>
+#include <vtkm/cont/ArrayHandleGroupVecVariable.h>
 #include <vtkm/cont/testing/Testing.h>
 #include <vtkm/filter/Contour.h>
 
@@ -16,19 +16,51 @@
 class TestCellSetDualGraph
 {
 private:
-  template <typename T, typename Storage>
-  bool TestArrayHandle(const vtkm::cont::ArrayHandle<T, Storage>& ah,
-                       const T* expected,
-                       vtkm::Id size) const
+  using GroupedConnectivityArrayType =
+    vtkm::cont::ArrayHandleGroupVecVariable<vtkm::cont::ArrayHandle<vtkm::Id>,
+                                            vtkm::cont::ArrayHandle<vtkm::Id>>;
+
+  static GroupedConnectivityArrayType MakeGroupedConnectivity(
+    vtkm::cont::ArrayHandle<vtkm::Id> connectivity,
+    vtkm::cont::ArrayHandle<vtkm::Id> counts)
   {
-    if (size != ah.GetNumberOfValues())
+    return GroupedConnectivityArrayType(connectivity,
+                                        vtkm::cont::ConvertNumComponentsToOffsets(counts));
+  }
+
+  static bool TestConnectivity(GroupedConnectivityArrayType computedConnectivityArray,
+                               GroupedConnectivityArrayType expectedConnectivityArray)
+  {
+    auto computedConnections = computedConnectivityArray.ReadPortal();
+    auto expectedConnections = expectedConnectivityArray.ReadPortal();
+
+    vtkm::Id numItems = computedConnections.GetNumberOfValues();
+    if (numItems != expectedConnections.GetNumberOfValues())
     {
       return false;
     }
 
-    for (vtkm::Id i = 0; i < size; ++i)
+    for (vtkm::Id itemIndex = 0; itemIndex < numItems; ++itemIndex)
     {
-      if (ah.ReadPortal().Get(i) != expected[i])
+      auto computed = computedConnections.Get(itemIndex);
+      auto expected = expectedConnections.Get(itemIndex);
+      vtkm::IdComponent numConnections = computed.GetNumberOfComponents();
+      if (numConnections != expected.GetNumberOfComponents())
+      {
+        return false;
+      }
+
+      // computed and expected are Vec-like objects that should represent the same thing.
+      // However, although both should have the same indices, they may be in different
+      // orders.
+      std::set<vtkm::Id> computedSet;
+      std::set<vtkm::Id> expectedSet;
+      for (vtkm::IdComponent componentIndex = 0; componentIndex < numConnections; ++componentIndex)
+      {
+        computedSet.insert(computed[componentIndex]);
+        expectedSet.insert(expected[componentIndex]);
+      }
+      if (computedSet != expectedSet)
       {
         return false;
       }
@@ -44,7 +76,7 @@ public:
       { 0, 2, 4, 1, 3, 5, 2, 6, 4, 5, 3, 7, 2, 9, 6, 4, 6, 8 });
 
     vtkm::cont::CellSetSingleType<> cellSet;
-    cellSet.Fill(8, vtkm::CELL_SHAPE_TRIANGLE, 3, connectivity);
+    cellSet.Fill(10, vtkm::CELL_SHAPE_TRIANGLE, 3, connectivity);
 
     vtkm::cont::ArrayHandle<vtkm::Id> numIndicesArray;
     vtkm::cont::ArrayHandle<vtkm::Id> indexOffsetArray;
@@ -53,19 +85,21 @@ public:
     vtkm::worklet::connectivity::CellSetDualGraph().Run(
       cellSet, numIndicesArray, indexOffsetArray, connectivityArray);
 
-    vtkm::Id expectedNumIndices[] = { 1, 1, 3, 1, 1, 1 };
-    VTKM_TEST_ASSERT(numIndicesArray.GetNumberOfValues() == 6,
-                     "Wrong number of elements in NumIndices array");
-    VTKM_TEST_ASSERT(TestArrayHandle(numIndicesArray, expectedNumIndices, 6),
-                     "Got incorrect numIndices");
+    vtkm::cont::ArrayHandle<vtkm::Id> expectedNumIndices =
+      vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 3, 1, 1, 1 });
+    VTKM_TEST_ASSERT(
+      test_equal_portals(numIndicesArray.ReadPortal(), expectedNumIndices.ReadPortal()));
 
-    vtkm::Id expectedIndexOffset[] = { 0, 1, 2, 5, 6, 7 };
-    VTKM_TEST_ASSERT(TestArrayHandle(indexOffsetArray, expectedIndexOffset, 6),
-                     "Got incorrect indexOffset");
+    vtkm::cont::ArrayHandle<vtkm::Id> expectedIndexOffset =
+      vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1, 2, 5, 6, 7 });
+    VTKM_TEST_ASSERT(
+      test_equal_portals(indexOffsetArray.ReadPortal(), expectedIndexOffset.ReadPortal()));
 
-    vtkm::Id expectedConnectivity[] = { 2, 3, 0, 4, 5, 1, 2, 2 };
-    VTKM_TEST_ASSERT(TestArrayHandle(connectivityArray, expectedConnectivity, 8),
-                     "Got incorrect dual graph connectivity");
+    vtkm::cont::ArrayHandle<vtkm::Id> expectedConnectivity =
+      vtkm::cont::make_ArrayHandle<vtkm::Id>({ 2, 3, 0, 4, 5, 1, 2, 2 });
+    VTKM_TEST_ASSERT(
+      TestConnectivity(MakeGroupedConnectivity(connectivityArray, numIndicesArray),
+                       MakeGroupedConnectivity(expectedConnectivity, numIndicesArray)));
   }
 
   void operator()() const { this->TestTriangleMesh(); }

vtkm/worklet/testing/UnitTestInnerJoin.cxx

@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/testing/Testing.h>
 #include <vtkm/worklet/connectivities/InnerJoin.h>
 
@@ -15,19 +16,32 @@
 class TestInnerJoin
 {
 public:
-  template <typename T, typename Storage>
-  bool TestArrayHandle(const vtkm::cont::ArrayHandle<T, Storage>& ah,
-                       const T* expected,
-                       vtkm::Id size) const
+  static bool TestJoinedValues(const vtkm::cont::ArrayHandle<vtkm::Id>& computedValuesArray,
+                               const vtkm::cont::ArrayHandle<vtkm::Id>& expectedValuesArray,
+                               const vtkm::cont::ArrayHandle<vtkm::Id>& originalKeysArray)
   {
-    if (size != ah.GetNumberOfValues())
+    auto computedValues = computedValuesArray.ReadPortal();
+    auto expectedValues = expectedValuesArray.ReadPortal();
+    auto originalKeys = originalKeysArray.ReadPortal();
+    if (computedValues.GetNumberOfValues() != expectedValues.GetNumberOfValues())
     {
       return false;
     }
 
-    for (vtkm::Id i = 0; i < size; ++i)
+    for (vtkm::Id valueIndex = 0; valueIndex < computedValues.GetNumberOfValues(); ++valueIndex)
     {
-      if (ah.ReadPortal().Get(i) != expected[i])
+      vtkm::Id computed = computedValues.Get(valueIndex);
+      vtkm::Id expected = expectedValues.Get(valueIndex);
+
+      // The join algorithm uses some key/value sorts that are unstable. Thus, for keys
+      // that are repeated in the original input, the computed and expected values may be
+      // swapped in the results associated with those keys. To test correctly, the values
+      // we computed for are actually indices into the original keys array. Thus, if both
+      // computed and expected are different indices that point to the same original key,
+      // then the algorithm is still correct.
+      vtkm::Id computedKey = originalKeys.Get(computed);
+      vtkm::Id expectedKey = originalKeys.Get(expected);
+      if (computedKey != expectedKey)
       {
         return false;
       }
@@ -38,32 +52,39 @@ public:
 
   void TestTwoArrays() const
   {
-    using Algorithm = vtkm::cont::Algorithm;
-
-    vtkm::cont::ArrayHandle<vtkm::Id> A_arr =
+    vtkm::cont::ArrayHandle<vtkm::Id> keysAOriginal =
       vtkm::cont::make_ArrayHandle<vtkm::Id>({ 8, 3, 6, 8, 9, 5, 12, 10, 14 });
-    vtkm::cont::ArrayHandle<vtkm::Id> B_arr =
+    vtkm::cont::ArrayHandle<vtkm::Id> keysBOriginal =
       vtkm::cont::make_ArrayHandle<vtkm::Id>({ 7, 11, 9, 8, 5, 1, 0, 5 });
-    vtkm::cont::ArrayHandle<vtkm::Id> idxA;
-    vtkm::cont::ArrayHandle<vtkm::Id> idxB;
 
-    Algorithm::Copy(vtkm::cont::ArrayHandleIndex(A_arr.GetNumberOfValues()), idxA);
-    Algorithm::Copy(vtkm::cont::ArrayHandleIndex(B_arr.GetNumberOfValues()), idxB);
+    vtkm::cont::ArrayHandle<vtkm::Id> keysA;
+    vtkm::cont::ArrayHandle<vtkm::Id> keysB;
+    vtkm::cont::ArrayHandle<vtkm::Id> valuesA;
+    vtkm::cont::ArrayHandle<vtkm::Id> valuesB;
+
+    vtkm::cont::ArrayCopy(keysAOriginal, keysA);
+    vtkm::cont::ArrayCopy(keysBOriginal, keysB);
+    vtkm::cont::ArrayCopy(vtkm::cont::ArrayHandleIndex(keysA.GetNumberOfValues()), valuesA);
+    vtkm::cont::ArrayCopy(vtkm::cont::ArrayHandleIndex(keysB.GetNumberOfValues()), valuesB);
 
     vtkm::cont::ArrayHandle<vtkm::Id> joinedIndex;
     vtkm::cont::ArrayHandle<vtkm::Id> outA;
     vtkm::cont::ArrayHandle<vtkm::Id> outB;
 
-    vtkm::worklet::connectivity::InnerJoin().Run(A_arr, idxA, B_arr, idxB, joinedIndex, outA, outB);
+    vtkm::worklet::connectivity::InnerJoin().Run(
+      keysA, valuesA, keysB, valuesB, joinedIndex, outA, outB);
 
-    vtkm::Id expectedIndex[] = { 5, 5, 8, 8, 9 };
-    VTKM_TEST_ASSERT(TestArrayHandle(joinedIndex, expectedIndex, 5), "Wrong joined keys");
+    vtkm::cont::ArrayHandle<vtkm::Id> expectedIndex =
+      vtkm::cont::make_ArrayHandle<vtkm::Id>({ 5, 5, 8, 8, 9 });
+    VTKM_TEST_ASSERT(test_equal_portals(joinedIndex.ReadPortal(), expectedIndex.ReadPortal()));
 
-    vtkm::Id expectedOutA[] = { 5, 5, 0, 3, 4 };
-    VTKM_TEST_ASSERT(TestArrayHandle(outA, expectedOutA, 5), "Wrong joined values");
+    vtkm::cont::ArrayHandle<vtkm::Id> expectedOutA =
+      vtkm::cont::make_ArrayHandle<vtkm::Id>({ 5, 5, 0, 3, 4 });
+    VTKM_TEST_ASSERT(TestJoinedValues(outA, expectedOutA, keysAOriginal));
 
-    vtkm::Id expectedOutB[] = { 4, 7, 3, 3, 2 };
-    VTKM_TEST_ASSERT(TestArrayHandle(outB, expectedOutB, 5), "Wrong joined values");
+    vtkm::cont::ArrayHandle<vtkm::Id> expectedOutB =
+      vtkm::cont::make_ArrayHandle<vtkm::Id>({ 4, 7, 3, 3, 2 });
+    VTKM_TEST_ASSERT(TestJoinedValues(outB, expectedOutB, keysBOriginal));
   }
 
   void operator()() const { this->TestTwoArrays(); }