Apply suggestions from code review

PointKernel · sleeepyjack · web-flow · commit a9027e452ab3 · 2024-11-19T11:58:32.000-08:00
Co-authored-by: Daniel Jünger &lt;djuenger@nvidia.com&gt;
diff --git a/tests/static_map/capacity_test.cu b/tests/static_map/capacity_test.cu
@@ -18,7 +18,7 @@
 
 #include <catch2/catch_test_macros.hpp>
 
-TEST_CASE("static_map capacity", "")
+TEST_CASE("static_map capacity test", "")
 {
   using Key        = int32_t;
   using T          = int32_t;
diff --git a/tests/static_map/custom_type_test.cu b/tests/static_map/custom_type_test.cu
@@ -98,7 +98,7 @@ struct custom_key_equals {
   }
 };
 
-TEMPLATE_TEST_CASE_SIG("static_map custom key and value type",
+TEMPLATE_TEST_CASE_SIG("static_map custom key and value type tests",
                        "",
                        ((typename Key, typename Value), Key, Value),
 #if defined(CUCO_HAS_INDEPENDENT_THREADS)  // Key type larger than 8B only supported for sm_70 and
diff --git a/tests/static_map/heterogeneous_lookup_test.cu b/tests/static_map/heterogeneous_lookup_test.cu
@@ -82,7 +82,7 @@ struct custom_key_equal {
   }
 };
 
-TEMPLATE_TEST_CASE_SIG("static_map heterogeneous lookup",
+TEMPLATE_TEST_CASE_SIG("static_map heterogeneous lookup tests",
                        "",
                        ((typename T, int CGSize), T, CGSize),
 #if defined(CUCO_HAS_INDEPENDENT_THREADS)  // Key type larger than 8B only supported for sm_70 and
diff --git a/tests/static_map/insert_or_assign_test.cu b/tests/static_map/insert_or_assign_test.cu
@@ -71,7 +71,7 @@ void test_insert_or_assign(Map& map, size_type num_keys)
 }
 
 TEMPLATE_TEST_CASE_SIG(
-  "static_map insert_or_assign",
+  "static_map insert_or_assign tests",
   "",
   ((typename Key, typename Value, cuco::test::probe_sequence Probe, int CGSize),
    Key,
diff --git a/tests/static_map/rehash_test.cu b/tests/static_map/rehash_test.cu
@@ -22,7 +22,7 @@
 
 #include <catch2/catch_test_macros.hpp>
 
-TEST_CASE("static_map rehash", "")
+TEST_CASE("static_map rehash test", "")
 {
   using key_type    = int;
   using mapped_type = long;
diff --git a/tests/static_multimap/custom_pair_retrieve_test.cu b/tests/static_multimap/custom_pair_retrieve_test.cu
@@ -188,7 +188,7 @@ void test_non_shmem_pair_retrieve(Map& map, std::size_t const num_pairs)
 }
 
 TEMPLATE_TEST_CASE_SIG(
-  "static_multimap non-shared-memory pair_retrieve",
+  "static_multimap non-shared-memory pair_retrieve tests",
   "",
   ((typename Key, typename Value, cuco::test::probe_sequence Probe), Key, Value, Probe),
   (int32_t, int32_t, cuco::test::probe_sequence::linear_probing),
diff --git a/tests/static_multimap/custom_type_test.cu b/tests/static_multimap/custom_type_test.cu
@@ -208,7 +208,7 @@ void test_custom_key_value_type(Map& map, std::size_t num_pairs)
   }
 }
 
-TEMPLATE_TEST_CASE_SIG("static_multimap user defined key and value type",
+TEMPLATE_TEST_CASE_SIG("static_multimap user defined key and value type tests",
                        "",
                        ((cuco::test::probe_sequence Probe), Probe),
                        (cuco::test::probe_sequence::linear_probing),
diff --git a/tests/static_multimap/heterogeneous_lookup_test.cu b/tests/static_multimap/heterogeneous_lookup_test.cu
@@ -80,7 +80,7 @@ struct custom_key_equal {
   }
 };
 
-TEMPLATE_TEST_CASE("static_multimap heterogeneous lookup",
+TEMPLATE_TEST_CASE("static_multimap heterogeneous lookup tests",
                    "",
 #if defined(CUCO_HAS_INDEPENDENT_THREADS)  // Key type larger than 8B only supported for sm_70 and
                                            // up
diff --git a/tests/static_multimap/pair_function_test.cu b/tests/static_multimap/pair_function_test.cu
@@ -108,7 +108,7 @@ void test_pair_functions(Map& map, PairIt pair_begin, std::size_t num_pairs)
 }
 
 TEMPLATE_TEST_CASE_SIG(
-  "static_multimap pair functions",
+  "static_multimap pair functions tests",
   "",
   ((typename Key, typename Value, cuco::test::probe_sequence Probe), Key, Value, Probe),
   (int32_t, int32_t, cuco::test::probe_sequence::linear_probing),
diff --git a/tests/static_set/capacity_test.cu b/tests/static_set/capacity_test.cu
@@ -18,7 +18,7 @@
 
 #include <catch2/catch_test_macros.hpp>
 
-TEST_CASE("static_set capacity", "")
+TEST_CASE("static_set capacity test", "")
 {
   using Key        = int32_t;
   using ProbeT     = cuco::double_hashing<1, cuco::default_hash_function<Key>>;
diff --git a/tests/static_set/heterogeneous_lookup_test.cu b/tests/static_set/heterogeneous_lookup_test.cu
@@ -82,7 +82,7 @@ struct custom_key_equal {
   }
 };
 
-TEMPLATE_TEST_CASE_SIG("static_set heterogeneous lookup",
+TEMPLATE_TEST_CASE_SIG("static_set heterogeneous lookup tests",
                        "",
                        ((typename T, int CGSize), T, CGSize),
                        (int32_t, 1),
diff --git a/tests/static_set/rehash_test.cu b/tests/static_set/rehash_test.cu
@@ -21,7 +21,7 @@
 
 #include <catch2/catch_test_macros.hpp>
 
-TEST_CASE("static_set rehash", "")
+TEST_CASE("static_set rehash test", "")
 {
   using key_type = int;
 
diff --git a/tests/static_set/retrieve_test.cu b/tests/static_set/retrieve_test.cu
@@ -73,7 +73,7 @@ void test_unique_sequence(Set& set, std::size_t num_keys)
 }
 
 TEMPLATE_TEST_CASE_SIG(
-  "static_set retrieve",
+  "static_set retrieve tests",
   "",
   ((typename Key, cuco::test::probe_sequence Probe, int CGSize), Key, Probe, CGSize),
   (int32_t, cuco::test::probe_sequence::double_hashing, 1),
diff --git a/tests/static_set/shared_memory_test.cu b/tests/static_set/shared_memory_test.cu
@@ -64,7 +64,7 @@ __global__ void shared_memory_test_kernel(Ref* sets,
   }
 }
 
-TEMPLATE_TEST_CASE_SIG("static_set shared memory", "", ((typename Key), Key), (int32_t), (int64_t))
+TEMPLATE_TEST_CASE_SIG("static_set shared memory tests", "", ((typename Key), Key), (int32_t), (int64_t))
 {
   constexpr std::size_t number_of_sets  = 1000;
   constexpr std::size_t elements_in_set = 500;
@@ -187,7 +187,7 @@ __global__ void shared_memory_hash_set_kernel(bool* key_found)
   if (retrieved_it != find_ref.end() && *retrieved_it == rank) { key_found[index] = true; }
 }
 
-TEST_CASE("static_set shared memory slots.", "")
+TEST_CASE("static_set shared memory slots test", "")
 {
   constexpr std::size_t N = 256;
   [[maybe_unused]] auto constexpr num_windows =
diff --git a/tests/static_set/size_test.cu b/tests/static_set/size_test.cu
@@ -22,7 +22,7 @@
 
 #include <catch2/catch_test_macros.hpp>
 
-TEST_CASE("static_set size computation", "")
+TEST_CASE("static_set size test", "")
 {
   constexpr std::size_t num_keys{400};
 
diff --git a/tests/static_set/unique_sequence_test.cu b/tests/static_set/unique_sequence_test.cu
@@ -136,7 +136,7 @@ void test_unique_sequence(Set& set, size_type num_keys)
 }
 
 TEMPLATE_TEST_CASE_SIG(
-  "static_set unique sequence",
+  "static_set unique sequence tests",
   "",
   ((typename Key, cuco::test::probe_sequence Probe, int CGSize), Key, Probe, CGSize),
   (int32_t, cuco::test::probe_sequence::double_hashing, 1),
diff --git a/tests/utility/hash_test.cu b/tests/utility/hash_test.cu
@@ -67,7 +67,7 @@ __global__ void check_identity_hash_result_kernel(OutputIter result)
     cuda::std::numeric_limits<int64_t>::max(), cuda::std::numeric_limits<int64_t>::max());
 }
 
-TEST_CASE("utility cuco::identity_hash tests", "")
+TEST_CASE("utility cuco::identity_hash test", "")
 {
   SECTION("Check if host-generated hash values match the identity function.")
   {
@@ -121,7 +121,7 @@ __global__ void check_hash_result_kernel_64(OutputIter result)
     check_hash_result<cuco::xxhash_64<large_key<32>>>(123456789, 2031761887105658523, 0);
 }
 
-TEST_CASE("utility cuco::xxhash_64 tests", "")
+TEST_CASE("utility cuco::xxhash_64 test", "")
 {
   // Reference hash values were computed using https://github.com/Cyan4973/xxHash
   SECTION("Check if host-generated hash values match the reference implementation.")
@@ -184,7 +184,7 @@ __global__ void check_hash_result_kernel_32(OutputIter result)
   result[i++] = check_hash_result<cuco::xxhash_32<large_key<32>>>(123456789, 3715432378, 0);
 }
 
-TEST_CASE("utility cuco::xxhash_32 tests", "")
+TEST_CASE("utility cuco::xxhash_32 test", "")
 {
   // Reference hash values were computed using https://github.com/Cyan4973/xxHash
   SECTION("Check if host-generated hash values match the reference implementation.")
@@ -323,7 +323,7 @@ __global__ void check_murmurhash3_128_result_kernel(OutputIter result)
       1024);
 }
 
-TEST_CASE("utility cuco::murmurhash3_x64_128 tests", "")
+TEST_CASE("utility cuco::murmurhash3_x64_128 test", "")
 {
   // Reference hash values were computed using
   // https://github.com/aappleby/smhasher/blob/master/src/MurmurHash3.cpp

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@`
`18`	`18`
`19`	`19`	`#include <catch2/catch_test_macros.hpp>`
`20`	`20`
`21`		`-TEST_CASE("static_map capacity", "")`
	`21`	`+TEST_CASE("static_map capacity test", "")`
`22`	`22`	`{`
`23`	`23`	`using Key = int32_t;`
`24`	`24`	`using T = int32_t;`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ struct custom_key_equals {`
`98`	`98`	`}`
`99`	`99`	`};`
`100`	`100`
`101`		`-TEMPLATE_TEST_CASE_SIG("static_map custom key and value type",`
	`101`	`+TEMPLATE_TEST_CASE_SIG("static_map custom key and value type tests",`
`102`	`102`	`"",`
`103`	`103`	`((typename Key, typename Value), Key, Value),`
`104`	`104`	`#if defined(CUCO_HAS_INDEPENDENT_THREADS) // Key type larger than 8B only supported for sm_70 and`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ struct custom_key_equal {`
`82`	`82`	`}`
`83`	`83`	`};`
`84`	`84`
`85`		`-TEMPLATE_TEST_CASE_SIG("static_map heterogeneous lookup",`
	`85`	`+TEMPLATE_TEST_CASE_SIG("static_map heterogeneous lookup tests",`
`86`	`86`	`"",`
`87`	`87`	`((typename T, int CGSize), T, CGSize),`
`88`	`88`	`#if defined(CUCO_HAS_INDEPENDENT_THREADS) // Key type larger than 8B only supported for sm_70 and`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ void test_insert_or_assign(Map& map, size_type num_keys)`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`TEMPLATE_TEST_CASE_SIG(`
`74`		`- "static_map insert_or_assign",`
	`74`	`+ "static_map insert_or_assign tests",`
`75`	`75`	`"",`
`76`	`76`	`((typename Key, typename Value, cuco::test::probe_sequence Probe, int CGSize),`
`77`	`77`	`Key,`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@`
`22`	`22`
`23`	`23`	`#include <catch2/catch_test_macros.hpp>`
`24`	`24`
`25`		`-TEST_CASE("static_map rehash", "")`
	`25`	`+TEST_CASE("static_map rehash test", "")`
`26`	`26`	`{`
`27`	`27`	`using key_type = int;`
`28`	`28`	`using mapped_type = long;`
Original file line number	Diff line number	Diff line change
`@@ -188,7 +188,7 @@ void test_non_shmem_pair_retrieve(Map& map, std::size_t const num_pairs)`
`188`	`188`	`}`
`189`	`189`
`190`	`190`	`TEMPLATE_TEST_CASE_SIG(`
`191`		`- "static_multimap non-shared-memory pair_retrieve",`
	`191`	`+ "static_multimap non-shared-memory pair_retrieve tests",`
`192`	`192`	`"",`
`193`	`193`	`((typename Key, typename Value, cuco::test::probe_sequence Probe), Key, Value, Probe),`
`194`	`194`	`(int32_t, int32_t, cuco::test::probe_sequence::linear_probing),`
Original file line number	Diff line number	Diff line change
`@@ -208,7 +208,7 @@ void test_custom_key_value_type(Map& map, std::size_t num_pairs)`
`208`	`208`	`}`
`209`	`209`	`}`
`210`	`210`
`211`		`-TEMPLATE_TEST_CASE_SIG("static_multimap user defined key and value type",`
	`211`	`+TEMPLATE_TEST_CASE_SIG("static_multimap user defined key and value type tests",`
`212`	`212`	`"",`
`213`	`213`	`((cuco::test::probe_sequence Probe), Probe),`
`214`	`214`	`(cuco::test::probe_sequence::linear_probing),`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ struct custom_key_equal {`
`80`	`80`	`}`
`81`	`81`	`};`
`82`	`82`
`83`		`-TEMPLATE_TEST_CASE("static_multimap heterogeneous lookup",`
	`83`	`+TEMPLATE_TEST_CASE("static_multimap heterogeneous lookup tests",`
`84`	`84`	`"",`
`85`	`85`	`#if defined(CUCO_HAS_INDEPENDENT_THREADS) // Key type larger than 8B only supported for sm_70 and`
`86`	`86`	`// up`
Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ void test_pair_functions(Map& map, PairIt pair_begin, std::size_t num_pairs)`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`TEMPLATE_TEST_CASE_SIG(`
`111`		`- "static_multimap pair functions",`
	`111`	`+ "static_multimap pair functions tests",`
`112`	`112`	`"",`
`113`	`113`	`((typename Key, typename Value, cuco::test::probe_sequence Probe), Key, Value, Probe),`
`114`	`114`	`(int32_t, int32_t, cuco::test::probe_sequence::linear_probing),`