renamed thrusttest->unittest

--HG--
rename : testing/thrusttest/assertions.h => testing/unittest/assertions.h
rename : testing/thrusttest/exceptions.h => testing/unittest/exceptions.h
rename : testing/thrusttest/meta.h => testing/unittest/meta.h
rename : testing/thrusttest/random.h => testing/unittest/random.h
rename : testing/thrusttest/special_types.h => testing/unittest/special_types.h
rename : testing/thrusttest/system.h => testing/unittest/system.h
rename : testing/thrusttest/testframework.h => testing/unittest/testframework.h
rename : testing/thrusttest/unittest.h => testing/unittest/unittest.h
rename : testing/thrusttest/util.h => testing/unittest/util.h

performance/adjacent_difference.test

@@ -5,7 +5,7 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$InputType>   h_input = thrusttest::random_integers<$InputType>($InputSize);
+    thrust::host_vector<$InputType>   h_input = unittest::random_integers<$InputType>($InputSize);
     thrust::device_vector<$InputType> d_input = h_input;
 
     thrust::host_vector<$InputType>   h_output($InputSize);

performance/axpy.test

@@ -50,8 +50,8 @@ INITIALIZE = \
     """
     //cublasInit();
 
-    thrust::host_vector<$InputType>   h_x = thrusttest::random_samples<$InputType>($InputSize);
-    thrust::host_vector<$InputType>   h_y = thrusttest::random_samples<$InputType>($InputSize);
+    thrust::host_vector<$InputType>   h_x = unittest::random_samples<$InputType>($InputSize);
+    thrust::host_vector<$InputType>   h_y = unittest::random_samples<$InputType>($InputSize);
     thrust::device_vector<$InputType> d_x = h_x;
     thrust::device_vector<$InputType> d_y = h_y;
 

performance/binary_search.test

@@ -6,15 +6,15 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$KeyType>   h_keys = thrusttest::random_integers<$KeyType>($InputSize);
+    thrust::host_vector<$KeyType>   h_keys = unittest::random_integers<$KeyType>($InputSize);
     thrust::device_vector<$KeyType> d_keys = h_keys;
 
     thrust::sort(h_keys.begin(), h_keys.end());
     thrust::sort(d_keys.begin(), d_keys.end());
 
     ASSERT_EQUAL(d_keys, h_keys);
 
-    thrust::host_vector<$KeyType>   h_search = thrusttest::random_integers<$KeyType>($InputSize);
+    thrust::host_vector<$KeyType>   h_search = unittest::random_integers<$KeyType>($InputSize);
     thrust::device_vector<$KeyType> d_search = h_search;
 
     thrust::host_vector<unsigned int>    h_output($InputSize);

performance/build/perftest.h

@@ -1,4 +1,4 @@
-#include <thrusttest/unittest.h>
+#include <unittest/unittest.h>
 #include <cuda_runtime.h>
 #include <cuda.h>
 #include <string>

performance/build/test_function_template.cxx

@@ -86,7 +86,7 @@ void $FUNCTION(void)
     catch (std::bad_alloc) {
         RECORD_TEST_FAILURE("std::bad_alloc");
     }
-    catch (thrusttest::UnitTestException e) {
+    catch (unittest::UnitTestException e) {
         RECORD_TEST_FAILURE(e);
     }
 

performance/build/test_program_template.cxx

@@ -1,4 +1,4 @@
-#include <thrusttest/unittest.h>
+#include <unittest/unittest.h>
 
 /*********** BEGIN PREAMBLE SECTION ***********/
 $PREAMBLE

performance/float3_optimization.test

@@ -66,9 +66,9 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$InputType>   h_x = thrusttest::random_samples<$InputType>($InputSize);
-    thrust::host_vector<$InputType>   h_y = thrusttest::random_samples<$InputType>($InputSize);
-    thrust::host_vector<$InputType>   h_z = thrusttest::random_samples<$InputType>($InputSize);
+    thrust::host_vector<$InputType>   h_x = unittest::random_samples<$InputType>($InputSize);
+    thrust::host_vector<$InputType>   h_y = unittest::random_samples<$InputType>($InputSize);
+    thrust::host_vector<$InputType>   h_z = unittest::random_samples<$InputType>($InputSize);
     thrust::device_vector<$InputType> d_x = h_x;
     thrust::device_vector<$InputType> d_y = h_y;
     thrust::device_vector<$InputType> d_z = h_z;

performance/host_sort.test

@@ -7,7 +7,7 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$KeyType> h_keys = thrusttest::random_integers<$KeyType>($InputSize);
+    thrust::host_vector<$KeyType> h_keys = unittest::random_integers<$KeyType>($InputSize);
     thrust::host_vector<$KeyType> h_keys_copy(h_keys);
 
     // test sort

performance/host_sort_by_key.test

@@ -6,7 +6,7 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$KeyType> h_keys = thrusttest::random_integers<$KeyType>($InputSize);
+    thrust::host_vector<$KeyType> h_keys = unittest::random_integers<$KeyType>($InputSize);
     thrust::host_vector<$KeyType> h_keys_copy(h_keys);
     thrust::host_vector<$KeyType> h_values($InputSize);
 

performance/inclusive_scan.test

@@ -5,7 +5,7 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$InputType>   h_input = thrusttest::random_integers<$InputType>($InputSize);
+    thrust::host_vector<$InputType>   h_input = unittest::random_integers<$InputType>($InputSize);
     thrust::device_vector<$InputType> d_input = h_input;
 
     thrust::host_vector<$InputType>   h_output($InputSize);

performance/inclusive_segmented_scan.test

@@ -5,7 +5,7 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$InputType>   h_input = thrusttest::random_integers<$InputType>($InputSize);
+    thrust::host_vector<$InputType>   h_input = unittest::random_integers<$InputType>($InputSize);
     thrust::device_vector<$InputType> d_input = h_input;
 
     thrust::host_vector<$InputType>   h_output($InputSize);

performance/inner_product.test

@@ -5,8 +5,8 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$InputType>   h_input1 = thrusttest::random_integers<$InputType>($InputSize);
-    thrust::host_vector<$InputType>   h_input2 = thrusttest::random_integers<$InputType>($InputSize);
+    thrust::host_vector<$InputType>   h_input1 = unittest::random_integers<$InputType>($InputSize);
+    thrust::host_vector<$InputType>   h_input2 = unittest::random_integers<$InputType>($InputSize);
     thrust::device_vector<$InputType> d_input1 = h_input1;
     thrust::device_vector<$InputType> d_input2 = h_input2;
 

performance/merge_sort.test

@@ -6,7 +6,7 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$KeyType>   h_keys = thrusttest::random_integers<$KeyType>($InputSize);
+    thrust::host_vector<$KeyType>   h_keys = unittest::random_integers<$KeyType>($InputSize);
     thrust::device_vector<$KeyType> d_keys = h_keys;
     thrust::device_vector<$KeyType> d_keys_copy = d_keys;
 

performance/merge_sort_by_key.test

@@ -6,7 +6,7 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$KeyType>   h_keys = thrusttest::random_integers<$KeyType>($InputSize);
+    thrust::host_vector<$KeyType>   h_keys = unittest::random_integers<$KeyType>($InputSize);
     thrust::device_vector<$KeyType> d_keys = h_keys;
 
     thrust::host_vector<$ValueType>   h_values($InputSize);

performance/nrm2.test

@@ -41,7 +41,7 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$InputType>   h_input = thrusttest::random_integers<bool>($InputSize);
+    thrust::host_vector<$InputType>   h_input = unittest::random_integers<bool>($InputSize);
     thrust::device_vector<$InputType> d_input = h_input;
 
     $InputType h_result = $Method(h_input);

performance/omp_merge_sort.test

@@ -6,7 +6,7 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$KeyType>   h_keys = thrusttest::random_integers<$KeyType>($InputSize);
+    thrust::host_vector<$KeyType>   h_keys = unittest::random_integers<$KeyType>($InputSize);
     thrust::device_vector<$KeyType> d_keys = h_keys;
     thrust::device_vector<$KeyType> d_keys_copy = d_keys;
 

performance/radix_sort.test

@@ -6,7 +6,7 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$KeyType>   h_keys = thrusttest::random_integers<$KeyType>($InputSize);
+    thrust::host_vector<$KeyType>   h_keys = unittest::random_integers<$KeyType>($InputSize);
     thrust::device_vector<$KeyType> d_keys = h_keys;
     thrust::device_vector<$KeyType> d_keys_copy = d_keys;
 

performance/radix_sort_bits.test

@@ -6,7 +6,7 @@ PREAMBLE = \
 INITIALIZE = \
     """
     const size_t InputSize = 1 << 24;
-    thrust::host_vector<$KeyType>   h_keys = thrusttest::random_integers<$KeyType>(InputSize);
+    thrust::host_vector<$KeyType>   h_keys = unittest::random_integers<$KeyType>(InputSize);
 
     // set upper bits to zero
     for(size_t i = 0; i < InputSize; i++)

performance/radix_sort_by_key.test

@@ -6,7 +6,7 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$KeyType>   h_keys = thrusttest::random_integers<$KeyType>($InputSize);
+    thrust::host_vector<$KeyType>   h_keys = unittest::random_integers<$KeyType>($InputSize);
     thrust::device_vector<$KeyType> d_keys = h_keys;
 
     thrust::host_vector<$ValueType>   h_values($InputSize);

performance/reduce.test

@@ -5,7 +5,7 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$InputType>   h_input = thrusttest::random_integers<$InputType>($InputSize);
+    thrust::host_vector<$InputType>   h_input = unittest::random_integers<$InputType>($InputSize);
     thrust::device_vector<$InputType> d_input = h_input;
 
     $InputType init = 13;

performance/reduce_float.test

@@ -5,7 +5,7 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$InputType>   h_input = thrusttest::random_samples<$InputType>($InputSize);
+    thrust::host_vector<$InputType>   h_input = unittest::random_samples<$InputType>($InputSize);
     thrust::device_vector<$InputType> d_input = h_input;
 
     $InputType init = 13;

performance/sort.test

@@ -5,7 +5,7 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$KeyType>   h_keys = thrusttest::random_integers<$KeyType>($InputSize);
+    thrust::host_vector<$KeyType>   h_keys = unittest::random_integers<$KeyType>($InputSize);
     thrust::device_vector<$KeyType> d_keys = h_keys;
     thrust::device_vector<$KeyType> d_keys_copy = d_keys;
 

performance/sort_by_key.test

@@ -6,7 +6,7 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$KeyType>   h_keys = thrusttest::random_integers<$KeyType>($InputSize);
+    thrust::host_vector<$KeyType>   h_keys = unittest::random_integers<$KeyType>($InputSize);
     thrust::device_vector<$KeyType> d_keys = h_keys;
 
     thrust::host_vector<$ValueType>   h_values($InputSize);

performance/sort_large.test

@@ -5,7 +5,7 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$KeyType>   h_keys = thrusttest::random_integers<$KeyType>($InputSize);
+    thrust::host_vector<$KeyType>   h_keys = unittest::random_integers<$KeyType>($InputSize);
     thrust::device_vector<$KeyType> d_keys = h_keys;
     thrust::device_vector<$KeyType> d_keys_copy = d_keys;
 

performance/stl_sort.test

@@ -5,7 +5,7 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$KeyType> h_keys = thrusttest::random_integers<$KeyType>($InputSize);
+    thrust::host_vector<$KeyType> h_keys = unittest::random_integers<$KeyType>($InputSize);
     thrust::host_vector<$KeyType> h_keys_copy = h_keys;
     """
 

performance/unique.test

@@ -5,7 +5,7 @@ PREAMBLE = \
 
 INITIALIZE = \
     """
-    thrust::host_vector<$InputType> h_input = thrusttest::random_integers<$InputType>($InputSize);
+    thrust::host_vector<$InputType> h_input = unittest::random_integers<$InputType>($InputSize);
 
     // increase likelihood of equal consecutive elements
     for(size_t i = 0; i < $InputSize; i++)

testing/adjacent_difference.cu

@@ -1,4 +1,4 @@
-#include <thrusttest/unittest.h>
+#include <unittest/unittest.h>
 #include <thrust/adjacent_difference.h>
 
 template <class Vector>
@@ -40,7 +40,7 @@ DECLARE_VECTOR_UNITTEST(TestAjacentDifferenceSimple);
 template <typename T>
 void TestAjacentDifference(const size_t n)
 {
-    thrust::host_vector<T>   h_input = thrusttest::random_samples<T>(n);
+    thrust::host_vector<T>   h_input = unittest::random_samples<T>(n);
     thrust::device_vector<T> d_input = h_input;
 
     thrust::host_vector<T>   h_output(n);

testing/advance.cu

@@ -1,4 +1,4 @@
-#include <thrusttest/unittest.h>
+#include <unittest/unittest.h>
 #include <thrust/advance.h>
 #include <thrust/sequence.h>
 

testing/arch.cu

@@ -1,4 +1,4 @@
-#include <thrusttest/unittest.h>
+#include <unittest/unittest.h>
 
 #if defined(__CUDACC__)
 

testing/binary_search.cu

@@ -1,4 +1,4 @@
-#include <thrusttest/unittest.h>
+#include <unittest/unittest.h>
 #include <thrust/binary_search.h>
 
 #include <thrust/sequence.h>
@@ -316,13 +316,13 @@ struct TestVectorLowerBound
 #if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC) && (THRUST_DEVICE_BACKEND == THRUST_DEVICE_BACKEND_OMP)
     KNOWN_FAILURE;
 #else
-    thrust::host_vector<T>   h_vec = thrusttest::random_integers<T>(n);
+    thrust::host_vector<T>   h_vec = unittest::random_integers<T>(n);
     thrust::device_vector<T> d_vec = h_vec;
 
     thrust::sort(h_vec.begin(), h_vec.end());
     thrust::sort(d_vec.begin(), d_vec.end());
 
-    thrust::host_vector<T>   h_input = thrusttest::random_integers<T>(4*n);
+    thrust::host_vector<T>   h_input = unittest::random_integers<T>(4*n);
     thrust::device_vector<T> d_input = h_input;
 
     thrust::host_vector<int>   h_output(4*n);
@@ -348,13 +348,13 @@ struct TestVectorUpperBound
 #if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC) && (THRUST_DEVICE_BACKEND == THRUST_DEVICE_BACKEND_OMP)
     KNOWN_FAILURE;
 #else
-    thrust::host_vector<T>   h_vec = thrusttest::random_integers<T>(n);
+    thrust::host_vector<T>   h_vec = unittest::random_integers<T>(n);
     thrust::device_vector<T> d_vec = h_vec;
 
     thrust::sort(h_vec.begin(), h_vec.end());
     thrust::sort(d_vec.begin(), d_vec.end());
 
-    thrust::host_vector<T>   h_input = thrusttest::random_integers<T>(4*n);
+    thrust::host_vector<T>   h_input = unittest::random_integers<T>(4*n);
     thrust::device_vector<T> d_input = h_input;
 
     thrust::host_vector<int>   h_output(4*n);
@@ -379,13 +379,13 @@ struct TestVectorBinarySearch
 #if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC) && (THRUST_DEVICE_BACKEND == THRUST_DEVICE_BACKEND_OMP)
     KNOWN_FAILURE;
 #else
-    thrust::host_vector<T>   h_vec = thrusttest::random_integers<T>(n);
+    thrust::host_vector<T>   h_vec = unittest::random_integers<T>(n);
     thrust::device_vector<T> d_vec = h_vec;
 
     thrust::sort(h_vec.begin(), h_vec.end());
     thrust::sort(d_vec.begin(), d_vec.end());
 
-    thrust::host_vector<T>   h_input = thrusttest::random_integers<T>(4*n);
+    thrust::host_vector<T>   h_input = unittest::random_integers<T>(4*n);
     thrust::device_vector<T> d_input = h_input;
 
     thrust::host_vector<int>   h_output(4*n);

testing/constant_iterator.cu

@@ -1,4 +1,4 @@
-#include <thrusttest/unittest.h>
+#include <unittest/unittest.h>
 #include <thrust/iterator/constant_iterator.h>
 #include <thrust/copy.h>
 #include <thrust/transform.h>

testing/copy.cu

@@ -1,4 +1,4 @@
-#include <thrusttest/unittest.h>
+#include <unittest/unittest.h>
 #include <thrust/copy.h>
 
 #include <list>
@@ -223,7 +223,7 @@ DECLARE_VECTOR_UNITTEST(TestCopyIfSimple);
 template <typename T>
 void TestCopyIf(const size_t n)
 {
-    thrust::host_vector<T> h_data = thrusttest::random_samples<T>(n);
+    thrust::host_vector<T> h_data = unittest::random_samples<T>(n);
     thrust::device_vector<T> d_data = h_data;
 
     thrust::host_vector<T> h_result(n);
@@ -268,11 +268,11 @@ DECLARE_VECTOR_UNITTEST(TestCopyIfStencilSimple);
 template <typename T>
 void TestCopyIfStencil(const size_t n)
 {
-    thrust::host_vector<T> h_data = thrusttest::random_samples<T>(n);
+    thrust::host_vector<T> h_data = unittest::random_samples<T>(n);
     thrust::device_vector<T> d_data = h_data;
 
-    thrust::host_vector<T> h_stencil = thrusttest::random_samples<T>(n);
-    thrust::device_vector<T> d_stencil = thrusttest::random_samples<T>(n);
+    thrust::host_vector<T> h_stencil = unittest::random_samples<T>(n);
+    thrust::device_vector<T> d_stencil = unittest::random_samples<T>(n);
 
     thrust::host_vector<T> h_result(n);
     thrust::device_vector<T> d_result(n);

testing/count.cu

@@ -1,4 +1,4 @@
-#include <thrusttest/unittest.h>
+#include <unittest/unittest.h>
 #include <thrust/count.h>
 
 template <class Vector>
@@ -18,7 +18,7 @@ DECLARE_VECTOR_UNITTEST(TestCountSimple);
 template <typename T>
 void TestCount(const size_t n)
 {
-    thrust::host_vector<T>   h_data = thrusttest::random_samples<T>(n);
+    thrust::host_vector<T>   h_data = unittest::random_samples<T>(n);
     thrust::device_vector<T> d_data = h_data;
 
     size_t cpu_result = thrust::count(h_data.begin(), h_data.end(), T(5));
@@ -53,7 +53,7 @@ DECLARE_VECTOR_UNITTEST(TestCountIfSimple);
 template <typename T>
 void TestCountIf(const size_t n)
 {
-    thrust::host_vector<T>   h_data = thrusttest::random_samples<T>(n);
+    thrust::host_vector<T>   h_data = unittest::random_samples<T>(n);
     thrust::device_vector<T> d_data = h_data;
 
     size_t cpu_result = thrust::count_if(h_data.begin(), h_data.end(), greater_than_five<T>());