Clean up double-brace initialization to remove large number of wrapping parenthesis

vector_test.cpp

@@ -25,12 +25,12 @@ vec2i iota2i() { return iota<int, 2>(); }
 vec3i iota3i() { return iota<int, 3>(); }
 
 TEST(Vector, Equality) {
-  EXPECT_THAT((iota3i()), (vec3i{{1, 2, 3}}));
-  EXPECT_THAT((iota3i()), ::testing::Not(vec3i{{0, 2, 3}}));
+  EXPECT_THAT((iota3i()), vec3i({1, 2, 3}));
+  EXPECT_THAT((iota3i()), ::testing::Not(vec3i({0, 2, 3})));
 }
 
 TEST(Vector, DefaultConstructorIsAllZero) {
-  EXPECT_THAT(vec3i(), (vec3i{{0,0,0}}));
+  EXPECT_THAT(vec3i(), vec3i({0,0,0}));
 }
 
 TEST(Vector, FillConstructorInsertsAllElements) {
@@ -38,7 +38,7 @@ TEST(Vector, FillConstructorInsertsAllElements) {
 }
 
 TEST(Vector, ExtensionConstructorAppendsZeros) {
-  EXPECT_THAT(vec4i(iota3i()), (vec4i{{1,2,3,0}}));
+  EXPECT_THAT(vec4i(iota3i()), vec4i({1,2,3,0}));
 }
 
 TEST(Vector, CanAccessVectorElements) {
@@ -53,32 +53,32 @@ TEST(Vector, AccessingOutOfRangeThrows) {
 }
 
 TEST(Vector, CrossProduct2DHasOnlyZElement) {
-  EXPECT_THAT((vec2i{{1,1}}.cross(vec2i{{-1,1}})), (vec3i{{0,0,2}}));
+  EXPECT_THAT(vec2i({1,1}).cross(vec2i({-1,1})), vec3i({0,0,2}));
 }
 
 TEST(Vector, CrossProduct3DHasAllElements) {
-  EXPECT_THAT((vec3i{{1,1,2}}.cross(vec3i{{-1,1,1}})), (vec3i{{-1,-3,2}}));
+  EXPECT_THAT(vec3i({1,1,2}).cross(vec3i({-1,1,1})), vec3i({-1,-3,2}));
 }
 
 TEST(Vector, AdditionIsPiecewise) {
-  EXPECT_THAT((vec2i{{1,0}} + vec2i{{0,1}}), (vec2i{{1,1}}));
+  EXPECT_THAT((vec2i{{1,0}} + vec2i{{0,1}}), vec2i({1,1}));
 }
 
 TEST(Vector, SubtractionIsPiecewise) {
-  EXPECT_THAT((vec2i{{1,0}} - vec2i{{0,1}}), (vec2i{{1,-1}}));
+  EXPECT_THAT((vec2i{{1,0}} - vec2i{{0,1}}), vec2i({1,-1}));
 }
 
 TEST(Vector, MultiplicationIsPiecewise) {
-  EXPECT_THAT((vec2i{{1,0}}*(vec2i{{2,1}})), (vec2i{{2,0}}));
+  EXPECT_THAT((vec2i{{1,0}}*vec2i({2,1})), vec2i({2,0}));
 }
 
 TEST(Vector, DivisionIsPiecewise) {
-  EXPECT_THAT((vec2i{{6,4}}/(vec2i{{2,1}})), (vec2i{{3,4}}));
+  EXPECT_THAT((vec2i{{6,4}}/vec2i({2,1})), vec2i({3,4}));
 }
 
 TEST(Vector, DivisionByZeroThrowsException) {
   EXPECT_THROW(vec3{} / 0, std::domain_error);
-  EXPECT_THROW((vec3{{1.0, 1.0, 1.0}}/(vec3{{1.0, 0.5, 0.0}})), std::domain_error);
+  EXPECT_THROW((vec3{{1.0, 1.0, 1.0}}/vec3({1.0, 0.5, 0.0})), std::domain_error);
 }
 
 //  TEST(Vector, AdditionWithValueType) {
@@ -92,12 +92,12 @@ TEST(Vector, DivisionByZeroThrowsException) {
 //  }
 
 TEST(Vector, MultiplicationWithValueType) {
-  EXPECT_THAT((vec2i{{1,0}} * 3), (vec2i{{3,0}}));
-  EXPECT_THAT(2*iota2i(), (vec2i{{2,4}}));
+  EXPECT_THAT((vec2i{{1,0}} * 3), vec2i({3,0}));
+  EXPECT_THAT(2*iota2i(), vec2i({2,4}));
 }
 
 TEST(Vector, DivisionWithValueType) {
-  EXPECT_THAT((vec2i{{6,4}} / 2), (vec2i{{3,2}}));
+  EXPECT_THAT((vec2i{{6,4}} / 2), vec2i({3,2}));
 //  EXPECT_THAT(4/iota2i(), (vec2i{4,2}));
 }
 
@@ -109,17 +109,17 @@ TEST(Vector, Length) {
 
 TEST(Vector, Distance) {
   //    EXPECT_THAT((iota3i().distanceSquared(vec3i{3, 1, -1})), 21);
-  EXPECT_THAT((iota3i() - vec3i{{3, 1, -1}}).magnitude(),
+  EXPECT_THAT((iota3i() - vec3i({3, 1, -1})).magnitude(),
               ::testing::DoubleNear(std::sqrt(21), 0.00001));
 }
 
 TEST(Vector, Projection) {
-  EXPECT_THAT((iota3i().projection(vec3i{{3, 1, -1}})).magnitude(),
+  EXPECT_THAT(iota3i().projection(vec3i({3, 1, -1})).magnitude(),
               ::testing::DoubleNear(std::sqrt(4.0/11.0), 0.00001));
 }
 
 TEST(Vector, DotProductIsSumOfElementProducts) {
-  EXPECT_THAT((iota3i().dot(vec3i{{3, 0, -1}})), 0);
+  EXPECT_THAT(iota3i().dot(vec3i({3, 0, -1})), 0);
 }
 
 TEST(Vector, UnitFunctionCreatesNewVectorOverMagnitude) {
@@ -131,7 +131,7 @@ TEST(Vector, UnitFunctionCreatesNewVectorOverMagnitude) {
 }
 
 TEST(Vector, CanCastEntireVectorThroughConstructor) {
-  EXPECT_THAT((vec3i(vec3{{1.0, 2.3, 3.9}})), iota3i());
+  EXPECT_THAT(vec3i(vec3({1.0, 2.3, 3.9})), iota3i());
 }
 
 TEST(Vector, SwapExchangesAllValues) {
@@ -144,7 +144,7 @@ TEST(Vector, SwapExchangesAllValues) {
 }
 
 TEST(Vector, UnaryNegateOperatorNegatesAllElements) {
-  EXPECT_THAT(-iota3i(), (vec3i{{-1,-2,-3}}));
+  EXPECT_THAT(-iota3i(), vec3i({-1,-2,-3}));
 }
 
 TEST(Vector, AbsoluteValueOfVectorAbsAllElements) {