simplify test of datafield rotation

Tests/Unit/Device/DatafieldTest.cpp

@@ -6,75 +6,71 @@
 
 TEST(DatafieldTest, rotatedDatafield)
 {
-    Datafield input_data{
-        {newEquiDivision("axis0", 2, 1.0, 2.0), newEquiDivision("axis1", 3, 3.0, 4.0)}};
-    input_data.setVector(std::vector<double>{1.0, 2.0, 3.0, 4.0, 5.0, 6.0});
-
-    std::unique_ptr<Datafield> output_data;
-    output_data = std::make_unique<Datafield>(DataUtil::rotatedDatafield(input_data, 5));
-
-    EXPECT_EQ(size_t(3), output_data->axis(0).size());
-    EXPECT_EQ(size_t(2), output_data->axis(1).size());
-
-    EXPECT_EQ(input_data[2], (*output_data)[0]);
-    EXPECT_EQ(input_data[5], (*output_data)[1]);
-    EXPECT_EQ(input_data[1], (*output_data)[2]);
-    EXPECT_EQ(input_data[4], (*output_data)[3]);
-    EXPECT_EQ(input_data[0], (*output_data)[4]);
-    EXPECT_EQ(input_data[3], (*output_data)[5]);
-
-    output_data = std::make_unique<Datafield>(DataUtil::rotatedDatafield(input_data, -6));
-
-    EXPECT_EQ(size_t(2), output_data->axis(0).size());
-    EXPECT_EQ(size_t(3), output_data->axis(1).size());
-
-    EXPECT_EQ(input_data[5], (*output_data)[0]);
-    EXPECT_EQ(input_data[4], (*output_data)[1]);
-    EXPECT_EQ(input_data[3], (*output_data)[2]);
-    EXPECT_EQ(input_data[2], (*output_data)[3]);
-    EXPECT_EQ(input_data[1], (*output_data)[4]);
-    EXPECT_EQ(input_data[0], (*output_data)[5]);
-
-    output_data = std::make_unique<Datafield>(DataUtil::rotatedDatafield(input_data, 3));
-
-    EXPECT_EQ(size_t(3), output_data->axis(0).size());
-    EXPECT_EQ(size_t(2), output_data->axis(1).size());
-
-    EXPECT_EQ(input_data[3], (*output_data)[0]);
-    EXPECT_EQ(input_data[0], (*output_data)[1]);
-    EXPECT_EQ(input_data[4], (*output_data)[2]);
-    EXPECT_EQ(input_data[1], (*output_data)[3]);
-    EXPECT_EQ(input_data[5], (*output_data)[4]);
-    EXPECT_EQ(input_data[2], (*output_data)[5]);
+    Datafield a({newEquiDivision("axis0", 2, 1., 2.), newEquiDivision("axis1", 3, 3., 4.)},
+                {0., 1., 2., 3., 4., 5.});
+
+    Datafield b = DataUtil::rotatedDatafield(a, 5);
+
+    EXPECT_EQ(b.axis(0).size(), 3);
+    EXPECT_EQ(b.axis(1).size(), 2);
+
+    EXPECT_EQ(b[0], 2.);
+    EXPECT_EQ(b[1], 5.);
+    EXPECT_EQ(b[2], 1.);
+    EXPECT_EQ(b[3], 4.);
+    EXPECT_EQ(b[4], 0.);
+    EXPECT_EQ(b[5], 3.);
+
+    Datafield c = DataUtil::rotatedDatafield(a, -6);
+
+    EXPECT_EQ(c.axis(0).size(), 2);
+    EXPECT_EQ(c.axis(1).size(), 3);
+
+    EXPECT_EQ(c[0], 5.);
+    EXPECT_EQ(c[1], 4.);
+    EXPECT_EQ(c[2], 3.);
+    EXPECT_EQ(c[3], 2.);
+    EXPECT_EQ(c[4], 1.);
+    EXPECT_EQ(c[5], 0.);
+
+    Datafield d = DataUtil::rotatedDatafield(a, 3);
+
+    EXPECT_EQ(d.axis(0).size(), 3);
+    EXPECT_EQ(d.axis(1).size(), 2);
+
+    EXPECT_EQ(d[0], 3.);
+    EXPECT_EQ(d[1], 0.);
+    EXPECT_EQ(d[2], 4.);
+    EXPECT_EQ(d[3], 1.);
+    EXPECT_EQ(d[4], 5.);
+    EXPECT_EQ(d[5], 2.);
 }
 
 TEST(DatafieldTest, create2DArrayfromDatafield)
 {
-    Datafield out_data{
-        {newEquiDivision("axis0", 3, 1.0, 3.0), newEquiDivision("axis1", 2, 10., 20.)}};
-    EXPECT_EQ(6u, out_data.size());
+    Datafield a{{newEquiDivision("axis0", 3, 1., 3.), newEquiDivision("axis1", 2, 10., 20.)}};
+    EXPECT_EQ(6u, a.size());
 
-    EXPECT_EQ(3u, out_data.axis(0).size()); // no. of rows
-    EXPECT_EQ(2u, out_data.axis(1).size()); // no. of cols
+    EXPECT_EQ(3u, a.axis(0).size()); // no. of rows
+    EXPECT_EQ(2u, a.axis(1).size()); // no. of cols
 
-    std::vector<double> arr_in{1, 2, 3, 4, 5, 6};
-    out_data.setVector(arr_in);
+    std::vector<double> v{0, 1, 2, 3, 4, 5};
+    a.setVector(v);
 
-    EXPECT_EQ(arr_in[0], out_data[0]);
-    EXPECT_EQ(arr_in[1], out_data[1]);
-    EXPECT_EQ(arr_in[2], out_data[2]);
-    EXPECT_EQ(arr_in[3], out_data[3]);
-    EXPECT_EQ(arr_in[4], out_data[4]);
-    EXPECT_EQ(arr_in[5], out_data[5]);
+    EXPECT_EQ(v[0], 0);
+    EXPECT_EQ(v[1], 1);
+    EXPECT_EQ(v[2], 2);
+    EXPECT_EQ(v[3], 3);
+    EXPECT_EQ(v[4], 4);
+    EXPECT_EQ(v[5], 5);
 
-    auto arr_out = out_data.flatVector();
-    EXPECT_EQ(arr_in, arr_out);
+    auto v2 = a.flatVector();
+    EXPECT_EQ(v2, v);
 
-    auto array_2d = out_data.values2D();
+    auto v3 = a.values2D();
 
-    std::vector<std::vector<double>> array_expected_2d{{arr_in[0], arr_in[1], arr_in[2]},
-                                                       {arr_in[3], arr_in[4], arr_in[5]}};
-    EXPECT_EQ(array_expected_2d, array_2d);
+    std::vector<std::vector<double>> v3expected{{0, 1, 2}, {3, 4, 5}};
+    EXPECT_EQ(v3, v3expected);
 }
 
 TEST(DatafieldTest, ctor2D)
@@ -87,8 +83,7 @@ TEST(DatafieldTest, ctor2D)
 
 TEST(DatafieldTest, DatafieldToVector2D)
 {
-    Datafield data(
-        {newEquiDivision("axis0", 3, 10.0, 20.0), newEquiDivision("axis1", 2, 30.0, 40.0)});
+    Datafield data({newEquiDivision("axis0", 3, 10., 20.), newEquiDivision("axis1", 2, 30., 40.)});
     const std::vector<double> values = {0., 1., 2., 10., 11., 12.};
 
     data.setVector(values);