 			}
 		}
 		#endif
-		AND_WHEN( "the at(), operator[], and operator() accessor methods are used on the device" ) {
-			THEN( "any index 0 <= index < N should be valid" ) {
-				ecuda::array<int,3> deviceResultCodes;
-				ecuda::fill( deviceResultCodes.begin(), deviceResultCodes.end(), 0 );
-				CUDA_CALL_KERNEL_AND_WAIT( check_array_accessors_on_device<data_type,N><<<1,1>>>( deviceArrayWithUniqueValues, deviceResultCodes ) );
-				std::vector<int> hostResultCodes( 3 );
-				ecuda::copy( deviceResultCodes.begin(), deviceResultCodes.end(), hostResultCodes.begin() );
-				REQUIRE( hostResultCodes[0] );
-				REQUIRE( hostResultCodes[1] );
-				REQUIRE( hostResultCodes[2] );
-			}
-			AND_THEN( "an invalid index N should throw an exception" ) {
-				bool exceptionThrown = false;
-				try {
-					CUDA_CALL_KERNEL_AND_WAIT( check_array_bad_accessor_on_device<data_type,N><<<1,1>>>( deviceArrayWithUniqueValues ) );
-				} catch( ecuda::cuda_error& ex ) {
-					exceptionThrown = true;
-				}
-				REQUIRE(exceptionThrown);
-			}
-		}
-		AND_WHEN( "the front() and back() accessors are used on the device" ) {
-			THEN( "the values should be as expected" ) {
-				ecuda::array<int,2> deviceResultCodes;
-				ecuda::fill( deviceResultCodes.begin(), deviceResultCodes.end(), 0 );
-				CUDA_CALL_KERNEL_AND_WAIT( check_array_front_and_back_on_device<data_type,N><<<1,1>>>( deviceArrayWithUniqueValues, deviceResultCodes ) );
-				std::vector<int> hostResultCodes( 2 );
-				ecuda::copy( deviceResultCodes.begin(), deviceResultCodes.end(), hostResultCodes.begin() );
-				REQUIRE( hostResultCodes[0] );
-				REQUIRE( hostResultCodes[1] );
-			}
-		}
-		AND_WHEN( "the begin() and end() iterators are used to traverse the array on the device" ) {
-			THEN( "the values should increase from 0 to N-1" ) {
-				ecuda::array<int,1> deviceResultCodes;
-				ecuda::fill( deviceResultCodes.begin(), deviceResultCodes.end(), 0 );
-				CUDA_CALL_KERNEL_AND_WAIT( check_array_begin_and_end_on_device<data_type,N><<<1,1>>>( deviceArrayWithUniqueValues, deviceResultCodes ) );
-				std::vector<int> hostResultCodes( 1 );
-				ecuda::copy( deviceResultCodes.begin(), deviceResultCodes.end(), hostResultCodes.begin() );
-				REQUIRE( hostResultCodes[0] );
-			}
-		}
-		AND_WHEN( "the rbegin() and rend() iterators are used to traverse the array on the device" ) {
-			THEN( "the values should decrease from N-1 to 0" ) {
-				ecuda::array<int,1> deviceResultCodes;
-				ecuda::fill( deviceResultCodes.begin(), deviceResultCodes.end(), 0 );
-				CUDA_CALL_KERNEL_AND_WAIT( check_array_rbegin_and_rend_on_device<data_type,N><<<1,1>>>( deviceArrayWithUniqueValues, deviceResultCodes ) );
-				std::vector<int> hostResultCodes( 1 );
-				ecuda::copy( deviceResultCodes.begin(), deviceResultCodes.end(), hostResultCodes.begin() );
-				REQUIRE( hostResultCodes[0] );
-			}
-		}
-		AND_WHEN( "the arrays are lexicographically compared on the device" ) {
-			THEN( "the former array should compare less than the latter array (since the default value is 66)" ) {
-				ecuda::array<int,3> deviceResultCodes;
-				ecuda::fill( deviceResultCodes.begin(), deviceResultCodes.end(), 0 );
-				CUDA_CALL_KERNEL_AND_WAIT( check_array_lexicographical_compare_on_device<data_type,N><<<1,1>>>( deviceArrayWithUniqueValues, deviceArrayWithDefaultValues, deviceResultCodes ) );
-				std::vector<int> hostResultCodes( 3 );
-				ecuda::copy( deviceResultCodes.begin(), deviceResultCodes.end(), hostResultCodes.begin() );
-				REQUIRE( hostResultCodes[0] );
-				REQUIRE( hostResultCodes[1] );
-				REQUIRE( hostResultCodes[2] );
-			}
-		}
-	}
-}
-
-#else
-
-SCENARIO( "array functions correctly", "array" ) {
-	GIVEN( "one default-intialized ecuda::array with a value of 66 and another ecuda::array with unique values from 0-99 inclusive" ) {
-		ecuda::array<data_type,N> deviceArrayWithDefaultValues;
-		ecuda::array<data_type,N> deviceArrayWithUniqueValues;
-		std::vector<data_type> hostArrayWithUniqueValues( N );
-		for( std::size_t i = 0; i < N; ++i ) hostArrayWithUniqueValues[i] = data_type(i);
-		ecuda::copy( hostArrayWithUniqueValues.begin(), hostArrayWithUniqueValues.end(), deviceArrayWithUniqueValues.begin() );
-		WHEN( "the values of the former are inspected" ) {
-			std::vector<data_type> v( N );
-			THEN( "they should all be default initialized" ) {
-				REQUIRE( ecuda::equal( deviceArrayWithDefaultValues.begin(), deviceArrayWithDefaultValues.end(), v.begin() ) );
-				REQUIRE( ecuda::equal( v.begin(), v.end(), deviceArrayWithDefaultValues.begin() ) );
-			}
-		}
-		AND_WHEN( "the values of the latter are inspected" ) {
-			THEN( "they should all have expected values" ) {
-				REQUIRE( ecuda::equal( deviceArrayWithUniqueValues.begin(), deviceArrayWithUniqueValues.end(), hostArrayWithUniqueValues.begin() ) );
-				REQUIRE( ecuda::equal( hostArrayWithUniqueValues.begin(), hostArrayWithUniqueValues.end(), deviceArrayWithUniqueValues.begin() ) );
-			}
-		}
-		AND_WHEN( "another array is copy constructed" ) {
-			ecuda::array<data_type,N> arr2( deviceArrayWithDefaultValues );
-			THEN( "they should be equal" ) {
-				REQUIRE( ecuda::equal( deviceArrayWithDefaultValues.begin(), deviceArrayWithDefaultValues.end(), arr2.begin() ) );
-				REQUIRE( ecuda::equal( arr2.begin(), arr2.end(), deviceArrayWithDefaultValues.begin() ) );
-			}
-			AND_THEN( "they should reside in different memory locations" ) { REQUIRE( deviceArrayWithDefaultValues.data() != arr2.data() ); }
-		}
-		AND_WHEN( "another array is copy assigned") {
-			ecuda::array<data_type,N> arr2;
-			arr2 = deviceArrayWithDefaultValues;
-			THEN( "they should be equal" ) {
-				REQUIRE( ecuda::equal( deviceArrayWithDefaultValues.begin(), deviceArrayWithDefaultValues.end(), arr2.begin() ) );
-				REQUIRE( ecuda::equal( arr2.begin(), arr2.end(), deviceArrayWithDefaultValues.begin() ) );
-			}
-			AND_THEN( "they should reside in different memory locations" ) { REQUIRE( deviceArrayWithDefaultValues.data() != arr2.data() ); }
-		}
-		#ifdef __CPP11_SUPPORTED__
-		AND_WHEN( "another array is move constructed" ) {
-			ecuda::array<data_type,N> arr2( std::move(deviceArrayWithDefaultValues) );
-			THEN( "the original array should be invalid" ) { REQUIRE( !deviceArrayWithDefaultValues.data() ); }
-			AND_THEN( "the new array should have the original one's contents" ) { REQUIRE( ecuda::count( arr2.begin(), arr2.end(), data_type() ) == N ); }
-			AND_THEN( "a move assignment operation should restore the original state" ) {
-				deviceArrayWithDefaultValues = std::move(arr2);
-				REQUIRE( deviceArrayWithDefaultValues.data() );
-				REQUIRE( !arr2.data() );
-			}
-		}
-		#endif
 		AND_WHEN( "the at accessor method is used" ) {
 			THEN( "any index 0 <= index < N should be valid" ) {
 				bool exceptionThrown = false;


typedef element_t<double> data_type;

const std::size_t N = 100; // 100k bytes

#ifdef __CUDACC__


		if( !(array1 >= array2 ) ) results[2] = 1;
	}
}

SCENARIO( "array functions correctly", "array" ) {
	GIVEN( "one default-intialized ecuda::array with a value of 66 and another ecuda::array with unique values from 0-99 inclusive" ) {
std::cout << "INIT deviceArrayWithDefaultValues" << std::endl;
		ecuda::array<data_type,N> deviceArrayWithDefaultValues;
std::cout << "INIT deviceArrayWithUniqueValues" << std::endl;
		ecuda::array<data_type,N> deviceArrayWithUniqueValues;
std::cout << "INIT COMPLETE" << std::endl;
		std::vector<data_type> hostArrayWithUniqueValues( N );
		for( std::size_t i = 0; i < N; ++i ) hostArrayWithUniqueValues[i] = data_type(i);
		ecuda::copy( hostArrayWithUniqueValues.begin(), hostArrayWithUniqueValues.end(), deviceArrayWithUniqueValues.begin() );
		WHEN( "the values of the former are inspected" ) {
			std::vector<data_type> v( N );
			THEN( "they should all be default initialized" ) {
				REQUIRE( ecuda::equal( deviceArrayWithDefaultValues.begin(), deviceArrayWithDefaultValues.end(), v.begin() ) );
				REQUIRE( ecuda::equal( v.begin(), v.end(), deviceArrayWithDefaultValues.begin() ) );
			}
		}
		AND_WHEN( "the values of the latter are inspected" ) {
			THEN( "they should all have expected values" ) {
				REQUIRE( ecuda::equal( deviceArrayWithUniqueValues.begin(), deviceArrayWithUniqueValues.end(), hostArrayWithUniqueValues.begin() ) );
				REQUIRE( ecuda::equal( hostArrayWithUniqueValues.begin(), hostArrayWithUniqueValues.end(), deviceArrayWithUniqueValues.begin() ) );
			}
		}
		AND_WHEN( "another array is copy constructed" ) {
			ecuda::array<data_type,N> arr2( deviceArrayWithDefaultValues );
			THEN( "they should be equal" ) {
				REQUIRE( ecuda::equal( deviceArrayWithDefaultValues.begin(), deviceArrayWithDefaultValues.end(), arr2.begin() ) );
				REQUIRE( ecuda::equal( arr2.begin(), arr2.end(), deviceArrayWithDefaultValues.begin() ) );
			}
			AND_THEN( "they should reside in different memory locations" ) { REQUIRE( deviceArrayWithDefaultValues.data() != arr2.data() ); }
		}
		AND_WHEN( "another array is copy assigned") {
			ecuda::array<data_type,N> arr2;
			arr2 = deviceArrayWithDefaultValues;
			THEN( "they should be equal" ) {
				REQUIRE( ecuda::equal( deviceArrayWithDefaultValues.begin(), deviceArrayWithDefaultValues.end(), arr2.begin() ) );
				REQUIRE( ecuda::equal( arr2.begin(), arr2.end(), deviceArrayWithDefaultValues.begin() ) );
			}
			AND_THEN( "they should reside in different memory locations" ) { REQUIRE( deviceArrayWithDefaultValues.data() != arr2.data() ); }
		}
		#ifdef __CPP11_SUPPORTED__
		AND_WHEN( "another array is move constructed" ) {
			ecuda::array<data_type,N> arr2( std::move(deviceArrayWithDefaultValues) );
			THEN( "the original array should be invalid" ) { REQUIRE( !deviceArrayWithDefaultValues.data() ); }
			AND_THEN( "the new array should have the original one's contents" ) { REQUIRE( ecuda::count( arr2.begin(), arr2.end(), data_type() ) == N ); }
			AND_THEN( "a move assignment operation should restore the original state" ) {
				deviceArrayWithDefaultValues = std::move(arr2);
				REQUIRE( deviceArrayWithDefaultValues.data() );
				REQUIRE( !arr2.data() );
			}
		}
		#endif
		AND_WHEN( "the at(), operator[], and operator() accessor methods are used on the device" ) {
			THEN( "any index 0 <= index < N should be valid" ) {
				ecuda::array<int,3> deviceResultCodes;
				ecuda::fill( deviceResultCodes.begin(), deviceResultCodes.end(), 0 );
				CUDA_CALL_KERNEL_AND_WAIT( check_array_accessors_on_device<data_type,N><<<1,1>>>( deviceArrayWithUniqueValues, deviceResultCodes ) );
				std::vector<int> hostResultCodes( 3 );
				ecuda::copy( deviceResultCodes.begin(), deviceResultCodes.end(), hostResultCodes.begin() );
				REQUIRE( hostResultCodes[0] );
				REQUIRE( hostResultCodes[1] );
				REQUIRE( hostResultCodes[2] );
			}
			AND_THEN( "an invalid index N should throw an exception" ) {
				bool exceptionThrown = false;
				try {
					CUDA_CALL_KERNEL_AND_WAIT( check_array_bad_accessor_on_device<data_type,N><<<1,1>>>( deviceArrayWithUniqueValues ) );
				} catch( ecuda::cuda_error& ex ) {
					exceptionThrown = true;
				}
				REQUIRE(exceptionThrown);
			}
		}
		AND_WHEN( "the front() and back() accessors are used on the device" ) {
			THEN( "the values should be as expected" ) {
				ecuda::array<int,2> deviceResultCodes;
				ecuda::fill( deviceResultCodes.begin(), deviceResultCodes.end(), 0 );
				CUDA_CALL_KERNEL_AND_WAIT( check_array_front_and_back_on_device<data_type,N><<<1,1>>>( deviceArrayWithUniqueValues, deviceResultCodes ) );
				std::vector<int> hostResultCodes( 2 );
				ecuda::copy( deviceResultCodes.begin(), deviceResultCodes.end(), hostResultCodes.begin() );
				REQUIRE( hostResultCodes[0] );
				REQUIRE( hostResultCodes[1] );
			}
		}
		AND_WHEN( "the begin() and end() iterators are used to traverse the array on the device" ) {
			THEN( "the values should increase from 0 to N-1" ) {
				ecuda::array<int,1> deviceResultCodes;
				ecuda::fill( deviceResultCodes.begin(), deviceResultCodes.end(), 0 );
				CUDA_CALL_KERNEL_AND_WAIT( check_array_begin_and_end_on_device<data_type,N><<<1,1>>>( deviceArrayWithUniqueValues, deviceResultCodes ) );
				std::vector<int> hostResultCodes( 1 );
				ecuda::copy( deviceResultCodes.begin(), deviceResultCodes.end(), hostResultCodes.begin() );
				REQUIRE( hostResultCodes[0] );
			}
		}
		AND_WHEN( "the rbegin() and rend() iterators are used to traverse the array on the device" ) {
			THEN( "the values should decrease from N-1 to 0" ) {
				ecuda::array<int,1> deviceResultCodes;
				ecuda::fill( deviceResultCodes.begin(), deviceResultCodes.end(), 0 );
				CUDA_CALL_KERNEL_AND_WAIT( check_array_rbegin_and_rend_on_device<data_type,N><<<1,1>>>( deviceArrayWithUniqueValues, deviceResultCodes ) );
				std::vector<int> hostResultCodes( 1 );
				ecuda::copy( deviceResultCodes.begin(), deviceResultCodes.end(), hostResultCodes.begin() );
				REQUIRE( hostResultCodes[0] );
			}
		}
		AND_WHEN( "the arrays are lexicographically compared on the device" ) {
			THEN( "the former array should compare less than the latter array (since the default value is 66)" ) {
				ecuda::array<int,3> deviceResultCodes;
				ecuda::fill( deviceResultCodes.begin(), deviceResultCodes.end(), 0 );
				CUDA_CALL_KERNEL_AND_WAIT( check_array_lexicographical_compare_on_device<data_type,N><<<1,1>>>( deviceArrayWithUniqueValues, deviceArrayWithDefaultValues, deviceResultCodes ) );
				std::vector<int> hostResultCodes( 3 );
				ecuda::copy( deviceResultCodes.begin(), deviceResultCodes.end(), hostResultCodes.begin() );
				REQUIRE( hostResultCodes[0] );
				REQUIRE( hostResultCodes[1] );
				REQUIRE( hostResultCodes[2] );
			}
		}
	}
}

#else

SCENARIO( "array functions correctly", "array" ) {
	GIVEN( "one default-intialized ecuda::array with a value of 66 and another ecuda::array with unique values from 0-99 inclusive" ) {
