MeshTools: simplify test code a bit.

We have new less shitty APIs, so use them!

src/Magnum/MeshTools/Test/CompressIndicesTest.cpp

@@ -62,8 +62,9 @@ void CompressIndicesTest::compressChar() {
     CORRADE_COMPARE(start, 0);
     CORRADE_COMPARE(end, 4);
     CORRADE_COMPARE(type, MeshIndexType::UnsignedByte);
-    CORRADE_COMPARE(std::vector<char>(data.begin(), data.end()),
-        (std::vector<char>{ 0x01, 0x02, 0x03, 0x00, 0x04 }));
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(data),
+        Containers::arrayView<UnsignedByte>({1, 2, 3, 0, 4}),
+        TestSuite::Compare::Container);
 }
 
 void CompressIndicesTest::compressShort() {
@@ -76,19 +77,9 @@ void CompressIndicesTest::compressShort() {
     CORRADE_COMPARE(start, 0);
     CORRADE_COMPARE(end, 256);
     CORRADE_COMPARE(type, MeshIndexType::UnsignedShort);
-    if(!Utility::Endianness::isBigEndian()) {
-        CORRADE_COMPARE(std::vector<char>(data.begin(), data.end()),
-            (std::vector<char>{ 0x01, 0x00,
-                           0x00, 0x01,
-                           0x00, 0x00,
-                           0x05, 0x00 }));
-    } else {
-        CORRADE_COMPARE(std::vector<char>(data.begin(), data.end()),
-            (std::vector<char>{ 0x00, 0x01,
-                           0x01, 0x00,
-                           0x00, 0x00,
-                           0x00, 0x05 }));
-    }
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedShort>(data),
+        Containers::arrayView<UnsignedShort>({1, 256, 0, 5}),
+        TestSuite::Compare::Container);
 }
 
 void CompressIndicesTest::compressInt() {
@@ -101,23 +92,14 @@ void CompressIndicesTest::compressInt() {
     CORRADE_COMPARE(start, 2);
     CORRADE_COMPARE(end, 65536);
     CORRADE_COMPARE(type, MeshIndexType::UnsignedInt);
-
-    if(!Utility::Endianness::isBigEndian()) {
-        CORRADE_COMPARE(std::vector<char>(data.begin(), data.end()),
-            (std::vector<char>{ 0x00, 0x00, 0x01, 0x00,
-                           0x03, 0x00, 0x00, 0x00,
-                           0x02, 0x00, 0x00, 0x00 }));
-    } else {
-        CORRADE_COMPARE(std::vector<char>(data.begin(), data.end()),
-            (std::vector<char>{ 0x00, 0x01, 0x00, 0x00,
-                           0x00, 0x00, 0x00, 0x03,
-                           0x00, 0x00, 0x00, 0x02 }));
-    }
+    CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedInt>(data),
+        Containers::arrayView<UnsignedInt>({65536, 3, 2}),
+        TestSuite::Compare::Container);
 }
 
 void CompressIndicesTest::compressAsShort() {
     CORRADE_COMPARE_AS(MeshTools::compressIndicesAs<UnsignedShort>({123, 456}),
-        (Containers::Array<UnsignedShort>{Containers::InPlaceInit, {123, 456}}),
+        Containers::arrayView<UnsignedShort>({123, 456}),
         TestSuite::Compare::Container);
 
     std::ostringstream out;

src/Magnum/MeshTools/Test/DuplicateTest.cpp

@@ -69,9 +69,8 @@ void DuplicateTest::duplicate() {
     constexpr Int data[]{-7, 35, 12, -18};
 
     CORRADE_COMPARE_AS((MeshTools::duplicate<UnsignedByte, Int>(indices, data)),
-        (Containers::Array<Int>{Containers::InPlaceInit, {
-            35, 35, -7, -18, 12, 12
-        }}), TestSuite::Compare::Container);
+        Containers::arrayView<Int>({35, 35, -7, -18, 12, 12}),
+        TestSuite::Compare::Container);
 }
 
 void DuplicateTest::duplicateOutOfBounds() {
@@ -98,9 +97,8 @@ void DuplicateTest::duplicateInto() {
 
     MeshTools::duplicateInto<UnsignedByte, Int>(indices, data, output);
     CORRADE_COMPARE_AS(Containers::arrayView<const Int>(output),
-        (Containers::Array<Int>{Containers::InPlaceInit, {
-            35, 35, -7, -18, 12, 12
-        }}), TestSuite::Compare::Container);
+        Containers::arrayView({35, 35, -7, -18, 12, 12}),
+        TestSuite::Compare::Container);
 }
 
 void DuplicateTest::duplicateIntoWrongSize() {

src/Magnum/MeshTools/Test/GenerateNormalsTest.cpp

@@ -102,14 +102,14 @@ constexpr Vector3 TwoTriangles[]{
 
 void GenerateNormalsTest::flat() {
     CORRADE_COMPARE_AS(generateFlatNormals(TwoTriangles),
-        (Containers::Array<Vector3>{Containers::InPlaceInit, {
+        Containers::arrayView<Vector3>({
             Vector3::zAxis(),
             Vector3::zAxis(),
             Vector3::zAxis(),
             -Vector3::zAxis(),
             -Vector3::zAxis(),
             -Vector3::zAxis()
-        }}), TestSuite::Compare::Container);
+        }), TestSuite::Compare::Container);
 }
 
 #ifdef MAGNUM_BUILD_DEPRECATED
@@ -165,16 +165,15 @@ template<class T> void GenerateNormalsTest::smoothTwoTriangles() {
     const T indices[]{0, 1, 2, 3, 4, 5};
 
     /* Should generate the same output as flat normals */
-    CORRADE_COMPARE_AS(
-        generateSmoothNormals(indices, TwoTriangles),
-        (Containers::Array<Vector3>{Containers::InPlaceInit, {
+    CORRADE_COMPARE_AS(generateSmoothNormals(indices, TwoTriangles),
+        Containers::arrayView<Vector3>({
             Vector3::zAxis(),
             Vector3::zAxis(),
             Vector3::zAxis(),
             -Vector3::zAxis(),
             -Vector3::zAxis(),
             -Vector3::zAxis()
-        }}), TestSuite::Compare::Container);
+        }), TestSuite::Compare::Container);
 }
 
 void GenerateNormalsTest::smoothCube() {
@@ -199,9 +198,8 @@ void GenerateNormalsTest::smoothCube() {
     };
 
     /* Normals should be the same as positions, only normalized */
-    CORRADE_COMPARE_AS(
-        generateSmoothNormals(indices, positions),
-        (Containers::Array<Vector3>{Containers::InPlaceInit, {
+    CORRADE_COMPARE_AS(generateSmoothNormals(indices, positions),
+        Containers::arrayView<Vector3>({
             positions[0]/Constants::sqrt3(),
             positions[1]/Constants::sqrt3(),
             positions[2]/Constants::sqrt3(),
@@ -210,7 +208,7 @@ void GenerateNormalsTest::smoothCube() {
             positions[5]/Constants::sqrt3(),
             positions[6]/Constants::sqrt3(),
             positions[7]/Constants::sqrt3()
-        }}), TestSuite::Compare::Container);
+        }), TestSuite::Compare::Container);
 }
 
 constexpr Vector3 BeveledCubePositions[] {
@@ -288,9 +286,8 @@ void GenerateNormalsTest::smoothBeveledCube() {
     Vector3 z{0.0462723f, 0.0754969f, 0.996072f};
     Vector3 x{0.996072f, 0.0754969f, 0.0462723f};
     Vector3 y{0.0467958f, 0.997808f, 0.0467958f};
-    CORRADE_COMPARE_AS(generateSmoothNormals(
-        BeveledCubeIndices, BeveledCubePositions),
-        (Containers::Array<Vector3>{Containers::InPlaceInit, {
+    CORRADE_COMPARE_AS(generateSmoothNormals(BeveledCubeIndices, BeveledCubePositions),
+        Containers::arrayView<Vector3>({
             z*Math::sign(BeveledCubePositions[ 0]),
             z*Math::sign(BeveledCubePositions[ 1]),
             z*Math::sign(BeveledCubePositions[ 2]), /* +Z */
@@ -320,7 +317,7 @@ void GenerateNormalsTest::smoothBeveledCube() {
             x*Math::sign(BeveledCubePositions[21]),
             x*Math::sign(BeveledCubePositions[22]), /* -X */
             x*Math::sign(BeveledCubePositions[23])
-        }}), TestSuite::Compare::Container);
+        }), TestSuite::Compare::Container);
 }
 
 void GenerateNormalsTest::smoothCylinder() {