MeshTools: adapt flipFaceWinding(), flipNormals() and tipsify() tests.

src/Magnum/MeshTools/Test/FlipNormalsTest.cpp

@@ -24,7 +24,9 @@
 */
 
 #include <sstream>
+#include <Corrade/Containers/StridedArrayView.h>
 #include <Corrade/TestSuite/Tester.h>
+#include <Corrade/TestSuite/Compare/Container.h>
 #include <Corrade/Utility/DebugStl.h>
 
 #include "Magnum/Math/Vector3.h"
@@ -36,44 +38,69 @@ struct FlipNormalsTest: TestSuite::Tester {
     explicit FlipNormalsTest();
 
     void wrongIndexCount();
-    void flipFaceWinding();
+    template<class T> void flipFaceWinding();
     void flipNormals();
+
+    template<class T> void flipNormalsFaceWinding();
 };
 
 FlipNormalsTest::FlipNormalsTest() {
     addTests({&FlipNormalsTest::wrongIndexCount,
-              &FlipNormalsTest::flipFaceWinding,
+              &FlipNormalsTest::flipFaceWinding<UnsignedByte>,
-              &FlipNormalsTest::flipNormals});
+              &FlipNormalsTest::flipFaceWinding<UnsignedShort>,
+              &FlipNormalsTest::flipFaceWinding<UnsignedInt>,
+              &FlipNormalsTest::flipNormals,
+
+              &FlipNormalsTest::flipNormalsFaceWinding<UnsignedByte>,
+              &FlipNormalsTest::flipNormalsFaceWinding<UnsignedShort>,
+              &FlipNormalsTest::flipNormalsFaceWinding<UnsignedInt>});
 }
 
 void FlipNormalsTest::wrongIndexCount() {
     std::stringstream ss;
     Error redirectError{&ss};
 
-    std::vector<UnsignedInt> indices{0, 1};
+    UnsignedByte indices[2];
-    MeshTools::flipFaceWinding(indices);
+    MeshTools::flipFaceWindingInPlace(Containers::stridedArrayView(indices));
 
     CORRADE_COMPARE(ss.str(), "MeshTools::flipNormals(): index count is not divisible by 3!\n");
 }
 
-void FlipNormalsTest::flipFaceWinding() {
+template<class T> void FlipNormalsTest::flipFaceWinding() {
-    std::vector<UnsignedInt> indices{0, 1, 2,
+    setTestCaseTemplateName(Math::TypeTraits<T>::name());
-                                       3, 4, 5};
+
-    MeshTools::flipFaceWinding(indices);
+    T indices[]{0, 1, 2, 3, 4, 5};
+    MeshTools::flipFaceWindingInPlace(indices);
 
-    CORRADE_COMPARE(indices, (std::vector<UnsignedInt>{0, 2, 1,
+    CORRADE_COMPARE_AS(Containers::arrayView(indices),
-                                                         3, 5, 4}));
+        Containers::arrayView<T>({0, 2, 1, 3, 5, 4}),
+        TestSuite::Compare::Container);
 }
 
 void FlipNormalsTest::flipNormals() {
-    std::vector<Vector3> normals{Vector3::xAxis(),
+    Vector3 normals[]{Vector3::xAxis(), Vector3::yAxis(), Vector3::zAxis()};
-                                 Vector3::yAxis(),
+    MeshTools::flipNormalsInPlace(normals);
-                                 Vector3::zAxis()};
+
-    MeshTools::flipNormals(normals);
+    CORRADE_COMPARE_AS(Containers::arrayView(normals),
-
+        Containers::arrayView<Vector3>({
-    CORRADE_COMPARE(normals, (std::vector<Vector3>{-Vector3::xAxis(),
+            -Vector3::xAxis(), -Vector3::yAxis(), -Vector3::zAxis()
-                                                   -Vector3::yAxis(),
+        }), TestSuite::Compare::Container);
-                                                   -Vector3::zAxis()}));
+}
+
+template<class T> void FlipNormalsTest::flipNormalsFaceWinding() {
+    setTestCaseTemplateName(Math::TypeTraits<T>::name());
+
+    T indices[]{0, 1, 2, 3, 4, 5};
+    Vector3 normals[]{Vector3::xAxis(), Vector3::yAxis(), Vector3::zAxis()};
+    MeshTools::flipNormalsInPlace(indices, normals);
+
+    CORRADE_COMPARE_AS(Containers::arrayView(indices),
+        Containers::arrayView<T>({0, 2, 1, 3, 5, 4}),
+        TestSuite::Compare::Container);
+    CORRADE_COMPARE_AS(Containers::arrayView(normals),
+        Containers::arrayView<Vector3>({
+            -Vector3::xAxis(), -Vector3::yAxis(), -Vector3::zAxis()
+        }), TestSuite::Compare::Container);
 }
 
 }}}}

src/Magnum/MeshTools/Test/TipsifyTest.cpp

@@ -28,6 +28,7 @@
 #include <Corrade/TestSuite/Compare/Container.h>
 
 #include "Magnum/Magnum.h"
+#include "Magnum/Math/TypeTraits.h"
 #include "Magnum/MeshTools/Tipsify.h"
 #include "Magnum/MeshTools/Implementation/Tipsify.h"
 
@@ -37,7 +38,7 @@ struct TipsifyTest: TestSuite::Tester {
     explicit TipsifyTest();
 
     void buildAdjacency();
-    void tipsify();
+    template<class T> void tipsify();
     void oneDegenerateTriangle();
 };
 
@@ -85,7 +86,9 @@ constexpr std::size_t VertexCount = 19;
 
 TipsifyTest::TipsifyTest() {
     addTests({&TipsifyTest::buildAdjacency,
-              &TipsifyTest::tipsify,
+              &TipsifyTest::tipsify<UnsignedByte>,
+              &TipsifyTest::tipsify<UnsignedShort>,
+              &TipsifyTest::tipsify<UnsignedInt>,
               &TipsifyTest::oneDegenerateTriangle});
 }
 
@@ -134,11 +137,15 @@ void TipsifyTest::buildAdjacency() {
     }), TestSuite::Compare::Container);
 }
 
-void TipsifyTest::tipsify() {
+template<class T> void TipsifyTest::tipsify() {
-    std::vector<UnsignedInt> indices{std::begin(Indices), std::end(Indices)};
+    setTestCaseTemplateName(Math::TypeTraits<T>::name());
-    MeshTools::tipsify(indices, VertexCount, 3);
 
-    CORRADE_COMPARE(indices, (std::vector<UnsignedInt>{
+    T indices[Containers::arraySize(Indices)];
+    for(std::size_t i = 0; i != Containers::arraySize(Indices); ++i)
+        indices[i] = Indices[i];
+    MeshTools::tipsifyInPlace(indices, VertexCount, 3);
+
+    CORRADE_COMPARE_AS(Containers::arrayView(indices), Containers::arrayView<T>({
         4, 1, 0,
         9, 5, 4,
         1, 4, 5,
@@ -158,16 +165,18 @@ void TipsifyTest::tipsify() {
         2, 1, 5,
         14, 15, 11, /* from dead-end vertex stack */
         16, 17, 18 /* arbitrary vertex */
-    }));
+    }), TestSuite::Compare::Container);
 }
 
 void TipsifyTest::oneDegenerateTriangle() {
     /* There used to be an OOB access (neighbors[++ti]) caught by ASan, this
        triggers it */
-    std::vector<UnsignedInt> indices{0, 0, 0};
+    UnsignedInt indices[]{0, 0, 0};
-    MeshTools::tipsify(indices, 1, 2);
+    MeshTools::tipsifyInPlace(indices, 1, 2);
 
-    CORRADE_COMPARE(indices, (std::vector<UnsignedInt>{0, 0, 0}));
+    CORRADE_COMPARE_AS(Containers::arrayView(indices),
+        Containers::arrayView<UnsignedInt>({0, 0, 0}),
+        TestSuite::Compare::Container);
 }
 
 }}}}