diff --git a/thrust/testing/swap_ranges.cu b/thrust/testing/swap_ranges.cu
index cf1e541d08..53aaf9e542 100644
--- a/thrust/testing/swap_ranges.cu
+++ b/thrust/testing/swap_ranges.cu
@@ -44,33 +44,16 @@ DECLARE_UNITTEST(TestSwapRangesDispatchImplicit);
 template <class Vector>
 void TestSwapRangesSimple()
 {
-  Vector v1(5);
-  v1[0] = 0;
-  v1[1] = 1;
-  v1[2] = 2;
-  v1[3] = 3;
-  v1[4] = 4;
-
-  Vector v2(5);
-  v2[0] = 5;
-  v2[1] = 6;
-  v2[2] = 7;
-  v2[3] = 8;
-  v2[4] = 9;
+  Vector v1{0, 1, 2, 3, 4};
+  Vector v2{5, 6, 7, 8, 9};
 
   thrust::swap_ranges(v1.begin(), v1.end(), v2.begin());
 
-  ASSERT_EQUAL(v1[0], 5);
-  ASSERT_EQUAL(v1[1], 6);
-  ASSERT_EQUAL(v1[2], 7);
-  ASSERT_EQUAL(v1[3], 8);
-  ASSERT_EQUAL(v1[4], 9);
-
-  ASSERT_EQUAL(v2[0], 0);
-  ASSERT_EQUAL(v2[1], 1);
-  ASSERT_EQUAL(v2[2], 2);
-  ASSERT_EQUAL(v2[3], 3);
-  ASSERT_EQUAL(v2[4], 4);
+  Vector ref1{5, 6, 7, 8, 9};
+  ASSERT_EQUAL(v1, ref1);
+
+  Vector ref2{0, 1, 2, 3, 4};
+  ASSERT_EQUAL(v2, ref2);
 }
 DECLARE_VECTOR_UNITTEST(TestSwapRangesSimple);
 
diff --git a/thrust/testing/tabulate.cu b/thrust/testing/tabulate.cu
index 2a4c5d6fee..c18007fade 100644
--- a/thrust/testing/tabulate.cu
+++ b/thrust/testing/tabulate.cu
@@ -48,27 +48,18 @@ void TestTabulateSimple()
 
   thrust::tabulate(v.begin(), v.end(), thrust::identity<T>());
 
-  ASSERT_EQUAL(v[0], 0);
-  ASSERT_EQUAL(v[1], 1);
-  ASSERT_EQUAL(v[2], 2);
-  ASSERT_EQUAL(v[3], 3);
-  ASSERT_EQUAL(v[4], 4);
+  Vector ref{0, 1, 2, 3, 4};
+  ASSERT_EQUAL(v, ref);
 
   thrust::tabulate(v.begin(), v.end(), -_1);
 
-  ASSERT_EQUAL(v[0], 0);
-  ASSERT_EQUAL(v[1], -1);
-  ASSERT_EQUAL(v[2], -2);
-  ASSERT_EQUAL(v[3], -3);
-  ASSERT_EQUAL(v[4], -4);
+  ref = {0, -1, -2, -3, -4};
+  ASSERT_EQUAL(v, ref);
 
   thrust::tabulate(v.begin(), v.end(), _1 * _1 * _1);
 
-  ASSERT_EQUAL(v[0], 0);
-  ASSERT_EQUAL(v[1], 1);
-  ASSERT_EQUAL(v[2], 8);
-  ASSERT_EQUAL(v[3], 27);
-  ASSERT_EQUAL(v[4], 64);
+  ref = {0, 1, 8, 27, 64};
+  ASSERT_EQUAL(v, ref);
 }
 DECLARE_VECTOR_UNITTEST(TestTabulateSimple);
 
diff --git a/thrust/testing/tabulate_output_iterator.cu b/thrust/testing/tabulate_output_iterator.cu
index 789ed6cf04..6d5351aec9 100644
--- a/thrust/testing/tabulate_output_iterator.cu
+++ b/thrust/testing/tabulate_output_iterator.cu
@@ -129,22 +129,16 @@ void TestTabulateOutputIterator()
   thrust::tabulate_output_iterator<op_t> tabulate_out_it{op_t{out.begin()}};
 
   tabulate_out_it[1] = 2;
-  ASSERT_EQUAL(out[0], 42);
-  ASSERT_EQUAL(out[1], 2);
-  ASSERT_EQUAL(out[2], 42);
-  ASSERT_EQUAL(out[3], 42);
+  vector_t ref{42, 2, 42, 42};
+  ASSERT_EQUAL(out, ref);
 
   tabulate_out_it[3] = 0;
-  ASSERT_EQUAL(out[0], 42);
-  ASSERT_EQUAL(out[1], 2);
-  ASSERT_EQUAL(out[2], 42);
-  ASSERT_EQUAL(out[3], 0);
+  ref                = {42, 2, 42, 0};
+  ASSERT_EQUAL(out, ref);
 
   tabulate_out_it[1] = 4;
-  ASSERT_EQUAL(out[0], 42);
-  ASSERT_EQUAL(out[1], 4);
-  ASSERT_EQUAL(out[2], 42);
-  ASSERT_EQUAL(out[3], 0);
+  ref                = {42, 4, 42, 0};
+  ASSERT_EQUAL(out, ref);
 }
 
 DECLARE_UNITTEST(TestTabulateOutputIterator);
diff --git a/thrust/testing/transform.cu b/thrust/testing/transform.cu
index 08a7a2ce91..ab5446344d 100644
--- a/thrust/testing/transform.cu
+++ b/thrust/testing/transform.cu
@@ -23,15 +23,9 @@ THRUST_DISABLE_BROKEN_GCC_VECTORIZER void TestTransformUnarySimple()
 
   typename Vector::iterator iter;
 
-  Vector input(3);
+  Vector input{1, -2, 3};
   Vector output(3);
-  Vector result(3);
-  input[0]  = 1;
-  input[1]  = -2;
-  input[2]  = 3;
-  result[0] = -1;
-  result[1] = 2;
-  result[2] = -3;
+  Vector result{-1, 2, -3};
 
   iter = thrust::transform(input.begin(), input.end(), output.begin(), thrust::negate<T>());
 
@@ -83,15 +77,9 @@ THRUST_DISABLE_BROKEN_GCC_VECTORIZER void TestTransformIfUnaryNoStencilSimple()
 
   typename Vector::iterator iter;
 
-  Vector input(3);
-  Vector output(3);
-  Vector result(3);
-
-  // clang-format off
-  input[0]   =  0; input[1]   = -2; input[2]   =  0;
-  output[0]  = -1; output[1]  = -2; output[2]  = -3;
-  result[0]  = -1; result[1]  =  2; result[2]  = -3;
-  // clang-format on
+  Vector input{0, -2, 0};
+  Vector output{-1, -2, -3};
+  Vector result{-1, 2, -3};
 
   iter = thrust::transform_if(input.begin(), input.end(), output.begin(), thrust::negate<T>(), thrust::identity<T>());
 
@@ -148,17 +136,10 @@ THRUST_DISABLE_BROKEN_GCC_VECTORIZER void TestTransformIfUnarySimple()
 
   typename Vector::iterator iter;
 
-  Vector input(3);
-  Vector stencil(3);
-  Vector output(3);
-  Vector result(3);
-
-  // clang-format off
-  input[0]   =  1; input[1]   = -2; input[2]   =  3;
-  output[0]  =  1; output[1]  =  2; output[2]  =  3;
-  stencil[0] =  1; stencil[1] =  0; stencil[2] =  1;
-  result[0]  = -1; result[1]  =  2; result[2]  = -3;
-  // clang-format on
+  Vector input{1, -2, 3};
+  Vector stencil{1, 0, 1};
+  Vector output{1, 2, 3};
+  Vector result{-1, 2, -3};
 
   iter = thrust::transform_if(
     input.begin(), input.end(), stencil.begin(), output.begin(), thrust::negate<T>(), thrust::identity<T>());
@@ -223,16 +204,10 @@ THRUST_DISABLE_BROKEN_GCC_VECTORIZER void TestTransformBinarySimple()
   // There is a strange gcc bug here where it belives we would write out of bounds.
   // It seems to go away if we add one more element that we leave untouched. Luckily 0 - 0 = 0 so all is fine.
   // Note that we still write the element, so it does not hide a functional thrust bug
-  Vector input1(4);
-  Vector input2(4);
-  Vector output(4);
-  Vector result(4);
-
-  // clang-format off
-  input1[0] =  1; input1[1] = -2; input1[2] =  3;
-  input2[0] = -4; input2[1] =  5; input2[2] =  6;
-  result[0] =  5; result[1] = -7; result[2] = -3;
-  // clang-format on
+  Vector input1{1, -2, 3};
+  Vector input2{-4, 5, 6};
+  Vector output(3);
+  Vector result{5, -7, -3};
 
   iter = thrust::transform(input1.begin(), input1.end(), input2.begin(), output.begin(), thrust::minus<T>());
 
@@ -289,19 +264,11 @@ THRUST_DISABLE_BROKEN_GCC_VECTORIZER void TestTransformIfBinarySimple()
 
   typename Vector::iterator iter;
 
-  Vector input1(3);
-  Vector input2(3);
-  Vector stencil(3);
-  Vector output(3);
-  Vector result(3);
-
-  // clang-format off
-  input1[0]  =  1; input1[1]  = -2; input1[2]  =  3;
-  input2[0]  = -4; input2[1]  =  5; input2[2]  =  6;
-  stencil[0] =  0; stencil[1] =  1; stencil[2] =  0;
-  output[0]  =  1; output[1]  =  2; output[2]  =  3;
-  result[0]  =  5; result[1]  =  2; result[2]  = -3;
-  // clang-format on
+  Vector input1{1, -2, 3};
+  Vector input2{-4, 5, 6};
+  Vector stencil{0, 1, 0};
+  Vector output{1, 2, 3};
+  Vector result{5, 2, -3};
 
   thrust::identity<T> identity;
 
@@ -768,37 +735,16 @@ THRUST_DISABLE_BROKEN_GCC_VECTORIZER void TestTransformWithIndirection()
   // add numbers modulo 3 with external lookup table
   using T = typename Vector::value_type;
 
-  Vector input1(7);
-  Vector input2(7);
+  Vector input1{0, 1, 2, 1, 2, 0, 1};
+  Vector input2{2, 2, 2, 0, 2, 1, 0};
   Vector output(7, 0);
 
-  // clang-format off
-  input1[0] = 0;  input2[0] = 2;
-  input1[1] = 1;  input2[1] = 2;
-  input1[2] = 2;  input2[2] = 2;
-  input1[3] = 1;  input2[3] = 0;
-  input1[4] = 2;  input2[4] = 2;
-  input1[5] = 0;  input2[5] = 1;
-  input1[6] = 1;  input2[6] = 0;
-  // clang-format on
-
-  Vector table(6);
-  table[0] = 0;
-  table[1] = 1;
-  table[2] = 2;
-  table[3] = 0;
-  table[4] = 1;
-  table[5] = 2;
+  Vector table{0, 1, 2, 0, 1, 2};
 
   thrust::transform(
     input1.begin(), input1.end(), input2.begin(), output.begin(), plus_mod3<T>(thrust::raw_pointer_cast(&table[0])));
 
-  ASSERT_EQUAL(output[0], T(2));
-  ASSERT_EQUAL(output[1], T(0));
-  ASSERT_EQUAL(output[2], T(1));
-  ASSERT_EQUAL(output[3], T(1));
-  ASSERT_EQUAL(output[4], T(1));
-  ASSERT_EQUAL(output[5], T(1));
-  ASSERT_EQUAL(output[6], T(1));
+  Vector ref{2, 0, 1, 1, 1, 1, 1};
+  ASSERT_EQUAL(output, ref);
 }
 DECLARE_INTEGRAL_VECTOR_UNITTEST(TestTransformWithIndirection);
diff --git a/thrust/testing/transform_input_output_iterator.cu b/thrust/testing/transform_input_output_iterator.cu
index 3f8ef2bdad..b49658208a 100644
--- a/thrust/testing/transform_input_output_iterator.cu
+++ b/thrust/testing/transform_input_output_iterator.cu
@@ -30,22 +30,14 @@ void TestTransformInputOutputIterator()
   // transform_iter writes squared value
   thrust::copy(input.begin(), input.end(), transform_iter);
 
-  Vector gold_squared(4);
-  gold_squared[0] = 1;
-  gold_squared[1] = 4;
-  gold_squared[2] = 9;
-  gold_squared[3] = 16;
+  Vector gold_squared{1, 4, 9, 16};
 
   ASSERT_EQUAL(squared, gold_squared);
 
   // negated value read from transform_iter
   thrust::copy_n(transform_iter, squared.size(), negated.begin());
 
-  Vector gold_negated(4);
-  gold_negated[0] = -1;
-  gold_negated[1] = -4;
-  gold_negated[2] = -9;
-  gold_negated[3] = -16;
+  Vector gold_negated{-1, -4, -9, -16};
 
   ASSERT_EQUAL(negated, gold_negated);
 }
@@ -71,11 +63,7 @@ void TestMakeTransformInputOutputIterator()
                  input.size(),
                  negated.begin());
 
-  Vector gold_negated(4);
-  gold_negated[0] = -1;
-  gold_negated[1] = -2;
-  gold_negated[2] = -3;
-  gold_negated[3] = -4;
+  Vector gold_negated{-1, -2, -3, -4};
 
   ASSERT_EQUAL(negated, gold_negated);
 
@@ -84,11 +72,7 @@ void TestMakeTransformInputOutputIterator()
                negated.end(),
                thrust::make_transform_input_output_iterator(squared.begin(), InputFunction(), OutputFunction()));
 
-  Vector gold_squared(4);
-  gold_squared[0] = 1;
-  gold_squared[1] = 4;
-  gold_squared[2] = 9;
-  gold_squared[3] = 16;
+  Vector gold_squared{1, 4, 9, 16};
 
   ASSERT_EQUAL(squared, gold_squared);
 }
diff --git a/thrust/testing/transform_iterator.cu b/thrust/testing/transform_iterator.cu
index 53bc4db00a..4284ad06c3 100644
--- a/thrust/testing/transform_iterator.cu
+++ b/thrust/testing/transform_iterator.cu
@@ -29,10 +29,8 @@ void TestTransformIterator()
 
   thrust::copy(iter, iter + 4, output.begin());
 
-  ASSERT_EQUAL(output[0], -1);
-  ASSERT_EQUAL(output[1], -2);
-  ASSERT_EQUAL(output[2], -3);
-  ASSERT_EQUAL(output[3], -4);
+  Vector ref{-1, -2, -3, -4};
+  ASSERT_EQUAL(output, ref);
 }
 DECLARE_VECTOR_UNITTEST(TestTransformIterator);
 
@@ -57,10 +55,8 @@ void TestMakeTransformIterator()
                thrust::make_transform_iterator(input.end(), UnaryFunction()),
                output.begin());
 
-  ASSERT_EQUAL(output[0], -1);
-  ASSERT_EQUAL(output[1], -2);
-  ASSERT_EQUAL(output[2], -3);
-  ASSERT_EQUAL(output[3], -4);
+  Vector ref{-1, -2, -3, -4};
+  ASSERT_EQUAL(output, ref);
 }
 DECLARE_VECTOR_UNITTEST(TestMakeTransformIterator);
 
diff --git a/thrust/testing/transform_output_iterator.cu b/thrust/testing/transform_output_iterator.cu
index 651eca0b59..d322b19333 100644
--- a/thrust/testing/transform_output_iterator.cu
+++ b/thrust/testing/transform_output_iterator.cu
@@ -28,11 +28,7 @@ void TestTransformOutputIterator()
 
   thrust::copy(input.begin(), input.end(), output_iter);
 
-  Vector gold_output(4);
-  gold_output[0] = 1;
-  gold_output[1] = 4;
-  gold_output[2] = 9;
-  gold_output[3] = 16;
+  Vector gold_output{1, 4, 9, 16};
 
   ASSERT_EQUAL(output, gold_output);
 }
@@ -53,11 +49,7 @@ void TestMakeTransformOutputIterator()
 
   thrust::copy(input.begin(), input.end(), thrust::make_transform_output_iterator(output.begin(), UnaryFunction()));
 
-  Vector gold_output(4);
-  gold_output[0] = 1;
-  gold_output[1] = 4;
-  gold_output[2] = 9;
-  gold_output[3] = 16;
+  Vector gold_output{1, 4, 9, 16};
   ASSERT_EQUAL(output, gold_output);
 }
 DECLARE_VECTOR_UNITTEST(TestMakeTransformOutputIterator);
diff --git a/thrust/testing/transform_reduce.cu b/thrust/testing/transform_reduce.cu
index 89ecea6e7d..c241aad77c 100644
--- a/thrust/testing/transform_reduce.cu
+++ b/thrust/testing/transform_reduce.cu
@@ -46,10 +46,7 @@ void TestTransformReduceSimple()
 {
   using T = typename Vector::value_type;
 
-  Vector data(3);
-  data[0] = 1;
-  data[1] = -2;
-  data[2] = 3;
+  Vector data{1, -2, 3};
 
   T init   = 10;
   T result = thrust::transform_reduce(data.begin(), data.end(), thrust::negate<T>(), init, thrust::plus<T>());
diff --git a/thrust/testing/trivial_sequence.cu b/thrust/testing/trivial_sequence.cu
index 2ceec431d9..7438b7e406 100644
--- a/thrust/testing/trivial_sequence.cu
+++ b/thrust/testing/trivial_sequence.cu
@@ -33,32 +33,16 @@ void test(Iterator first, Iterator last)
 template <class Vector>
 void TestTrivialSequence()
 {
-  Vector A(5);
-  A[0] = 0;
-  A[1] = 2;
-  A[2] = 1;
-  A[3] = 0;
-  A[4] = 1;
-  Vector B(5);
-  B[0] = 11;
-  B[1] = 11;
-  B[2] = 13;
-  B[3] = 10;
-  B[4] = 12;
+  Vector A{0, 2, 1, 0, 1};
+  Vector B{11, 11, 13, 10, 12};
 
   test(thrust::make_zip_iterator(thrust::make_tuple(A.begin(), B.begin())),
        thrust::make_zip_iterator(thrust::make_tuple(A.end(), B.end())));
 
+  Vector refA{0, 2, 1, 0, 1};
+  ASSERT_EQUAL(A, refA);
   // ensure that values weren't modified
-  ASSERT_EQUAL(A[0], 0);
-  ASSERT_EQUAL(B[0], 11);
-  ASSERT_EQUAL(A[1], 2);
-  ASSERT_EQUAL(B[1], 11);
-  ASSERT_EQUAL(A[2], 1);
-  ASSERT_EQUAL(B[2], 13);
-  ASSERT_EQUAL(A[3], 0);
-  ASSERT_EQUAL(B[3], 10);
-  ASSERT_EQUAL(A[4], 1);
-  ASSERT_EQUAL(B[4], 12);
+  Vector refB{11, 11, 13, 10, 12};
+  ASSERT_EQUAL(B, refB);
 }
 DECLARE_VECTOR_UNITTEST(TestTrivialSequence);
diff --git a/thrust/testing/uninitialized_copy.cu b/thrust/testing/uninitialized_copy.cu
index d6b45a9815..74743bd7dd 100644
--- a/thrust/testing/uninitialized_copy.cu
+++ b/thrust/testing/uninitialized_copy.cu
@@ -79,42 +79,26 @@ DECLARE_UNITTEST(TestUninitializedCopyNDispatchImplicit);
 template <class Vector>
 void TestUninitializedCopySimplePOD()
 {
-  Vector v1(5);
-  v1[0] = 0;
-  v1[1] = 1;
-  v1[2] = 2;
-  v1[3] = 3;
-  v1[4] = 4;
+  Vector v1{0, 1, 2, 3, 4};
 
   // copy to Vector
   Vector v2(5);
   thrust::uninitialized_copy(v1.begin(), v1.end(), v2.begin());
-  ASSERT_EQUAL(v2[0], 0);
-  ASSERT_EQUAL(v2[1], 1);
-  ASSERT_EQUAL(v2[2], 2);
-  ASSERT_EQUAL(v2[3], 3);
-  ASSERT_EQUAL(v2[4], 4);
+  Vector ref{0, 1, 2, 3, 4};
+  ASSERT_EQUAL(v2, ref);
 }
 DECLARE_VECTOR_UNITTEST(TestUninitializedCopySimplePOD);
 
 template <typename Vector>
 void TestUninitializedCopyNSimplePOD()
 {
-  Vector v1(5);
-  v1[0] = 0;
-  v1[1] = 1;
-  v1[2] = 2;
-  v1[3] = 3;
-  v1[4] = 4;
+  Vector v1{0, 1, 2, 3, 4};
 
   // copy to Vector
   Vector v2(5);
   thrust::uninitialized_copy_n(v1.begin(), v1.size(), v2.begin());
-  ASSERT_EQUAL(v2[0], 0);
-  ASSERT_EQUAL(v2[1], 1);
-  ASSERT_EQUAL(v2[2], 2);
-  ASSERT_EQUAL(v2[3], 3);
-  ASSERT_EQUAL(v2[4], 4);
+  Vector ref{0, 1, 2, 3, 4};
+  ASSERT_EQUAL(v2, ref);
 }
 DECLARE_VECTOR_UNITTEST(TestUninitializedCopyNSimplePOD);
 
diff --git a/thrust/testing/uninitialized_fill.cu b/thrust/testing/uninitialized_fill.cu
index b3b8e7110f..175f1f6a16 100644
--- a/thrust/testing/uninitialized_fill.cu
+++ b/thrust/testing/uninitialized_fill.cu
@@ -79,52 +79,35 @@ void TestUninitializedFillPOD()
 {
   using T = typename Vector::value_type;
 
-  Vector v(5);
-  v[0] = 0;
-  v[1] = 1;
-  v[2] = 2;
-  v[3] = 3;
-  v[4] = 4;
+  Vector v{0, 1, 2, 3, 4};
 
   T exemplar(7);
 
   thrust::uninitialized_fill(v.begin() + 1, v.begin() + 4, exemplar);
 
-  ASSERT_EQUAL(v[0], 0);
-  ASSERT_EQUAL(v[1], exemplar);
-  ASSERT_EQUAL(v[2], exemplar);
-  ASSERT_EQUAL(v[3], exemplar);
-  ASSERT_EQUAL(v[4], 4);
+  Vector ref{0, exemplar, exemplar, exemplar, 4};
+  ASSERT_EQUAL(v, ref);
 
   exemplar = 8;
 
   thrust::uninitialized_fill(v.begin() + 0, v.begin() + 3, exemplar);
 
-  ASSERT_EQUAL(v[0], exemplar);
-  ASSERT_EQUAL(v[1], exemplar);
-  ASSERT_EQUAL(v[2], exemplar);
-  ASSERT_EQUAL(v[3], 7);
-  ASSERT_EQUAL(v[4], 4);
+  ref = {exemplar, exemplar, exemplar, 7, 4};
+  ASSERT_EQUAL(v, ref);
 
   exemplar = 9;
 
   thrust::uninitialized_fill(v.begin() + 2, v.end(), exemplar);
 
-  ASSERT_EQUAL(v[0], 8);
-  ASSERT_EQUAL(v[1], 8);
-  ASSERT_EQUAL(v[2], exemplar);
-  ASSERT_EQUAL(v[3], exemplar);
-  ASSERT_EQUAL(v[4], 9);
+  ref = {8, 8, exemplar, exemplar, 9};
+  ASSERT_EQUAL(v, ref);
 
   exemplar = 1;
 
   thrust::uninitialized_fill(v.begin(), v.end(), exemplar);
 
-  ASSERT_EQUAL(v[0], exemplar);
-  ASSERT_EQUAL(v[1], exemplar);
-  ASSERT_EQUAL(v[2], exemplar);
-  ASSERT_EQUAL(v[3], exemplar);
-  ASSERT_EQUAL(v[4], exemplar);
+  ref = {exemplar, exemplar, exemplar, exemplar, exemplar};
+  ASSERT_EQUAL(v, ref);
 }
 DECLARE_VECTOR_UNITTEST(TestUninitializedFillPOD);
 
@@ -189,55 +172,34 @@ void TestUninitializedFillNPOD()
 {
   using T = typename Vector::value_type;
 
-  Vector v(5);
-  v[0] = 0;
-  v[1] = 1;
-  v[2] = 2;
-  v[3] = 3;
-  v[4] = 4;
+  Vector v{0, 1, 2, 3, 4};
 
   T exemplar(7);
 
   typename Vector::iterator iter = thrust::uninitialized_fill_n(v.begin() + 1, 3, exemplar);
 
-  ASSERT_EQUAL(v[0], 0);
-  ASSERT_EQUAL(v[1], exemplar);
-  ASSERT_EQUAL(v[2], exemplar);
-  ASSERT_EQUAL(v[3], exemplar);
-  ASSERT_EQUAL(v[4], 4);
+  Vector ref{0, exemplar, exemplar, exemplar, 4};
   ASSERT_EQUAL_QUIET(v.begin() + 4, iter);
 
   exemplar = 8;
 
   iter = thrust::uninitialized_fill_n(v.begin() + 0, 3, exemplar);
 
-  ASSERT_EQUAL(v[0], exemplar);
-  ASSERT_EQUAL(v[1], exemplar);
-  ASSERT_EQUAL(v[2], exemplar);
-  ASSERT_EQUAL(v[3], 7);
-  ASSERT_EQUAL(v[4], 4);
+  ref = {exemplar, exemplar, exemplar, 7, 4};
   ASSERT_EQUAL_QUIET(v.begin() + 3, iter);
 
   exemplar = 9;
 
   iter = thrust::uninitialized_fill_n(v.begin() + 2, 3, exemplar);
 
-  ASSERT_EQUAL(v[0], 8);
-  ASSERT_EQUAL(v[1], 8);
-  ASSERT_EQUAL(v[2], exemplar);
-  ASSERT_EQUAL(v[3], exemplar);
-  ASSERT_EQUAL(v[4], 9);
+  ref = {8, 8, exemplar, exemplar, 9};
   ASSERT_EQUAL_QUIET(v.end(), iter);
 
   exemplar = 1;
 
   iter = thrust::uninitialized_fill_n(v.begin(), v.size(), exemplar);
 
-  ASSERT_EQUAL(v[0], exemplar);
-  ASSERT_EQUAL(v[1], exemplar);
-  ASSERT_EQUAL(v[2], exemplar);
-  ASSERT_EQUAL(v[3], exemplar);
-  ASSERT_EQUAL(v[4], exemplar);
+  ref = {exemplar, exemplar, exemplar, exemplar, exemplar};
   ASSERT_EQUAL_QUIET(v.end(), iter);
 }
 DECLARE_VECTOR_UNITTEST(TestUninitializedFillNPOD);
diff --git a/thrust/testing/unique.cu b/thrust/testing/unique.cu
index cd886879ef..b62b20f5b2 100644
--- a/thrust/testing/unique.cu
+++ b/thrust/testing/unique.cu
@@ -125,37 +125,24 @@ void TestUniqueSimple()
 {
   using T = typename Vector::value_type;
 
-  Vector data(10);
-  data[0] = 11;
-  data[1] = 11;
-  data[2] = 12;
-  data[3] = 20;
-  data[4] = 29;
-  data[5] = 21;
-  data[6] = 21;
-  data[7] = 31;
-  data[8] = 31;
-  data[9] = 37;
+  Vector data{11, 11, 12, 20, 29, 21, 21, 31, 31, 37};
 
   typename Vector::iterator new_last;
 
   new_last = thrust::unique(data.begin(), data.end());
 
   ASSERT_EQUAL(new_last - data.begin(), 7);
-  ASSERT_EQUAL(data[0], 11);
-  ASSERT_EQUAL(data[1], 12);
-  ASSERT_EQUAL(data[2], 20);
-  ASSERT_EQUAL(data[3], 29);
-  ASSERT_EQUAL(data[4], 21);
-  ASSERT_EQUAL(data[5], 31);
-  ASSERT_EQUAL(data[6], 37);
+  data.resize(7);
+  Vector ref{11, 12, 20, 29, 21, 31, 37};
+  ASSERT_EQUAL(data, ref);
 
   new_last = thrust::unique(data.begin(), new_last, is_equal_div_10_unique<T>());
 
   ASSERT_EQUAL(new_last - data.begin(), 3);
-  ASSERT_EQUAL(data[0], 11);
-  ASSERT_EQUAL(data[1], 20);
-  ASSERT_EQUAL(data[2], 31);
+  ref.resize(3);
+  data.resize(3);
+  ref = {11, 20, 31};
+  ASSERT_EQUAL(data, ref);
 }
 DECLARE_INTEGRAL_VECTOR_UNITTEST(TestUniqueSimple);
 
@@ -188,18 +175,7 @@ void TestUniqueCopySimple()
 {
   using T = typename Vector::value_type;
 
-  Vector data(10);
-  data[0] = 11;
-  data[1] = 11;
-  data[2] = 12;
-  data[3] = 20;
-  data[4] = 29;
-  data[5] = 21;
-  data[6] = 21;
-  data[7] = 31;
-  data[8] = 31;
-  data[9] = 37;
-
+  Vector data{11, 11, 12, 20, 29, 21, 21, 31, 31, 37};
   Vector output(10, -1);
 
   typename Vector::iterator new_last;
@@ -207,20 +183,17 @@ void TestUniqueCopySimple()
   new_last = thrust::unique_copy(data.begin(), data.end(), output.begin());
 
   ASSERT_EQUAL(new_last - output.begin(), 7);
-  ASSERT_EQUAL(output[0], 11);
-  ASSERT_EQUAL(output[1], 12);
-  ASSERT_EQUAL(output[2], 20);
-  ASSERT_EQUAL(output[3], 29);
-  ASSERT_EQUAL(output[4], 21);
-  ASSERT_EQUAL(output[5], 31);
-  ASSERT_EQUAL(output[6], 37);
+  output.resize(7);
+  Vector ref{11, 12, 20, 29, 21, 31, 37};
+  ASSERT_EQUAL(output, ref);
 
   new_last = thrust::unique_copy(output.begin(), new_last, data.begin(), is_equal_div_10_unique<T>());
 
   ASSERT_EQUAL(new_last - data.begin(), 3);
-  ASSERT_EQUAL(data[0], 11);
-  ASSERT_EQUAL(data[1], 20);
-  ASSERT_EQUAL(data[2], 31);
+  ref.resize(3);
+  data.resize(3);
+  ref = {11, 20, 31};
+  ASSERT_EQUAL(data, ref);
 }
 DECLARE_INTEGRAL_VECTOR_UNITTEST(TestUniqueCopySimple);
 
@@ -284,17 +257,7 @@ void TestUniqueCountSimple()
 {
   using T = typename Vector::value_type;
 
-  Vector data(10);
-  data[0] = 11;
-  data[1] = 11;
-  data[2] = 12;
-  data[3] = 20;
-  data[4] = 29;
-  data[5] = 21;
-  data[6] = 21;
-  data[7] = 31;
-  data[8] = 31;
-  data[9] = 37;
+  Vector data{11, 11, 12, 20, 29, 21, 21, 31, 31, 37};
 
   int count = thrust::unique_count(data.begin(), data.end());
 
diff --git a/thrust/testing/unique_by_key.cu b/thrust/testing/unique_by_key.cu
index 8657cc8c5b..942c0bcdd6 100644
--- a/thrust/testing/unique_by_key.cu
+++ b/thrust/testing/unique_by_key.cu
@@ -120,30 +120,14 @@ template <typename Vector>
 void initialize_keys(Vector& keys)
 {
   keys.resize(9);
-  keys[0] = 11;
-  keys[1] = 11;
-  keys[2] = 21;
-  keys[3] = 20;
-  keys[4] = 21;
-  keys[5] = 21;
-  keys[6] = 21;
-  keys[7] = 37;
-  keys[8] = 37;
+  keys = {11, 11, 21, 20, 21, 21, 21, 37, 37};
 }
 
 template <typename Vector>
 void initialize_values(Vector& values)
 {
   values.resize(9);
-  values[0] = 0;
-  values[1] = 1;
-  values[2] = 2;
-  values[3] = 3;
-  values[4] = 4;
-  values[5] = 5;
-  values[6] = 6;
-  values[7] = 7;
-  values[8] = 8;
+  values = {0, 1, 2, 3, 4, 5, 6, 7, 8};
 }
 
 template <typename Vector>
@@ -164,17 +148,13 @@ void TestUniqueByKeySimple()
 
   ASSERT_EQUAL(new_last.first - keys.begin(), 5);
   ASSERT_EQUAL(new_last.second - values.begin(), 5);
-  ASSERT_EQUAL(keys[0], 11);
-  ASSERT_EQUAL(keys[1], 21);
-  ASSERT_EQUAL(keys[2], 20);
-  ASSERT_EQUAL(keys[3], 21);
-  ASSERT_EQUAL(keys[4], 37);
-
-  ASSERT_EQUAL(values[0], 0);
-  ASSERT_EQUAL(values[1], 2);
-  ASSERT_EQUAL(values[2], 3);
-  ASSERT_EQUAL(values[3], 4);
-  ASSERT_EQUAL(values[4], 7);
+  keys.resize(5);
+  values.resize(5);
+  Vector keys_ref{11, 21, 20, 21, 37};
+  ASSERT_EQUAL(keys, keys_ref);
+
+  Vector values_ref{0, 2, 3, 4, 7};
+  ASSERT_EQUAL(values, values_ref);
 
   // test BinaryPredicate
   initialize_keys(keys);
@@ -184,13 +164,15 @@ void TestUniqueByKeySimple()
 
   ASSERT_EQUAL(new_last.first - keys.begin(), 3);
   ASSERT_EQUAL(new_last.second - values.begin(), 3);
-  ASSERT_EQUAL(keys[0], 11);
-  ASSERT_EQUAL(keys[1], 21);
-  ASSERT_EQUAL(keys[2], 37);
-
-  ASSERT_EQUAL(values[0], 0);
-  ASSERT_EQUAL(values[1], 2);
-  ASSERT_EQUAL(values[2], 7);
+  keys_ref.resize(3);
+  keys.resize(3);
+  keys_ref = {11, 21, 37};
+  ASSERT_EQUAL(keys, keys_ref);
+
+  values.resize(3);
+  values_ref.resize(3);
+  values_ref = {0, 2, 7};
+  ASSERT_EQUAL(values, values_ref);
 }
 DECLARE_INTEGRAL_VECTOR_UNITTEST(TestUniqueByKeySimple);
 
@@ -216,17 +198,13 @@ void TestUniqueCopyByKeySimple()
 
   ASSERT_EQUAL(new_last.first - output_keys.begin(), 5);
   ASSERT_EQUAL(new_last.second - output_values.begin(), 5);
-  ASSERT_EQUAL(output_keys[0], 11);
-  ASSERT_EQUAL(output_keys[1], 21);
-  ASSERT_EQUAL(output_keys[2], 20);
-  ASSERT_EQUAL(output_keys[3], 21);
-  ASSERT_EQUAL(output_keys[4], 37);
-
-  ASSERT_EQUAL(output_values[0], 0);
-  ASSERT_EQUAL(output_values[1], 2);
-  ASSERT_EQUAL(output_values[2], 3);
-  ASSERT_EQUAL(output_values[3], 4);
-  ASSERT_EQUAL(output_values[4], 7);
+  output_keys.resize(5);
+  output_values.resize(5);
+  Vector keys_ref{11, 21, 20, 21, 37};
+  ASSERT_EQUAL(output_keys, keys_ref);
+
+  Vector values_ref{0, 2, 3, 4, 7};
+  ASSERT_EQUAL(output_values, values_ref);
 
   // test BinaryPredicate
   initialize_keys(keys);
@@ -237,13 +215,14 @@ void TestUniqueCopyByKeySimple()
 
   ASSERT_EQUAL(new_last.first - output_keys.begin(), 3);
   ASSERT_EQUAL(new_last.second - output_values.begin(), 3);
-  ASSERT_EQUAL(output_keys[0], 11);
-  ASSERT_EQUAL(output_keys[1], 21);
-  ASSERT_EQUAL(output_keys[2], 37);
-
-  ASSERT_EQUAL(output_values[0], 0);
-  ASSERT_EQUAL(output_values[1], 2);
-  ASSERT_EQUAL(output_values[2], 7);
+  output_keys.resize(3);
+  output_values.resize(3);
+  keys_ref = {11, 21, 37};
+  ASSERT_EQUAL(output_keys, keys_ref);
+
+  values_ref.resize(3);
+  values_ref = {0, 2, 7};
+  ASSERT_EQUAL(output_values, values_ref);
 }
 DECLARE_INTEGRAL_VECTOR_UNITTEST(TestUniqueCopyByKeySimple);
 
diff --git a/thrust/testing/vector_insert.cu b/thrust/testing/vector_insert.cu
index 0b8176f7c3..cc1b1914e5 100644
--- a/thrust/testing/vector_insert.cu
+++ b/thrust/testing/vector_insert.cu
@@ -8,8 +8,6 @@ struct TestVectorRangeInsertSimple
 {
   void operator()(size_t)
   {
-    using T = typename Vector::value_type;
-
     Vector v1(5);
     thrust::sequence(v1.begin(), v1.end());
 
@@ -29,16 +27,8 @@ struct TestVectorRangeInsertSimple
 
     v2.insert(v2.begin() + 1, v1.begin(), v1.end());
 
-    ASSERT_EQUAL(T(0), v2[0]);
-
-    ASSERT_EQUAL(T(0), v2[1]);
-    ASSERT_EQUAL(T(1), v2[2]);
-    ASSERT_EQUAL(T(2), v2[3]);
-    ASSERT_EQUAL(T(3), v2[4]);
-    ASSERT_EQUAL(T(4), v2[5]);
-
-    ASSERT_EQUAL(T(1), v2[6]);
-    ASSERT_EQUAL(T(2), v2[7]);
+    Vector ref{0, 0, 1, 2, 3, 4, 1, 2};
+    ASSERT_EQUAL(ref, v2);
 
     ASSERT_EQUAL(8lu, v2.size());
     ASSERT_EQUAL(10lu, v2.capacity());
@@ -58,18 +48,8 @@ struct TestVectorRangeInsertSimple
     ASSERT_EQUAL(true, insertion_size == num_displaced);
 
     v3.insert(v3.begin(), v1.begin(), v1.end());
-
-    ASSERT_EQUAL(T(0), v3[0]);
-    ASSERT_EQUAL(T(1), v3[1]);
-    ASSERT_EQUAL(T(2), v3[2]);
-    ASSERT_EQUAL(T(3), v3[3]);
-    ASSERT_EQUAL(T(4), v3[4]);
-
-    ASSERT_EQUAL(T(0), v3[5]);
-    ASSERT_EQUAL(T(1), v3[6]);
-    ASSERT_EQUAL(T(2), v3[7]);
-    ASSERT_EQUAL(T(3), v3[8]);
-    ASSERT_EQUAL(T(4), v3[9]);
+    ref = {0, 1, 2, 3, 4, 0, 1, 2, 3, 4};
+    ASSERT_EQUAL(ref, v3);
 
     ASSERT_EQUAL(10lu, v3.size());
     ASSERT_EQUAL(10lu, v3.capacity());
@@ -90,16 +70,8 @@ struct TestVectorRangeInsertSimple
 
     v4.insert(v4.begin() + 1, v1.begin(), v1.begin() + 3);
 
-    ASSERT_EQUAL(T(0), v4[0]);
-
-    ASSERT_EQUAL(T(0), v4[1]);
-    ASSERT_EQUAL(T(1), v4[2]);
-    ASSERT_EQUAL(T(2), v4[3]);
-
-    ASSERT_EQUAL(T(1), v4[4]);
-    ASSERT_EQUAL(T(2), v4[5]);
-    ASSERT_EQUAL(T(3), v4[6]);
-    ASSERT_EQUAL(T(4), v4[7]);
+    ref = {0, 0, 1, 2, 1, 2, 3, 4};
+    ASSERT_EQUAL(ref, v4);
 
     ASSERT_EQUAL(8lu, v4.size());
     ASSERT_EQUAL(10lu, v4.capacity());
@@ -114,18 +86,8 @@ struct TestVectorRangeInsertSimple
 
     v5.insert(v5.begin() + 1, v1.begin(), v1.end());
 
-    ASSERT_EQUAL(T(0), v5[0]);
-
-    ASSERT_EQUAL(T(0), v5[1]);
-    ASSERT_EQUAL(T(1), v5[2]);
-    ASSERT_EQUAL(T(2), v5[3]);
-    ASSERT_EQUAL(T(3), v5[4]);
-    ASSERT_EQUAL(T(4), v5[5]);
-
-    ASSERT_EQUAL(T(1), v5[6]);
-    ASSERT_EQUAL(T(2), v5[7]);
-    ASSERT_EQUAL(T(3), v5[8]);
-    ASSERT_EQUAL(T(4), v5[9]);
+    ref = {0, 0, 1, 2, 3, 4, 1, 2, 3, 4};
+    ASSERT_EQUAL(ref, v5);
 
     ASSERT_EQUAL(10lu, v5.size());
   }
@@ -173,8 +135,6 @@ struct TestVectorFillInsertSimple
 {
   void operator()(size_t)
   {
-    using T = typename Vector::value_type;
-
     // test when insertion range fits inside capacity
     // and the size of the insertion is greater than the number
     // of displaced elements
@@ -191,16 +151,8 @@ struct TestVectorFillInsertSimple
 
     v1.insert(v1.begin() + 1, insertion_size, 13);
 
-    ASSERT_EQUAL(T(0), v1[0]);
-
-    ASSERT_EQUAL(T(13), v1[1]);
-    ASSERT_EQUAL(T(13), v1[2]);
-    ASSERT_EQUAL(T(13), v1[3]);
-    ASSERT_EQUAL(T(13), v1[4]);
-    ASSERT_EQUAL(T(13), v1[5]);
-
-    ASSERT_EQUAL(T(1), v1[6]);
-    ASSERT_EQUAL(T(2), v1[7]);
+    Vector ref{0, 13, 13, 13, 13, 13, 1, 2};
+    ASSERT_EQUAL(ref, v1);
 
     ASSERT_EQUAL(8lu, v1.size());
     ASSERT_EQUAL(10lu, v1.capacity());
@@ -221,17 +173,8 @@ struct TestVectorFillInsertSimple
 
     v2.insert(v2.begin(), insertion_size, 13);
 
-    ASSERT_EQUAL(T(13), v2[0]);
-    ASSERT_EQUAL(T(13), v2[1]);
-    ASSERT_EQUAL(T(13), v2[2]);
-    ASSERT_EQUAL(T(13), v2[3]);
-    ASSERT_EQUAL(T(13), v2[4]);
-
-    ASSERT_EQUAL(T(0), v2[5]);
-    ASSERT_EQUAL(T(1), v2[6]);
-    ASSERT_EQUAL(T(2), v2[7]);
-    ASSERT_EQUAL(T(3), v2[8]);
-    ASSERT_EQUAL(T(4), v2[9]);
+    ref = {13, 13, 13, 13, 13, 0, 1, 2, 3, 4};
+    ASSERT_EQUAL(ref, v2);
 
     ASSERT_EQUAL(10lu, v2.size());
     ASSERT_EQUAL(10lu, v2.capacity());
@@ -252,16 +195,8 @@ struct TestVectorFillInsertSimple
 
     v3.insert(v3.begin() + 1, insertion_size, 13);
 
-    ASSERT_EQUAL(T(0), v3[0]);
-
-    ASSERT_EQUAL(T(13), v3[1]);
-    ASSERT_EQUAL(T(13), v3[2]);
-    ASSERT_EQUAL(T(13), v3[3]);
-
-    ASSERT_EQUAL(T(1), v3[4]);
-    ASSERT_EQUAL(T(2), v3[5]);
-    ASSERT_EQUAL(T(3), v3[6]);
-    ASSERT_EQUAL(T(4), v3[7]);
+    ref = {0, 13, 13, 13, 1, 2, 3, 4};
+    ASSERT_EQUAL(ref, v3);
 
     ASSERT_EQUAL(8lu, v3.size());
     ASSERT_EQUAL(10lu, v3.capacity());
@@ -277,18 +212,8 @@ struct TestVectorFillInsertSimple
 
     v4.insert(v4.begin() + 1, insertion_size, 13);
 
-    ASSERT_EQUAL(T(0), v4[0]);
-
-    ASSERT_EQUAL(T(13), v4[1]);
-    ASSERT_EQUAL(T(13), v4[2]);
-    ASSERT_EQUAL(T(13), v4[3]);
-    ASSERT_EQUAL(T(13), v4[4]);
-    ASSERT_EQUAL(T(13), v4[5]);
-
-    ASSERT_EQUAL(T(1), v4[6]);
-    ASSERT_EQUAL(T(2), v4[7]);
-    ASSERT_EQUAL(T(3), v4[8]);
-    ASSERT_EQUAL(T(4), v4[9]);
+    ref = {0, 13, 13, 13, 13, 13, 1, 2, 3, 4};
+    ASSERT_EQUAL(ref, v4);
 
     ASSERT_EQUAL(10lu, v4.size());
   }