diff --git a/src/UnitTests/AllocatorsTest.cpp b/src/UnitTests/AllocatorsTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ba28216dc87bc8405b0ebb4b0d5da60fce2e0bf7
--- /dev/null
+++ b/src/UnitTests/AllocatorsTest.cpp
@@ -0,0 +1 @@
+#include "AllocatorsTest.h"
diff --git a/src/UnitTests/AllocatorsTest.cu b/src/UnitTests/AllocatorsTest.cu
new file mode 100644
index 0000000000000000000000000000000000000000..ba28216dc87bc8405b0ebb4b0d5da60fce2e0bf7
--- /dev/null
+++ b/src/UnitTests/AllocatorsTest.cu
@@ -0,0 +1 @@
+#include "AllocatorsTest.h"
diff --git a/src/UnitTests/AllocatorsTest.h b/src/UnitTests/AllocatorsTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..e1d618ea5f814c73cd15163c7ba6ab326c4d42b3
--- /dev/null
+++ b/src/UnitTests/AllocatorsTest.h
@@ -0,0 +1,115 @@
+/***************************************************************************
+                          AllocatorsTest.h  -  description
+                             -------------------
+    begin                : Jul 4, 2019
+    copyright            : (C) 2019 by Tomas Oberhuber et al.
+    email                : tomas.oberhuber@fjfi.cvut.cz
+ ***************************************************************************/
+
+/* See Copyright Notice in tnl/Copyright */
+
+#pragma once
+
+#ifdef HAVE_GTEST
+#include <TNL/Allocators/Host.h>
+#include <TNL/Allocators/Cuda.h>
+#include <TNL/Allocators/CudaHost.h>
+#include <TNL/Allocators/CudaManaged.h>
+#include <TNL/Containers/Algorithms/ArrayOperations.h>
+
+#include "gtest/gtest.h"
+
+using namespace TNL;
+
+constexpr int ARRAY_TEST_SIZE = 5000;
+
+// test fixture for typed tests
+template< typename Value >
+class AllocatorsTest : public ::testing::Test
+{
+protected:
+   using ValueType = Value;
+};
+
+// types for which ArrayTest is instantiated
+using ValueTypes = ::testing::Types< short int, int, long, float, double >;
+
+TYPED_TEST_SUITE( AllocatorsTest, ValueTypes );
+
+TYPED_TEST( AllocatorsTest, Host )
+{
+   using ValueType = typename TestFixture::ValueType;
+   using Allocator = Allocators::Host< ValueType >;
+
+   Allocator allocator;
+   ValueType* data = allocator.allocate( ARRAY_TEST_SIZE );
+   ASSERT_NE( data, nullptr );
+
+   // do something useful with the data
+   for (int i = 0; i < ARRAY_TEST_SIZE; i++) {
+      data[i] = 0;
+      EXPECT_EQ(data[i], 0);
+   }
+
+   allocator.deallocate( data, ARRAY_TEST_SIZE );
+}
+
+#ifdef HAVE_CUDA
+TYPED_TEST( AllocatorsTest, CudaHost )
+{
+   using ValueType = typename TestFixture::ValueType;
+   using Allocator = Allocators::CudaHost< ValueType >;
+
+   Allocator allocator;
+   ValueType* data = allocator.allocate( ARRAY_TEST_SIZE );
+   ASSERT_NE( data, nullptr );
+
+   // do something useful with the data
+   for (int i = 0; i < ARRAY_TEST_SIZE; i++) {
+      data[i] = 0;
+      EXPECT_EQ(data[i], 0);
+   }
+
+   allocator.deallocate( data, ARRAY_TEST_SIZE );
+}
+
+TYPED_TEST( AllocatorsTest, CudaManaged )
+{
+   using ValueType = typename TestFixture::ValueType;
+   using Allocator = Allocators::CudaManaged< ValueType >;
+
+   Allocator allocator;
+   ValueType* data = allocator.allocate( ARRAY_TEST_SIZE );
+   ASSERT_NE( data, nullptr );
+
+   // set data on the device
+   Containers::Algorithms::ArrayOperations< Devices::Cuda >::setMemory( data, (ValueType) 0, ARRAY_TEST_SIZE );
+   ASSERT_NO_THROW( TNL_CHECK_CUDA_DEVICE );
+
+   // check values on the host
+   for (int i = 0; i < ARRAY_TEST_SIZE; i++)
+      EXPECT_EQ(data[i], 0);
+
+   allocator.deallocate( data, ARRAY_TEST_SIZE );
+}
+
+TYPED_TEST( AllocatorsTest, Cuda )
+{
+   using ValueType = typename TestFixture::ValueType;
+   using Allocator = Allocators::CudaHost< ValueType >;
+
+   Allocator allocator;
+   ValueType* data = allocator.allocate( ARRAY_TEST_SIZE );
+   ASSERT_NE( data, nullptr );
+
+   // set data on the device
+   Containers::Algorithms::ArrayOperations< Devices::Cuda >::setMemory( data, (ValueType) 0, ARRAY_TEST_SIZE );
+   ASSERT_NO_THROW( TNL_CHECK_CUDA_DEVICE );
+
+   allocator.deallocate( data, ARRAY_TEST_SIZE );
+}
+#endif // HAVE_CUDA
+#endif // HAVE_GTEST
+
+
+#include "main.h"
diff --git a/src/UnitTests/CMakeLists.txt b/src/UnitTests/CMakeLists.txt
index f7d3b68b03d3f5e52a23f6bf47f5c25ac9b8f0ae..331d199388c3e13a2dc930744571d87847948311 100644
--- a/src/UnitTests/CMakeLists.txt
+++ b/src/UnitTests/CMakeLists.txt
@@ -14,6 +14,15 @@ if( BUILD_CUDA )
    TARGET_LINK_LIBRARIES( AssertCudaTest ${GTEST_BOTH_LIBRARIES} )
 endif()
 
+if( BUILD_CUDA )
+   CUDA_ADD_EXECUTABLE( AllocatorsTest AllocatorsTest.cu OPTIONS ${CXX_TESTS_FLAGS} )
+   TARGET_LINK_LIBRARIES( AllocatorsTest ${GTEST_BOTH_LIBRARIES} )
+else()
+   ADD_EXECUTABLE( AllocatorsTest AllocatorsTest.cpp )
+   TARGET_COMPILE_OPTIONS( AllocatorsTest PRIVATE ${CXX_TESTS_FLAGS} )
+   TARGET_LINK_LIBRARIES( AllocatorsTest ${GTEST_BOTH_LIBRARIES} )
+endif()
+
 if( BUILD_CUDA )
    CUDA_ADD_EXECUTABLE( FileTest FileTest.cu OPTIONS ${CXX_TESTS_FLAGS} )
    TARGET_LINK_LIBRARIES( FileTest ${GTEST_BOTH_LIBRARIES} )
@@ -52,6 +61,7 @@ ADD_TEST( AssertTest ${EXECUTABLE_OUTPUT_PATH}/AssertTest${CMAKE_EXECUTABLE_SUFF
 if( BUILD_CUDA )
    ADD_TEST( AssertCudaTest ${EXECUTABLE_OUTPUT_PATH}/AssertCudaTest${CMAKE_EXECUTABLE_SUFFIX} )
 endif()
+ADD_TEST( AllocatorsTest ${EXECUTABLE_OUTPUT_PATH}/AllocatorsTest${CMAKE_EXECUTABLE_SUFFIX} )
 ADD_TEST( FileTest ${EXECUTABLE_OUTPUT_PATH}/FileTest${CMAKE_EXECUTABLE_SUFFIX} )
 ADD_TEST( StringTest ${EXECUTABLE_OUTPUT_PATH}/StringTest${CMAKE_EXECUTABLE_SUFFIX} )
 ADD_TEST( ObjectTest ${EXECUTABLE_OUTPUT_PATH}/ObjectTest${CMAKE_EXECUTABLE_SUFFIX} )
diff --git a/src/UnitTests/Containers/ArrayOperationsTest.h b/src/UnitTests/Containers/ArrayOperationsTest.h
index 4c1b6b9c2ced4d380e93f1056cafab50b0335b64..749cea3edc486c411ea306f313faeb13cf29a140 100644
--- a/src/UnitTests/Containers/ArrayOperationsTest.h
+++ b/src/UnitTests/Containers/ArrayOperationsTest.h
@@ -10,7 +10,9 @@
 
 #pragma once
 
-#ifdef HAVE_GTEST 
+#ifdef HAVE_GTEST
+#include <TNL/Allocators/Host.h>
+#include <TNL/Allocators/Cuda.h>
 #include <TNL/Containers/Algorithms/ArrayOperations.h>
 
 #include "gtest/gtest.h"
@@ -37,166 +39,147 @@ TYPED_TEST_SUITE( ArrayOperationsTest, ValueTypes );
 TYPED_TEST( ArrayOperationsTest, allocateMemory_host )
 {
    using ValueType = typename TestFixture::ValueType;
+   using Allocator = Allocators::Host< ValueType >;
 
-   ValueType* data;
-   ArrayOperations< Devices::Host >::allocateMemory( data, ARRAY_TEST_SIZE );
+   Allocator allocator;
+   ValueType* data = allocator.allocate( ARRAY_TEST_SIZE );
    ASSERT_NE( data, nullptr );
 
-   ArrayOperations< Devices::Host >::freeMemory( data );
+   allocator.deallocate( data, ARRAY_TEST_SIZE );
 }
 
 TYPED_TEST( ArrayOperationsTest, setMemoryElement_host )
 {
    using ValueType = typename TestFixture::ValueType;
-   const int size = ARRAY_TEST_SIZE;
+   using Allocator = Allocators::Host< ValueType >;
 
-   ValueType *data;
-   ArrayOperations< Devices::Host >::allocateMemory( data, size );
-   for( int i = 0; i < size; i++ ) {
+   Allocator allocator;
+   ValueType* data = allocator.allocate( ARRAY_TEST_SIZE );
+   for( int i = 0; i < ARRAY_TEST_SIZE; i++ ) {
       ArrayOperations< Devices::Host >::setMemoryElement( data + i, (ValueType) i );
       EXPECT_EQ( data[ i ], i );
       EXPECT_EQ( ArrayOperations< Devices::Host >::getMemoryElement( data + i ), i );
    }
-   ArrayOperations< Devices::Host >::freeMemory( data );
+   allocator.deallocate( data, ARRAY_TEST_SIZE );
 }
 
 TYPED_TEST( ArrayOperationsTest, setMemory_host )
 {
    using ValueType = typename TestFixture::ValueType;
-   const int size = ARRAY_TEST_SIZE;
+   using Allocator = Allocators::Host< ValueType >;
 
-   ValueType *data;
-   ArrayOperations< Devices::Host >::allocateMemory( data, size );
-   ArrayOperations< Devices::Host >::setMemory( data, (ValueType) 13, size );
-   for( int i = 0; i < size; i ++ )
+   Allocator allocator;
+   ValueType* data = allocator.allocate( ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Host >::setMemory( data, (ValueType) 13, ARRAY_TEST_SIZE );
+   for( int i = 0; i < ARRAY_TEST_SIZE; i ++ )
       EXPECT_EQ( data[ i ], 13 );
-   ArrayOperations< Devices::Host >::freeMemory( data );
+   allocator.deallocate( data, ARRAY_TEST_SIZE );
 }
 
 TYPED_TEST( ArrayOperationsTest, copyMemory_host )
 {
    using ValueType = typename TestFixture::ValueType;
-   const int size = ARRAY_TEST_SIZE;
-
-   ValueType *data1, *data2;
-   ArrayOperations< Devices::Host >::allocateMemory( data1, size );
-   ArrayOperations< Devices::Host >::allocateMemory( data2, size );
-   ArrayOperations< Devices::Host >::setMemory( data1, (ValueType) 13, size );
-   ArrayOperations< Devices::Host >::copyMemory< ValueType, ValueType >( data2, data1, size );
-   for( int i = 0; i < size; i ++ )
+   using Allocator = Allocators::Host< ValueType >;
+
+   Allocator allocator;
+   ValueType* data1 = allocator.allocate( ARRAY_TEST_SIZE );
+   ValueType* data2 = allocator.allocate( ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Host >::setMemory( data1, (ValueType) 13, ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Host >::copyMemory< ValueType, ValueType >( data2, data1, ARRAY_TEST_SIZE );
+   for( int i = 0; i < ARRAY_TEST_SIZE; i ++ )
       EXPECT_EQ( data1[ i ], data2[ i ]);
-   ArrayOperations< Devices::Host >::freeMemory( data1 );
-   ArrayOperations< Devices::Host >::freeMemory( data2 );
+   allocator.deallocate( data1, ARRAY_TEST_SIZE );
+   allocator.deallocate( data2, ARRAY_TEST_SIZE );
 }
 
 TYPED_TEST( ArrayOperationsTest, copyMemoryWithConversion_host )
 {
-   using ValueType = typename TestFixture::ValueType;
-   const int size = ARRAY_TEST_SIZE;
-
-   int *data1;
-   float *data2;
-   ArrayOperations< Devices::Host >::allocateMemory( data1, size );
-   ArrayOperations< Devices::Host >::allocateMemory( data2, size );
-   ArrayOperations< Devices::Host >::setMemory( data1, 13, size );
-   ArrayOperations< Devices::Host >::copyMemory< float, int >( data2, data1, size );
-   for( int i = 0; i < size; i ++ )
+   using Allocator1 = Allocators::Host< int >;
+   using Allocator2 = Allocators::Host< float >;
+
+   Allocator1 allocator1;
+   Allocator2 allocator2;
+   int* data1 = allocator1.allocate( ARRAY_TEST_SIZE );
+   float* data2 = allocator2.allocate( ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Host >::setMemory( data1, 13, ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Host >::copyMemory< float, int >( data2, data1, ARRAY_TEST_SIZE );
+   for( int i = 0; i < ARRAY_TEST_SIZE; i ++ )
       EXPECT_EQ( data1[ i ], data2[ i ] );
-   ArrayOperations< Devices::Host >::freeMemory( data1 );
-   ArrayOperations< Devices::Host >::freeMemory( data2 );
+   allocator1.deallocate( data1, ARRAY_TEST_SIZE );
+   allocator2.deallocate( data2, ARRAY_TEST_SIZE );
 }
 
 TYPED_TEST( ArrayOperationsTest, compareMemory_host )
 {
    using ValueType = typename TestFixture::ValueType;
-   const int size = ARRAY_TEST_SIZE;
-
-   ValueType *data1, *data2;
-   ArrayOperations< Devices::Host >::allocateMemory( data1, size );
-   ArrayOperations< Devices::Host >::allocateMemory( data2, size );
-   ArrayOperations< Devices::Host >::setMemory( data1, (ValueType) 7, size );
-   ArrayOperations< Devices::Host >::setMemory( data2, (ValueType) 0, size );
-   EXPECT_FALSE( ( ArrayOperations< Devices::Host >::compareMemory< ValueType, ValueType >( data1, data2, size ) ) );
-   ArrayOperations< Devices::Host >::setMemory( data2, (ValueType) 7, size );
-   EXPECT_TRUE( ( ArrayOperations< Devices::Host >::compareMemory< ValueType, ValueType >( data1, data2, size ) ) );
-   ArrayOperations< Devices::Host >::freeMemory( data1 );
-   ArrayOperations< Devices::Host >::freeMemory( data2 );
+   using Allocator = Allocators::Host< ValueType >;
+
+   Allocator allocator;
+   ValueType* data1 = allocator.allocate( ARRAY_TEST_SIZE );
+   ValueType* data2 = allocator.allocate( ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Host >::setMemory( data1, (ValueType) 7, ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Host >::setMemory( data2, (ValueType) 0, ARRAY_TEST_SIZE );
+   EXPECT_FALSE( ( ArrayOperations< Devices::Host >::compareMemory< ValueType, ValueType >( data1, data2, ARRAY_TEST_SIZE ) ) );
+   ArrayOperations< Devices::Host >::setMemory( data2, (ValueType) 7, ARRAY_TEST_SIZE );
+   EXPECT_TRUE( ( ArrayOperations< Devices::Host >::compareMemory< ValueType, ValueType >( data1, data2, ARRAY_TEST_SIZE ) ) );
+   allocator.deallocate( data1, ARRAY_TEST_SIZE );
+   allocator.deallocate( data2, ARRAY_TEST_SIZE );
 }
 
 TYPED_TEST( ArrayOperationsTest, compareMemoryWithConversion_host )
 {
-   const int size = ARRAY_TEST_SIZE;
-
-   int *data1;
-   float *data2;
-   ArrayOperations< Devices::Host >::allocateMemory( data1, size );
-   ArrayOperations< Devices::Host >::allocateMemory( data2, size );
-   ArrayOperations< Devices::Host >::setMemory( data1, 7, size );
-   ArrayOperations< Devices::Host >::setMemory( data2, (float) 0.0, size );
-   EXPECT_FALSE( ( ArrayOperations< Devices::Host >::compareMemory< int, float >( data1, data2, size ) ) );
-   ArrayOperations< Devices::Host >::setMemory( data2, (float) 7.0, size );
-   EXPECT_TRUE( ( ArrayOperations< Devices::Host >::compareMemory< int, float >( data1, data2, size ) ) );
-   ArrayOperations< Devices::Host >::freeMemory( data1 );
-   ArrayOperations< Devices::Host >::freeMemory( data2 );
+   using Allocator1 = Allocators::Host< int >;
+   using Allocator2 = Allocators::Host< float >;
+
+   Allocator1 allocator1;
+   Allocator2 allocator2;
+   int* data1 = allocator1.allocate( ARRAY_TEST_SIZE );
+   float* data2 = allocator2.allocate( ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Host >::setMemory( data1, 7, ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Host >::setMemory( data2, (float) 0.0, ARRAY_TEST_SIZE );
+   EXPECT_FALSE( ( ArrayOperations< Devices::Host >::compareMemory< int, float >( data1, data2, ARRAY_TEST_SIZE ) ) );
+   ArrayOperations< Devices::Host >::setMemory( data2, (float) 7.0, ARRAY_TEST_SIZE );
+   EXPECT_TRUE( ( ArrayOperations< Devices::Host >::compareMemory< int, float >( data1, data2, ARRAY_TEST_SIZE ) ) );
+   allocator1.deallocate( data1, ARRAY_TEST_SIZE );
+   allocator2.deallocate( data2, ARRAY_TEST_SIZE );
 }
 
 TYPED_TEST( ArrayOperationsTest, containsValue_host )
 {
-   const int size = ARRAY_TEST_SIZE;
+   using ValueType = typename TestFixture::ValueType;
+   using Allocator = Allocators::Host< ValueType >;
+
+   Allocator allocator;
+   ValueType* data = allocator.allocate( ARRAY_TEST_SIZE );
 
-   int *data1;
-   float *data2;
-   ArrayOperations< Devices::Host >::allocateMemory( data1, size );
-   ArrayOperations< Devices::Host >::allocateMemory( data2, size );
    for( int i = 0; i < ARRAY_TEST_SIZE; i++ )
-   {
-      data1[ i ] = i % 10;
-      data2[ i ] = ( float ) ( i % 10 );
-   }
+      data[ i ] = i % 10;
    for( int i = 0; i < 10; i++ )
-   {
-      EXPECT_TRUE( ( ArrayOperations< Devices::Host >::containsValue( data1, size, i ) ) );
-      EXPECT_TRUE( ( ArrayOperations< Devices::Host >::containsValue( data2, size, ( float ) i ) ) );
-   }
+      EXPECT_TRUE( ( ArrayOperations< Devices::Host >::containsValue( data, ARRAY_TEST_SIZE, (ValueType) i ) ) );
    for( int i = 10; i < 20; i++ )
-   {
-      EXPECT_FALSE( ( ArrayOperations< Devices::Host >::containsValue( data1, size, i ) ) );
-      EXPECT_FALSE( ( ArrayOperations< Devices::Host >::containsValue( data2, size, ( float ) i ) ) );
-   }
-   ArrayOperations< Devices::Host >::freeMemory( data1 );
-   ArrayOperations< Devices::Host >::freeMemory( data2 );
+      EXPECT_FALSE( ( ArrayOperations< Devices::Host >::containsValue( data, ARRAY_TEST_SIZE, (ValueType) i ) ) );
+
+   allocator.deallocate( data, ARRAY_TEST_SIZE );
 }
 
 TYPED_TEST( ArrayOperationsTest, containsOnlyValue_host )
 {
-   const int size = ARRAY_TEST_SIZE;
+   using ValueType = typename TestFixture::ValueType;
+   using Allocator = Allocators::Host< ValueType >;
+
+   Allocator allocator;
+   ValueType* data = allocator.allocate( ARRAY_TEST_SIZE );
 
-   int *data1;
-   float *data2;
-   ArrayOperations< Devices::Host >::allocateMemory( data1, size );
-   ArrayOperations< Devices::Host >::allocateMemory( data2, size );
    for( int i = 0; i < ARRAY_TEST_SIZE; i++ )
-   {
-      data1[ i ] = i % 10;
-      data2[ i ] = ( float ) ( i % 10 );
-   }
+      data[ i ] = i % 10;
    for( int i = 0; i < 20; i++ )
-   {
-      EXPECT_FALSE( ( ArrayOperations< Devices::Host >::containsOnlyValue( data1, size, i ) ) );
-      EXPECT_FALSE( ( ArrayOperations< Devices::Host >::containsOnlyValue( data2, size, ( float ) i ) ) );
-   }
+      EXPECT_FALSE( ( ArrayOperations< Devices::Host >::containsOnlyValue( data, ARRAY_TEST_SIZE, (ValueType) i ) ) );
 
    for( int i = 0; i < ARRAY_TEST_SIZE; i++ )
-   {
-      data1[ i ] = 10;
-      data2[ i ] = ( float ) 10;
-   }
-
-   EXPECT_TRUE( ( ArrayOperations< Devices::Host >::containsOnlyValue( data1, size, 10 ) ) );
-   EXPECT_TRUE( ( ArrayOperations< Devices::Host >::containsOnlyValue( data2, size, ( float ) 10 ) ) );
+      data[ i ] = 10;
+   EXPECT_TRUE( ( ArrayOperations< Devices::Host >::containsOnlyValue( data, ARRAY_TEST_SIZE, (ValueType) 10 ) ) );
 
-   ArrayOperations< Devices::Host >::freeMemory( data1 );
-   ArrayOperations< Devices::Host >::freeMemory( data2 );
+   allocator.deallocate( data, ARRAY_TEST_SIZE );
 }
 
 
@@ -204,30 +187,30 @@ TYPED_TEST( ArrayOperationsTest, containsOnlyValue_host )
 TYPED_TEST( ArrayOperationsTest, allocateMemory_cuda )
 {
    using ValueType = typename TestFixture::ValueType;
-   const int size = ARRAY_TEST_SIZE;
+   using Allocator = Allocators::Cuda< ValueType >;
 
-   ValueType* data;
-   ArrayOperations< Devices::Cuda >::allocateMemory( data, size );
+   Allocator allocator;
+   ValueType* data = allocator.allocate( ARRAY_TEST_SIZE );
    ASSERT_NO_THROW( TNL_CHECK_CUDA_DEVICE );
    ASSERT_NE( data, nullptr );
 
-   ArrayOperations< Devices::Cuda >::freeMemory( data );
+   allocator.deallocate( data, ARRAY_TEST_SIZE );
    ASSERT_NO_THROW( TNL_CHECK_CUDA_DEVICE );
 }
 
 TYPED_TEST( ArrayOperationsTest, setMemoryElement_cuda )
 {
    using ValueType = typename TestFixture::ValueType;
-   const int size = ARRAY_TEST_SIZE;
+   using Allocator = Allocators::Cuda< ValueType >;
 
-   ValueType* data;
-   ArrayOperations< Devices::Cuda >::allocateMemory( data, size );
+   Allocator allocator;
+   ValueType* data = allocator.allocate( ARRAY_TEST_SIZE );
    ASSERT_NO_THROW( TNL_CHECK_CUDA_DEVICE );
 
-   for( int i = 0; i < size; i++ )
+   for( int i = 0; i < ARRAY_TEST_SIZE; i++ )
       ArrayOperations< Devices::Cuda >::setMemoryElement( &data[ i ], (ValueType) i );
 
-   for( int i = 0; i < size; i++ )
+   for( int i = 0; i < ARRAY_TEST_SIZE; i++ )
    {
       ValueType d;
       ASSERT_EQ( cudaMemcpy( &d, &data[ i ], sizeof( ValueType ), cudaMemcpyDeviceToHost ), cudaSuccess );
@@ -235,208 +218,192 @@ TYPED_TEST( ArrayOperationsTest, setMemoryElement_cuda )
       EXPECT_EQ( ArrayOperations< Devices::Cuda >::getMemoryElement( &data[ i ] ), i );
    }
 
-   ArrayOperations< Devices::Cuda >::freeMemory( data );
+   allocator.deallocate( data, ARRAY_TEST_SIZE );
    ASSERT_NO_THROW( TNL_CHECK_CUDA_DEVICE );
 }
 
 TYPED_TEST( ArrayOperationsTest, setMemory_cuda )
 {
    using ValueType = typename TestFixture::ValueType;
-   const int size = ARRAY_TEST_SIZE;
-
-   ValueType *hostData, *deviceData;
-   ArrayOperations< Devices::Host >::allocateMemory( hostData, size );
-   ArrayOperations< Devices::Cuda >::allocateMemory( deviceData, size );
-   ArrayOperations< Devices::Host >::setMemory( hostData, (ValueType) 0, size );
-   ArrayOperations< Devices::Cuda >::setMemory( deviceData, (ValueType) 13, size );
+   using HostAllocator = Allocators::Host< ValueType >;
+   using CudaAllocator = Allocators::Cuda< ValueType >;
+
+   HostAllocator hostAllocator;
+   CudaAllocator cudaAllocator;
+   ValueType* hostData = hostAllocator.allocate( ARRAY_TEST_SIZE );
+   ValueType* deviceData = cudaAllocator.allocate( ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Host >::setMemory( hostData, (ValueType) 0, ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Cuda >::setMemory( deviceData, (ValueType) 13, ARRAY_TEST_SIZE );
    ASSERT_NO_THROW( TNL_CHECK_CUDA_DEVICE );
-   ArrayOperations< Devices::Host, Devices::Cuda >::copyMemory< ValueType, ValueType >( hostData, deviceData, size );
+   ArrayOperations< Devices::Host, Devices::Cuda >::copyMemory< ValueType, ValueType >( hostData, deviceData, ARRAY_TEST_SIZE );
    ASSERT_NO_THROW( TNL_CHECK_CUDA_DEVICE );
-   for( int i = 0; i < size; i++ )
+   for( int i = 0; i < ARRAY_TEST_SIZE; i++ )
       EXPECT_EQ( hostData[ i ], 13 );
-   ArrayOperations< Devices::Host >::freeMemory( hostData );
-   ArrayOperations< Devices::Cuda >::freeMemory( deviceData );
+   hostAllocator.deallocate( hostData, ARRAY_TEST_SIZE );
+   cudaAllocator.deallocate( deviceData, ARRAY_TEST_SIZE );
 }
 
 TYPED_TEST( ArrayOperationsTest, copyMemory_cuda )
 {
    using ValueType = typename TestFixture::ValueType;
-   const int size = ARRAY_TEST_SIZE;
-
-   ValueType *hostData, *hostData2, *deviceData, *deviceData2;
-   ArrayOperations< Devices::Host >::allocateMemory( hostData, size );
-   ArrayOperations< Devices::Host >::allocateMemory( hostData2, size );
-   ArrayOperations< Devices::Cuda >::allocateMemory( deviceData, size );
-   ArrayOperations< Devices::Cuda >::allocateMemory( deviceData2, size );
-   ArrayOperations< Devices::Host >::setMemory( hostData, (ValueType) 13, size );
-   ArrayOperations< Devices::Cuda, Devices::Host >::copyMemory< ValueType >( deviceData, hostData, size );
-   ArrayOperations< Devices::Cuda >::copyMemory< ValueType, ValueType >( deviceData2, deviceData, size );
-   ArrayOperations< Devices::Host, Devices::Cuda >::copyMemory< ValueType, ValueType >( hostData2, deviceData2, size );
-   EXPECT_TRUE( ( ArrayOperations< Devices::Host >::compareMemory< ValueType, ValueType >( hostData, hostData2, size) ) );
-   ArrayOperations< Devices::Host >::freeMemory( hostData );
-   ArrayOperations< Devices::Host >::freeMemory( hostData2 );
-   ArrayOperations< Devices::Cuda >::freeMemory( deviceData );
-   ArrayOperations< Devices::Cuda >::freeMemory( deviceData2 );
+   using HostAllocator = Allocators::Host< ValueType >;
+   using CudaAllocator = Allocators::Cuda< ValueType >;
+
+   HostAllocator hostAllocator;
+   CudaAllocator cudaAllocator;
+   ValueType* hostData = hostAllocator.allocate( ARRAY_TEST_SIZE );
+   ValueType* hostData2 = hostAllocator.allocate( ARRAY_TEST_SIZE );
+   ValueType* deviceData = cudaAllocator.allocate( ARRAY_TEST_SIZE );
+   ValueType* deviceData2 = cudaAllocator.allocate( ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Host >::setMemory( hostData, (ValueType) 13, ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Cuda, Devices::Host >::copyMemory< ValueType >( deviceData, hostData, ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Cuda >::copyMemory< ValueType, ValueType >( deviceData2, deviceData, ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Host, Devices::Cuda >::copyMemory< ValueType, ValueType >( hostData2, deviceData2, ARRAY_TEST_SIZE );
+   EXPECT_TRUE( ( ArrayOperations< Devices::Host >::compareMemory< ValueType, ValueType >( hostData, hostData2, ARRAY_TEST_SIZE) ) );
+   hostAllocator.deallocate( hostData, ARRAY_TEST_SIZE );
+   hostAllocator.deallocate( hostData2, ARRAY_TEST_SIZE );
+   cudaAllocator.deallocate( deviceData, ARRAY_TEST_SIZE );
+   cudaAllocator.deallocate( deviceData2, ARRAY_TEST_SIZE );
 }
 
 TYPED_TEST( ArrayOperationsTest, copyMemoryWithConversions_cuda )
 {
-   const int size = ARRAY_TEST_SIZE;
-
-   int *hostData;
-   double *hostData2;
-   long *deviceData;
-   float *deviceData2;
-   ArrayOperations< Devices::Host >::allocateMemory( hostData, size );
-   ArrayOperations< Devices::Host >::allocateMemory( hostData2, size );
-   ArrayOperations< Devices::Cuda >::allocateMemory( deviceData, size );
-   ArrayOperations< Devices::Cuda >::allocateMemory( deviceData2, size );
-   ArrayOperations< Devices::Host >::setMemory( hostData, 13, size );
-   ArrayOperations< Devices::Cuda, Devices::Host >::copyMemory< long, int >( deviceData, hostData, size );
-   ArrayOperations< Devices::Cuda >::copyMemory< float, long >( deviceData2, deviceData, size );
-   ArrayOperations< Devices::Host, Devices::Cuda >::copyMemory< double, float >( hostData2, deviceData2, size );
-   for( int i = 0; i < size; i ++ )
+   using HostAllocator1 = Allocators::Host< int >;
+   using HostAllocator2 = Allocators::Host< double >;
+   using CudaAllocator1 = Allocators::Cuda< long >;
+   using CudaAllocator2 = Allocators::Cuda< float >;
+
+   HostAllocator1 hostAllocator1;
+   HostAllocator2 hostAllocator2;
+   CudaAllocator1 cudaAllocator1;
+   CudaAllocator2 cudaAllocator2;
+   int* hostData = hostAllocator1.allocate( ARRAY_TEST_SIZE );
+   double* hostData2 = hostAllocator2.allocate( ARRAY_TEST_SIZE );
+   long* deviceData = cudaAllocator1.allocate( ARRAY_TEST_SIZE );
+   float* deviceData2 = cudaAllocator2.allocate( ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Host >::setMemory( hostData, 13, ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Cuda, Devices::Host >::copyMemory< long, int >( deviceData, hostData, ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Cuda >::copyMemory< float, long >( deviceData2, deviceData, ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Host, Devices::Cuda >::copyMemory< double, float >( hostData2, deviceData2, ARRAY_TEST_SIZE );
+   for( int i = 0; i < ARRAY_TEST_SIZE; i ++ )
       EXPECT_EQ( hostData[ i ], hostData2[ i ] );
-   ArrayOperations< Devices::Host >::freeMemory( hostData );
-   ArrayOperations< Devices::Host >::freeMemory( hostData2 );
-   ArrayOperations< Devices::Cuda >::freeMemory( deviceData );
-   ArrayOperations< Devices::Cuda >::freeMemory( deviceData2 );
+   hostAllocator1.deallocate( hostData, ARRAY_TEST_SIZE );
+   hostAllocator2.deallocate( hostData2, ARRAY_TEST_SIZE );
+   cudaAllocator1.deallocate( deviceData, ARRAY_TEST_SIZE );
+   cudaAllocator2.deallocate( deviceData2, ARRAY_TEST_SIZE );
 }
 
 TYPED_TEST( ArrayOperationsTest, compareMemory_cuda )
 {
    using ValueType = typename TestFixture::ValueType;
-   const int size = ARRAY_TEST_SIZE;
-
-   ValueType *hostData, *deviceData, *deviceData2;
-   ArrayOperations< Devices::Host >::allocateMemory( hostData, size );
-   ArrayOperations< Devices::Cuda >::allocateMemory( deviceData, size );
-   ArrayOperations< Devices::Cuda >::allocateMemory( deviceData2, size );
-
-   ArrayOperations< Devices::Host >::setMemory( hostData, (ValueType) 7, size );
-   ArrayOperations< Devices::Cuda >::setMemory( deviceData, (ValueType) 8, size );
-   ArrayOperations< Devices::Cuda >::setMemory( deviceData2, (ValueType) 9, size );
-   EXPECT_FALSE(( ArrayOperations< Devices::Host, Devices::Cuda >::compareMemory< ValueType, ValueType >( hostData, deviceData, size ) ));
-   EXPECT_FALSE(( ArrayOperations< Devices::Cuda, Devices::Host >::compareMemory< ValueType, ValueType >( deviceData, hostData, size ) ));
-   EXPECT_FALSE(( ArrayOperations< Devices::Cuda >::compareMemory< ValueType, ValueType >( deviceData, deviceData2, size ) ));
-
-   ArrayOperations< Devices::Cuda >::setMemory( deviceData, (ValueType) 7, size );
-   ArrayOperations< Devices::Cuda >::setMemory( deviceData2, (ValueType) 7, size );
-   EXPECT_TRUE(( ArrayOperations< Devices::Host, Devices::Cuda >::compareMemory< ValueType, ValueType >( hostData, deviceData, size ) ));
-   EXPECT_TRUE(( ArrayOperations< Devices::Cuda, Devices::Host >::compareMemory< ValueType, ValueType >( deviceData, hostData, size ) ));
-   EXPECT_TRUE(( ArrayOperations< Devices::Cuda >::compareMemory< ValueType, ValueType >( deviceData, deviceData2, size ) ));
-
-   ArrayOperations< Devices::Host >::freeMemory( hostData );
-   ArrayOperations< Devices::Cuda >::freeMemory( deviceData );
-   ArrayOperations< Devices::Cuda >::freeMemory( deviceData2 );
+   using HostAllocator = Allocators::Host< ValueType >;
+   using CudaAllocator = Allocators::Cuda< ValueType >;
+
+   HostAllocator hostAllocator;
+   CudaAllocator cudaAllocator;
+   ValueType* hostData = hostAllocator.allocate( ARRAY_TEST_SIZE );
+   ValueType* deviceData = cudaAllocator.allocate( ARRAY_TEST_SIZE );
+   ValueType* deviceData2 = cudaAllocator.allocate( ARRAY_TEST_SIZE );
+
+   ArrayOperations< Devices::Host >::setMemory( hostData, (ValueType) 7, ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Cuda >::setMemory( deviceData, (ValueType) 8, ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Cuda >::setMemory( deviceData2, (ValueType) 9, ARRAY_TEST_SIZE );
+   EXPECT_FALSE(( ArrayOperations< Devices::Host, Devices::Cuda >::compareMemory< ValueType, ValueType >( hostData, deviceData, ARRAY_TEST_SIZE ) ));
+   EXPECT_FALSE(( ArrayOperations< Devices::Cuda, Devices::Host >::compareMemory< ValueType, ValueType >( deviceData, hostData, ARRAY_TEST_SIZE ) ));
+   EXPECT_FALSE(( ArrayOperations< Devices::Cuda >::compareMemory< ValueType, ValueType >( deviceData, deviceData2, ARRAY_TEST_SIZE ) ));
+
+   ArrayOperations< Devices::Cuda >::setMemory( deviceData, (ValueType) 7, ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Cuda >::setMemory( deviceData2, (ValueType) 7, ARRAY_TEST_SIZE );
+   EXPECT_TRUE(( ArrayOperations< Devices::Host, Devices::Cuda >::compareMemory< ValueType, ValueType >( hostData, deviceData, ARRAY_TEST_SIZE ) ));
+   EXPECT_TRUE(( ArrayOperations< Devices::Cuda, Devices::Host >::compareMemory< ValueType, ValueType >( deviceData, hostData, ARRAY_TEST_SIZE ) ));
+   EXPECT_TRUE(( ArrayOperations< Devices::Cuda >::compareMemory< ValueType, ValueType >( deviceData, deviceData2, ARRAY_TEST_SIZE ) ));
+
+   hostAllocator.deallocate( hostData, ARRAY_TEST_SIZE );
+   cudaAllocator.deallocate( deviceData, ARRAY_TEST_SIZE );
+   cudaAllocator.deallocate( deviceData2, ARRAY_TEST_SIZE );
 }
 
 TYPED_TEST( ArrayOperationsTest, compareMemoryWithConversions_cuda )
 {
-   const int size = ARRAY_TEST_SIZE;
-
-   int *hostData;
-   float *deviceData;
-   double *deviceData2;
-   ArrayOperations< Devices::Host >::allocateMemory( hostData, size );
-   ArrayOperations< Devices::Cuda >::allocateMemory( deviceData, size );
-   ArrayOperations< Devices::Cuda >::allocateMemory( deviceData2, size );
-
-   ArrayOperations< Devices::Host >::setMemory( hostData, 7, size );
-   ArrayOperations< Devices::Cuda >::setMemory( deviceData, (float) 8, size );
-   ArrayOperations< Devices::Cuda >::setMemory( deviceData2, (double) 9, size );
-   EXPECT_FALSE(( ArrayOperations< Devices::Host, Devices::Cuda >::compareMemory< int, float >( hostData, deviceData, size ) ));
-   EXPECT_FALSE(( ArrayOperations< Devices::Cuda, Devices::Host >::compareMemory< float, int >( deviceData, hostData, size ) ));
-   EXPECT_FALSE(( ArrayOperations< Devices::Cuda >::compareMemory< float, double >( deviceData, deviceData2, size ) ));
-
-   ArrayOperations< Devices::Cuda >::setMemory( deviceData, (float) 7, size );
-   ArrayOperations< Devices::Cuda >::setMemory( deviceData2, (double) 7, size );
-   EXPECT_TRUE(( ArrayOperations< Devices::Host, Devices::Cuda >::compareMemory< int, float >( hostData, deviceData, size ) ));
-   EXPECT_TRUE(( ArrayOperations< Devices::Cuda, Devices::Host >::compareMemory< float, int >( deviceData, hostData, size ) ));
-   EXPECT_TRUE(( ArrayOperations< Devices::Cuda >::compareMemory< float, double >( deviceData, deviceData2, size ) ));
-
-   ArrayOperations< Devices::Host >::freeMemory( hostData );
-   ArrayOperations< Devices::Cuda >::freeMemory( deviceData );
-   ArrayOperations< Devices::Cuda >::freeMemory( deviceData2 );
+   using HostAllocator = Allocators::Host< int >;
+   using CudaAllocator1 = Allocators::Cuda< float >;
+   using CudaAllocator2 = Allocators::Cuda< double >;
+
+   HostAllocator hostAllocator;
+   CudaAllocator1 cudaAllocator1;
+   CudaAllocator2 cudaAllocator2;
+   int* hostData = hostAllocator.allocate( ARRAY_TEST_SIZE );
+   float* deviceData = cudaAllocator1.allocate( ARRAY_TEST_SIZE );
+   double* deviceData2 = cudaAllocator2.allocate( ARRAY_TEST_SIZE );
+
+   ArrayOperations< Devices::Host >::setMemory( hostData, 7, ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Cuda >::setMemory( deviceData, (float) 8, ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Cuda >::setMemory( deviceData2, (double) 9, ARRAY_TEST_SIZE );
+   EXPECT_FALSE(( ArrayOperations< Devices::Host, Devices::Cuda >::compareMemory< int, float >( hostData, deviceData, ARRAY_TEST_SIZE ) ));
+   EXPECT_FALSE(( ArrayOperations< Devices::Cuda, Devices::Host >::compareMemory< float, int >( deviceData, hostData, ARRAY_TEST_SIZE ) ));
+   EXPECT_FALSE(( ArrayOperations< Devices::Cuda >::compareMemory< float, double >( deviceData, deviceData2, ARRAY_TEST_SIZE ) ));
+
+   ArrayOperations< Devices::Cuda >::setMemory( deviceData, (float) 7, ARRAY_TEST_SIZE );
+   ArrayOperations< Devices::Cuda >::setMemory( deviceData2, (double) 7, ARRAY_TEST_SIZE );
+   EXPECT_TRUE(( ArrayOperations< Devices::Host, Devices::Cuda >::compareMemory< int, float >( hostData, deviceData, ARRAY_TEST_SIZE ) ));
+   EXPECT_TRUE(( ArrayOperations< Devices::Cuda, Devices::Host >::compareMemory< float, int >( deviceData, hostData, ARRAY_TEST_SIZE ) ));
+   EXPECT_TRUE(( ArrayOperations< Devices::Cuda >::compareMemory< float, double >( deviceData, deviceData2, ARRAY_TEST_SIZE ) ));
+
+   hostAllocator.deallocate( hostData, ARRAY_TEST_SIZE );
+   cudaAllocator1.deallocate( deviceData, ARRAY_TEST_SIZE );
+   cudaAllocator2.deallocate( deviceData2, ARRAY_TEST_SIZE );
 }
 
 TYPED_TEST( ArrayOperationsTest, containsValue_cuda )
 {
-   const int size = ARRAY_TEST_SIZE;
+   using ValueType = typename TestFixture::ValueType;
+   using HostAllocator = Allocators::Host< ValueType >;
+   using CudaAllocator = Allocators::Cuda< ValueType >;
 
-   int *data1_host, *data1_cuda;
-   float *data2_host, *data2_cuda;
-   ArrayOperations< Devices::Host >::allocateMemory( data1_host, size );
-   ArrayOperations< Devices::Host >::allocateMemory( data2_host, size );
-   ArrayOperations< Devices::Cuda >::allocateMemory( data1_cuda, size );
-   ArrayOperations< Devices::Cuda >::allocateMemory( data2_cuda, size );
+   HostAllocator hostAllocator;
+   CudaAllocator cudaAllocator;
+   ValueType* hostData = hostAllocator.allocate( ARRAY_TEST_SIZE );
+   ValueType* deviceData = cudaAllocator.allocate( ARRAY_TEST_SIZE );
 
    for( int i = 0; i < ARRAY_TEST_SIZE; i++ )
-   {
-      data1_host[ i ] = i % 10;
-      data2_host[ i ] = ( float ) ( i % 10 );
-   }
-
-   ArrayOperations< Devices::Cuda, Devices::Host >::copyMemory( data1_cuda, data1_host, size );
-   ArrayOperations< Devices::Cuda, Devices::Host >::copyMemory( data2_cuda, data2_host, size );
+      hostData[ i ] = i % 10;
+   ArrayOperations< Devices::Cuda, Devices::Host >::copyMemory( deviceData, hostData, ARRAY_TEST_SIZE );
 
    for( int i = 0; i < 10; i++ )
-   {
-      EXPECT_TRUE( ( ArrayOperations< Devices::Cuda >::containsValue( data1_cuda, size, i ) ) );
-      EXPECT_TRUE( ( ArrayOperations< Devices::Cuda >::containsValue( data2_cuda, size, ( float ) i ) ) );
-   }
+      EXPECT_TRUE( ( ArrayOperations< Devices::Cuda >::containsValue( deviceData, ARRAY_TEST_SIZE, (ValueType) i ) ) );
    for( int i = 10; i < 20; i++ )
-   {
-      EXPECT_FALSE( ( ArrayOperations< Devices::Cuda >::containsValue( data1_cuda, size, i ) ) );
-      EXPECT_FALSE( ( ArrayOperations< Devices::Cuda >::containsValue( data2_cuda, size, ( float ) i ) ) );
-   }
+      EXPECT_FALSE( ( ArrayOperations< Devices::Cuda >::containsValue( deviceData, ARRAY_TEST_SIZE, (ValueType) i ) ) );
 
-   ArrayOperations< Devices::Host >::freeMemory( data1_host );
-   ArrayOperations< Devices::Host >::freeMemory( data2_host );
-   ArrayOperations< Devices::Cuda >::freeMemory( data1_cuda );
-   ArrayOperations< Devices::Cuda >::freeMemory( data2_cuda );
+   hostAllocator.deallocate( hostData, ARRAY_TEST_SIZE );
+   cudaAllocator.deallocate( deviceData, ARRAY_TEST_SIZE );
 }
 
 TYPED_TEST( ArrayOperationsTest, containsOnlyValue_cuda )
 {
-   const int size = ARRAY_TEST_SIZE;
+   using ValueType = typename TestFixture::ValueType;
+   using HostAllocator = Allocators::Host< ValueType >;
+   using CudaAllocator = Allocators::Cuda< ValueType >;
 
-   int *data1_host, *data1_cuda;
-   float *data2_host, *data2_cuda;
-   ArrayOperations< Devices::Host >::allocateMemory( data1_host, size );
-   ArrayOperations< Devices::Host >::allocateMemory( data2_host, size );
-   ArrayOperations< Devices::Cuda >::allocateMemory( data1_cuda, size );
-   ArrayOperations< Devices::Cuda >::allocateMemory( data2_cuda, size );
+   HostAllocator hostAllocator;
+   CudaAllocator cudaAllocator;
+   ValueType* hostData = hostAllocator.allocate( ARRAY_TEST_SIZE );
+   ValueType* deviceData = cudaAllocator.allocate( ARRAY_TEST_SIZE );
 
    for( int i = 0; i < ARRAY_TEST_SIZE; i++ )
-   {
-      data1_host[ i ] = i % 10;
-      data2_host[ i ] = ( float ) ( i % 10 );
-   }
-   ArrayOperations< Devices::Cuda, Devices::Host >::copyMemory( data1_cuda, data1_host, size );
-   ArrayOperations< Devices::Cuda, Devices::Host >::copyMemory( data2_cuda, data2_host, size );
+      hostData[ i ] = i % 10;
+   ArrayOperations< Devices::Cuda, Devices::Host >::copyMemory( deviceData, hostData, ARRAY_TEST_SIZE );
 
    for( int i = 0; i < 20; i++ )
-   {
-      EXPECT_FALSE( ( ArrayOperations< Devices::Cuda >::containsOnlyValue( data1_cuda, size, i ) ) );
-      EXPECT_FALSE( ( ArrayOperations< Devices::Cuda >::containsOnlyValue( data2_cuda, size, ( float ) i ) ) );
-   }
+      EXPECT_FALSE( ( ArrayOperations< Devices::Cuda >::containsOnlyValue( deviceData, ARRAY_TEST_SIZE, (ValueType) i ) ) );
 
    for( int i = 0; i < ARRAY_TEST_SIZE; i++ )
-   {
-      data1_host[ i ] = 10;
-      data2_host[ i ] = ( float ) 10;
-   }
-   ArrayOperations< Devices::Cuda, Devices::Host >::copyMemory( data1_cuda, data1_host, size );
-   ArrayOperations< Devices::Cuda, Devices::Host >::copyMemory( data2_cuda, data2_host, size );
+      hostData[ i ] = 10;
+   ArrayOperations< Devices::Cuda, Devices::Host >::copyMemory( deviceData, hostData, ARRAY_TEST_SIZE );
 
-   EXPECT_TRUE( ( ArrayOperations< Devices::Cuda >::containsOnlyValue( data1_cuda, size, 10 ) ) );
-   EXPECT_TRUE( ( ArrayOperations< Devices::Cuda >::containsOnlyValue( data2_cuda, size, ( float ) 10 ) ) );
+   EXPECT_TRUE( ( ArrayOperations< Devices::Cuda >::containsOnlyValue( deviceData, ARRAY_TEST_SIZE, (ValueType) 10 ) ) );
 
-   ArrayOperations< Devices::Host >::freeMemory( data1_host );
-   ArrayOperations< Devices::Host >::freeMemory( data2_host );
-   ArrayOperations< Devices::Cuda >::freeMemory( data1_cuda );
-   ArrayOperations< Devices::Cuda >::freeMemory( data2_cuda );
+   hostAllocator.deallocate( hostData, ARRAY_TEST_SIZE );
+   cudaAllocator.deallocate( deviceData, ARRAY_TEST_SIZE );
 }
 #endif // HAVE_CUDA
 #endif // HAVE_GTEST