diff --git a/Source/Common/Testing/imstkVecDataArrayTest.cpp b/Source/Common/Testing/imstkVecDataArrayTest.cpp
index ba654d22f9203a041cc0015601745ad286146c01..dac375967ba09147bd9a3d75ae62dd04585fabf4 100644
--- a/Source/Common/Testing/imstkVecDataArrayTest.cpp
+++ b/Source/Common/Testing/imstkVecDataArrayTest.cpp
@@ -60,10 +60,10 @@ TEST(imstkVecDataArrayTest, Constructors)
     EXPECT_EQ(2, a.getCapacity());
     EXPECT_EQ(2, a.getNumberOfComponents());
 
-    VecDataArray<int, 2> b{ imstk::Vec2i{ 0, 1 }, { 2, 3 } };
+    VecDataArray<int, 2> b{ Vec2i(0, 1), Vec2i(2, 3) };
     EXPECT_EQ(2, b.size());
     EXPECT_EQ(4, b.getCapacity());
-    EXPECT_TRUE(isEqualTo(b, { imstk::Vec2i{ 0, 1, }, { 2, 3 } }));
+    EXPECT_TRUE(isEqualTo(b, { Vec2i(0, 1), Vec2i(2, 3) }));
 
     VecDataArray<int, 2> c(128);
     EXPECT_EQ(128, c.size());
@@ -73,22 +73,22 @@ TEST(imstkVecDataArrayTest, Constructors)
     VecDataArray<int, 2> d(std::move(b));
     EXPECT_EQ(2, d.size());
     EXPECT_EQ(4, d.getCapacity());
-    EXPECT_TRUE(isEqualTo(d, { imstk::Vec2i{ 0, 1, }, { 2, 3 } }));
+    EXPECT_TRUE(isEqualTo(d, { Vec2i(0, 1), Vec2i(2, 3) }));
     EXPECT_EQ(ptr, d.getPointer());
 }
 
 TEST(imstkVecDataArrayTest, Assignment)
 {
     VecDataArray<int, 2> a;
-    a = { imstk::Vec2i{ 1, 2, }, { 3, 4 }, { 5, 6 } };
+    a = { Vec2i(1, 2), Vec2i(3, 4), Vec2i(5, 6) };
     EXPECT_EQ(3, a.size());
     EXPECT_EQ(3 * 2, a.getCapacity());
-    EXPECT_TRUE(isEqualTo(a, { imstk::Vec2i{ 1, 2, }, { 3, 4 }, { 5, 6 } }));
+    EXPECT_TRUE(isEqualTo(a, { Vec2i(1, 2), Vec2i(3, 4), Vec2i(5, 6) }));
 
-    VecDataArray<int, 2> b{ imstk::Vec2i{ 0, 2, }, { 4, 6 } };
+    VecDataArray<int, 2> b{ Vec2i(0, 2), Vec2i(4, 6) };
 
     b = a;
-    EXPECT_TRUE(isEqualTo(b, { imstk::Vec2i{ 1, 2, }, { 3, 4 }, { 5, 6 } }));
+    EXPECT_TRUE(isEqualTo(b, { Vec2i(1, 2), Vec2i(3, 4), Vec2i(5, 6) }));
     EXPECT_EQ(a.size(), b.size());
     EXPECT_EQ(a.getCapacity(), b.getCapacity());
     EXPECT_NE(a.getPointer(), b.getPointer());
@@ -96,18 +96,18 @@ TEST(imstkVecDataArrayTest, Assignment)
 
 TEST(imstkVecDataArrayTest, Mapping)
 {
-    std::vector<imstk::Vec2i> other{ { -1, -2, }, { -3, -4 } };
+    std::vector<Vec2i> other{ { -1, -2, }, { -3, -4 } };
     {
-        VecDataArray<int, 2> a{ imstk::Vec2i{ 1, 2, } };
+        VecDataArray<int, 2> a{ Vec2i(1, 2) };
         a.setData(other.data(), static_cast<int>(other.size()));
         EXPECT_EQ(2, a.size());
         EXPECT_EQ(2 * 2, a.getCapacity());
-        EXPECT_TRUE(isEqualTo(a, { imstk::Vec2i{ -1, -2, }, { -3, -4 } }));
+        EXPECT_TRUE(isEqualTo(a, { Vec2i(-1, -2), Vec2i(-3, -4) }));
         EXPECT_EQ(other.data(), a.getPointer());
 
         VecDataArray<int, 2> b = a;
         EXPECT_EQ(2, b.size());
-        EXPECT_TRUE(isEqualTo(b, { imstk::Vec2i{ -1, -2, }, { -3, -4 } }));
+        EXPECT_TRUE(isEqualTo(b, { Vec2i(-1, -2), Vec2i(-3, -4) }));
         EXPECT_EQ(other.data(), b.getPointer());
     }
 }
@@ -141,7 +141,7 @@ TEST(imstkVecDataArrayTest, CapacityManagement)
         EXPECT_EQ(1 * 2, a.getCapacity());
     }
     {
-        VecDataArray<int, 2> a{ imstk::Vec2i{ 0, 2, }, { 4, 6 } };
+        VecDataArray<int, 2> a{ Vec2i(0, 2), Vec2i(4, 6) };
         a.reserve(256);
         EXPECT_EQ(2, a.size());
         EXPECT_EQ(256 * 2, a.getCapacity());
@@ -165,13 +165,13 @@ TEST(imstkVecDataArrayTest, Iterators)
     auto itBegin = a.begin();
     auto itEnd   = a.end();
     EXPECT_EQ(itBegin, itEnd);
-    a = { imstk::Vec2i{ 1, 1 }, { 2, 2 }, { 3, 3 } };
+    a = { Vec2i(1, 1), Vec2i(2, 2), Vec2i(3, 3) };
     auto it = a.begin();
     itEnd = a.end();
     int expected = 1;
     while (it != itEnd)
     {
-        EXPECT_EQ(imstk::Vec2i(expected, expected), *it);
+        EXPECT_EQ(Vec2i(expected, expected), *it);
         ++it;
         ++expected;
     }
@@ -179,17 +179,17 @@ TEST(imstkVecDataArrayTest, Iterators)
 
 TEST(imstkVecDataArrayTest, ConstructorCast)
 {
-    VecDataArray<long, 2> a{ Vec2i{ 1, 2 }, { 3, 4 } };
+    VecDataArray<long, 2> a{ Vec2i(1, 2), Vec2i(3, 4) };
     EXPECT_EQ(Vec2i(1, 2), a[0].cast<int>());
 }
 
 TEST(imstkVecDataArrayTest, Erase)
 {
-    VecDataArray<int, 2> a{ imstk::Vec2i{ 1, 1 }, { 2, 2 }, { 3, 3 }, { 4, 4 } };
+    VecDataArray<int, 2> a{ Vec2i(1, 1), Vec2i(2, 2), Vec2i(3, 3), Vec2i(4, 4) };
     a.erase(1);
     EXPECT_EQ(3, a.size());
     EXPECT_EQ(8, a.getCapacity());
-    EXPECT_TRUE(isEqualTo(a, { imstk::Vec2i{ 1, 1, }, { 3, 3 }, { 4, 4 } }));
+    EXPECT_TRUE(isEqualTo(a, { Vec2i(1, 1), Vec2i(3, 3), Vec2i(4, 4) }));
     EXPECT_EQ(8, a.getCapacity());
     a.erase(-1);
     EXPECT_EQ(3, a.size());
@@ -197,7 +197,7 @@ TEST(imstkVecDataArrayTest, Erase)
     EXPECT_EQ(3, a.size());
     a.erase(1);
     a.erase(0);
-    EXPECT_TRUE(isEqualTo(a, { imstk::Vec2i{ 4, 4, } }));
+    EXPECT_TRUE(isEqualTo(a, { Vec2i(4, 4) }));
     EXPECT_EQ(8, a.getCapacity());
     a.erase(0);
     EXPECT_EQ(0, a.size());