test: Pass containers by const reference to functors

test/stdgpu/atomic.inc

@@ -277,7 +277,7 @@ template <typename T>
 class exchange_sequence
 {
     public:
-        explicit exchange_sequence(stdgpu::atomic<T> value)
+        explicit exchange_sequence(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 
@@ -341,7 +341,7 @@ template <typename T>
 class add_sequence_with_compare_exchange_weak
 {
     public:
-        explicit add_sequence_with_compare_exchange_weak(stdgpu::atomic<T> value)
+        explicit add_sequence_with_compare_exchange_weak(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 
@@ -366,7 +366,7 @@ template <typename T>
 class add_sequence_with_compare_exchange_strong
 {
     public:
-        explicit add_sequence_with_compare_exchange_strong(stdgpu::atomic<T> value)
+        explicit add_sequence_with_compare_exchange_strong(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 
@@ -465,7 +465,7 @@ template <typename T>
 class add_sequence
 {
     public:
-        explicit add_sequence(stdgpu::atomic<T> value)
+        explicit add_sequence(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 
@@ -486,7 +486,7 @@ template <typename T>
 class add_equals_sequence
 {
     public:
-        explicit add_equals_sequence(stdgpu::atomic<T> value)
+        explicit add_equals_sequence(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 
@@ -581,7 +581,7 @@ template <typename T>
 class sub_sequence
 {
     public:
-        explicit sub_sequence(stdgpu::atomic<T> value)
+        explicit sub_sequence(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 
@@ -602,7 +602,7 @@ template <typename T>
 class sub_equals_sequence
 {
     public:
-        explicit sub_equals_sequence(stdgpu::atomic<T> value)
+        explicit sub_equals_sequence(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 
@@ -716,7 +716,7 @@ template <typename T>
 class or_sequence
 {
     public:
-        explicit or_sequence(stdgpu::atomic<T> value)
+        explicit or_sequence(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 
@@ -739,7 +739,7 @@ template <typename T>
 class or_equals_sequence
 {
     public:
-        explicit or_equals_sequence(stdgpu::atomic<T> value)
+        explicit or_equals_sequence(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 
@@ -836,7 +836,7 @@ template <typename T>
 class and_sequence
 {
     public:
-        and_sequence(stdgpu::atomic<T> value,
+        and_sequence(const stdgpu::atomic<T>& value,
                      T one_pattern)
             : _value(value),
               _one_pattern(one_pattern)
@@ -862,7 +862,7 @@ template <typename T>
 class and_equals_sequence
 {
     public:
-        and_equals_sequence(stdgpu::atomic<T> value,
+        and_equals_sequence(const stdgpu::atomic<T>& value,
                             T one_pattern)
             : _value(value),
               _one_pattern(one_pattern)
@@ -984,7 +984,7 @@ template <typename T>
 class xor_sequence
 {
     public:
-        explicit xor_sequence(stdgpu::atomic<T> value)
+        explicit xor_sequence(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 
@@ -1007,7 +1007,7 @@ template <typename T>
 class xor_equals_sequence
 {
     public:
-        explicit xor_equals_sequence(stdgpu::atomic<T> value)
+        explicit xor_equals_sequence(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 
@@ -1104,7 +1104,7 @@ template <typename T>
 class min_sequence
 {
     public:
-        explicit min_sequence(stdgpu::atomic<T> value)
+        explicit min_sequence(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 
@@ -1163,7 +1163,7 @@ template <typename T>
 class max_sequence
 {
     public:
-        explicit max_sequence(stdgpu::atomic<T> value)
+        explicit max_sequence(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 
@@ -1222,7 +1222,7 @@ template <typename T>
 class inc_mod_sequence
 {
     public:
-        explicit inc_mod_sequence(stdgpu::atomic<T> value)
+        explicit inc_mod_sequence(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 
@@ -1281,7 +1281,7 @@ template <typename T>
 class dec_mod_dequence
 {
     public:
-        explicit dec_mod_dequence(stdgpu::atomic<T> value)
+        explicit dec_mod_dequence(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 
@@ -1340,7 +1340,7 @@ template <typename T>
 class pre_inc_sequence
 {
     public:
-        explicit pre_inc_sequence(stdgpu::atomic<T> value)
+        explicit pre_inc_sequence(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 
@@ -1404,7 +1404,7 @@ template <typename T>
 class post_inc_sequence
 {
     public:
-        explicit post_inc_sequence(stdgpu::atomic<T> value)
+        explicit post_inc_sequence(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 
@@ -1468,7 +1468,7 @@ template <typename T>
 class pre_dec_sequence
 {
     public:
-        explicit pre_dec_sequence(stdgpu::atomic<T> value)
+        explicit pre_dec_sequence(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 
@@ -1539,7 +1539,7 @@ template <typename T>
 class post_dec_sequence
 {
     public:
-        explicit post_dec_sequence(stdgpu::atomic<T> value)
+        explicit post_dec_sequence(const stdgpu::atomic<T>& value)
             : _value(value)
         {
 

test/stdgpu/bitset.inc

@@ -61,7 +61,7 @@ TEST_F(stdgpu_bitset, default_values)
 class set_all_bits
 {
     public:
-        explicit set_all_bits(stdgpu::bitset bitset)
+        explicit set_all_bits(const stdgpu::bitset& bitset)
             : _bitset(bitset)
         {
 
@@ -83,7 +83,7 @@ class set_all_bits
 class reset_all_bits
 {
     public:
-        explicit reset_all_bits(stdgpu::bitset bitset)
+        explicit reset_all_bits(const stdgpu::bitset& bitset)
             : _bitset(bitset)
         {
 
@@ -105,7 +105,7 @@ class reset_all_bits
 class set_and_reset_all_bits
 {
     public:
-        explicit set_and_reset_all_bits(stdgpu::bitset bitset)
+        explicit set_and_reset_all_bits(const stdgpu::bitset& bitset)
             : _bitset(bitset)
         {
 
@@ -132,7 +132,7 @@ class set_and_reset_all_bits
 class flip_all_bits
 {
     public:
-        explicit flip_all_bits(stdgpu::bitset bitset)
+        explicit flip_all_bits(const stdgpu::bitset& bitset)
             : _bitset(bitset)
         {
 
@@ -300,7 +300,7 @@ generate_shuffled_sequence(const stdgpu::index_t size)
 class set_bits
 {
     public:
-        set_bits(stdgpu::bitset bitset,
+        set_bits(const stdgpu::bitset& bitset,
                  stdgpu::index_t* positions,
                  std::uint8_t* set)
             : _bitset(bitset),
@@ -328,7 +328,7 @@ class set_bits
 class reset_bits
 {
     public:
-        reset_bits(stdgpu::bitset bitset,
+        reset_bits(const stdgpu::bitset& bitset,
                    stdgpu::index_t* positions,
                    std::uint8_t* set)
             : _bitset(bitset),
@@ -356,7 +356,7 @@ class reset_bits
 class set_and_reset_bits
 {
     public:
-        set_and_reset_bits(stdgpu::bitset bitset,
+        set_and_reset_bits(const stdgpu::bitset& bitset,
                            stdgpu::index_t* positions,
                            std::uint8_t* set)
             : _bitset(bitset),
@@ -389,7 +389,7 @@ class set_and_reset_bits
 class flip_bits
 {
     public:
-        flip_bits(stdgpu::bitset bitset,
+        flip_bits(const stdgpu::bitset& bitset,
                   stdgpu::index_t* positions,
                   std::uint8_t* set)
             : _bitset(bitset),