Use raw string literals for source definitions in cccl.c tests

Author: shwina

c/parallel/test/test_merge_sort.cpp

@@ -244,16 +244,15 @@ struct item_pair
 struct DeviceMergeSort_SortPairsCopy_CustomType_Fixture_Tag;
 C2H_TEST("DeviceMergeSort:SortPairsCopy works with custom types", "[merge_sort]")
 {
-  const size_t num_items = GENERATE_COPY(take(2, random(1, 100000)), values({5, 10000, 100000}));
-  operation_t op         = make_operation(
-    "op",
-    "struct key_pair { short a; size_t b; };\n"
-            "extern \"C\" __device__ void op(void* lhs_ptr, void* rhs_ptr, bool* out_ptr) {\n"
-            "  key_pair* lhs = static_cast<key_pair*>(lhs_ptr);\n"
-            "  key_pair* rhs = static_cast<key_pair*>(rhs_ptr);\n"
-            "  bool* out = static_cast<bool*>(out_ptr);\n"
-            "  *out = lhs->a == rhs->a ? lhs->b < rhs->b : lhs->a < rhs->a;\n"
-            "}");
+  const size_t num_items      = GENERATE_COPY(take(2, random(1, 100000)), values({5, 10000, 100000}));
+  operation_t op              = make_operation("op",
+                                  R"(struct key_pair { short a; size_t b; };
+extern "C" __device__ void op(void* lhs_ptr, void* rhs_ptr, bool* out_ptr) {
+  key_pair* lhs = static_cast<key_pair*>(lhs_ptr);
+  key_pair* rhs = static_cast<key_pair*>(rhs_ptr);
+  bool* out = static_cast<bool*>(out_ptr);
+  *out = lhs->a == rhs->a ? lhs->b < rhs->b : lhs->a < rhs->a;
+})");
   const std::vector<short> a  = generate<short>(num_items);
   const std::vector<size_t> b = generate<size_t>(num_items);
   std::vector<key_pair> input_keys(num_items);
@@ -301,16 +300,15 @@ C2H_TEST("DeviceMergeSort:SortPairsCopy works with custom types", "[merge_sort]"
 struct DeviceMergeSort_SortPairsCopy_CustomType_WellKnown_Fixture_Tag;
 C2H_TEST("DeviceMergeSort:SortPairsCopy works with custom types with well-known predicates", "[merge_sort][well_known]")
 {
-  const size_t num_items = GENERATE_COPY(take(2, random(1, 100000)), values({5, 10000, 100000}));
-  operation_t op_state   = make_operation(
-    "op",
-    "struct key_pair { short a; size_t b; };\n"
-      "extern \"C\" __device__ void op(void* lhs_ptr, void* rhs_ptr, bool* out_ptr) {\n"
-      "  key_pair* lhs = static_cast<key_pair*>(lhs_ptr);\n"
-      "  key_pair* rhs = static_cast<key_pair*>(rhs_ptr);\n"
-      "  bool* out = static_cast<bool*>(out_ptr);\n"
-      "  *out = lhs->a == rhs->a ? lhs->b < rhs->b : lhs->a < rhs->a;\n"
-      "}");
+  const size_t num_items      = GENERATE_COPY(take(2, random(1, 100000)), values({5, 10000, 100000}));
+  operation_t op_state        = make_operation("op",
+                                        R"(struct key_pair { short a; size_t b; };
+extern "C" __device__ void op(void* lhs_ptr, void* rhs_ptr, bool* out_ptr) {
+  key_pair* lhs = static_cast<key_pair*>(lhs_ptr);
+  key_pair* rhs = static_cast<key_pair*>(rhs_ptr);
+  bool* out = static_cast<bool*>(out_ptr);
+  *out = lhs->a == rhs->a ? lhs->b < rhs->b : lhs->a < rhs->a;
+})");
   cccl_op_t op                = op_state;
   op.type                     = cccl_op_kind_t::CCCL_LESS;
   const std::vector<short> a  = generate<short>(num_items);
@@ -432,17 +430,17 @@ C2H_TEST("DeviceMergeSort::SortKeys works with output iterators", "[merge_sort]"
     make_iterator<TestType, random_access_iterator_state_t>(
       {"random_access_iterator_state_t", "struct random_access_iterator_state_t { int* d_input; };\n"},
       {"advance",
-       "extern \"C\" __device__ void advance(void* state, const void* offset) {\n"
-       "  auto* typed_state = static_cast<random_access_iterator_state_t*>(state);\n"
-       "  auto offset_val = *static_cast<const unsigned long long*>(offset);\n"
-       "  typed_state->d_input += offset_val;\n"
-       "}"},
+       R"(extern "C" __device__ void advance(void* state, const void* offset) {
+  auto* typed_state = static_cast<random_access_iterator_state_t*>(state);
+  auto offset_val = *static_cast<const unsigned long long*>(offset);
+  typed_state->d_input += offset_val;
+})"},
       {"dereference",
-       "extern \"C\" __device__ void dereference(void* state, const void* x) {\n"
-       "  auto* typed_state = static_cast<random_access_iterator_state_t*>(state);\n"
-       "  auto x_val = *static_cast<const int*>(x);\n"
-       "  *typed_state->d_input = x_val;\n"
-       "}"});
+       R"(extern "C" __device__ void dereference(void* state, const void* x) {
+  auto* typed_state = static_cast<random_access_iterator_state_t*>(state);
+  auto x_val = *static_cast<const int*>(x);
+  *typed_state->d_input = x_val;
+})"});
   std::vector<TestType> input_keys    = make_shuffled_key_ranks_vector<TestType>(num_items);
   std::vector<TestType> expected_keys = input_keys;
 
@@ -475,17 +473,17 @@ C2H_TEST("DeviceMergeSort::SortPairs works with output iterators for items", "[m
     make_iterator<TestType, item_random_access_iterator_state_t>(
       "struct item_random_access_iterator_state_t { int* d_input; };\n",
       {"advance",
-       "extern \"C\" __device__ void advance(void* state, const void* offset) {\n"
-       "  auto* typed_state = static_cast<item_random_access_iterator_state_t*>(state);\n"
-       "  auto offset_val = *static_cast<const unsigned long long*>(offset);\n"
-       "  typed_state->d_input += offset_val;\n"
-       "}"},
+       R"(extern "C" __device__ void advance(void* state, const void* offset) {
+  auto* typed_state = static_cast<item_random_access_iterator_state_t*>(state);
+  auto offset_val = *static_cast<const unsigned long long*>(offset);
+  typed_state->d_input += offset_val;
+})"},
       {"dereference",
-       "extern \"C\" __device__ void dereference(void* state, const void* x) {\n"
-       "  auto* typed_state = static_cast<item_random_access_iterator_state_t*>(state);\n"
-       "  auto x_val = *static_cast<const int*>(x);\n"
-       "  *typed_state->d_input = x_val;\n"
-       "}"});
+       R"(extern "C" __device__ void dereference(void* state, const void* x) {
+  auto* typed_state = static_cast<item_random_access_iterator_state_t*>(state);
+  auto x_val = *static_cast<const int*>(x);
+  *typed_state->d_input = x_val;
+})"});
 
   pointer_t<TestType> input_keys_it(input_keys);
   pointer_t<item_t> input_items_it(input_items);
@@ -657,12 +655,12 @@ C2H_TEST("MergeSort works with C++ source operations using custom headers", "[me
 /* C2H_TEST("DeviceMergeSort:SortPairsCopy fails to build for large types due to no vsmem", "[merge_sort]")
 {
   const size_t num_items = 1;
-  operation_t op         = make_operation(
+  operation_t op = make_operation(
     "op",
-    "struct large_key_pair { int a; char c[100]; };\n"
-            "extern \"C\" __device__ bool op(large_key_pair lhs, large_key_pair rhs) {\n"
-            "  return lhs.a < rhs.a;\n"
-            "}");
+    R"(struct large_key_pair { int a; char c[100]; };
+extern "C" __device__ bool op(large_key_pair lhs, large_key_pair rhs) {
+  return lhs.a < rhs.a;
+})");
   const std::vector<int> a = generate<int>(num_items);
   std::vector<large_key_pair> input_keys(num_items);
   for (std::size_t i = 0; i < num_items; ++i)

c/parallel/test/test_reduce.cpp

@@ -180,15 +180,14 @@ C2H_TEST("Reduce works with custom types", "[reduce]")
 {
   const std::size_t num_items = GENERATE(0, 42, take(4, random(1 << 12, 1 << 24)));
 
-  operation_t op = make_operation(
-    "op",
-    "struct pair { short a; size_t b; };\n"
-    "extern \"C\" __device__ void op(void* lhs_ptr, void* rhs_ptr, void* out_ptr) {\n"
-    "  pair* lhs = static_cast<pair*>(lhs_ptr);\n"
-    "  pair* rhs = static_cast<pair*>(rhs_ptr);\n"
-    "  pair* out = static_cast<pair*>(out_ptr);\n"
-    "  *out = pair{ lhs->a + rhs->a, lhs->b + rhs->b };\n"
-    "}");
+  operation_t op              = make_operation("op",
+                                  R"(struct pair { short a; size_t b; };
+extern "C" __device__ void op(void* lhs_ptr, void* rhs_ptr, void* out_ptr) {
+  pair* lhs = static_cast<pair*>(lhs_ptr);
+  pair* rhs = static_cast<pair*>(rhs_ptr);
+  pair* out = static_cast<pair*>(out_ptr);
+  *out = pair{ lhs->a + rhs->a, lhs->b + rhs->b };
+})");
   const std::vector<short> a  = generate<short>(num_items);
   const std::vector<size_t> b = generate<size_t>(num_items);
   std::vector<pair> input(num_items);
@@ -218,15 +217,14 @@ C2H_TEST("Reduce works with custom types with well-known operations", "[reduce][
 {
   const std::size_t num_items = GENERATE(0, 42, take(4, random(1 << 12, 1 << 24)));
 
-  operation_t op_state = make_operation(
-    "op",
-    "struct pair { short a; size_t b; };\n"
-    "extern \"C\" __device__ void op(void* lhs_ptr, void* rhs_ptr, void* out_ptr) {\n"
-    "  pair* lhs = static_cast<pair*>(lhs_ptr);\n"
-    "  pair* rhs = static_cast<pair*>(rhs_ptr);\n"
-    "  pair* out = static_cast<pair*>(out_ptr);\n"
-    "  *out = pair{ lhs->a + rhs->a, lhs->b + rhs->b };\n"
-    "}");
+  operation_t op_state        = make_operation("op",
+                                        R"(struct pair { short a; size_t b; };
+extern "C" __device__ void op(void* lhs_ptr, void* rhs_ptr, void* out_ptr) {
+  pair* lhs = static_cast<pair*>(lhs_ptr);
+  pair* rhs = static_cast<pair*>(rhs_ptr);
+  pair* out = static_cast<pair*>(out_ptr);
+  *out = pair{ lhs->a + rhs->a, lhs->b + rhs->b };
+})");
   cccl_op_t op                = op_state;
   op.type                     = cccl_op_kind_t::CCCL_PLUS;
   const std::vector<short> a  = generate<short>(num_items);
@@ -371,14 +369,14 @@ C2H_TEST("Reduce works with stateful operators", "[reduce]")
   pointer_t<int> counter(1);
   stateful_operation_t<invocation_counter_state_t> op = make_operation(
     "op",
-    "struct invocation_counter_state_t { int* d_counter; };\n"
-    "extern \"C\" __device__ void op(void* state_ptr, void* a_ptr, void* b_ptr, void* out_ptr) {\n"
-    "  invocation_counter_state_t* state = static_cast<invocation_counter_state_t*>(state_ptr);\n"
-    "  atomicAdd(state->d_counter, 1);\n"
-    "  int a = *static_cast<int*>(a_ptr);\n"
-    "  int b = *static_cast<int*>(b_ptr);\n"
-    "  *static_cast<int*>(out_ptr) = a + b;\n"
-    "}",
+    R"(struct invocation_counter_state_t { int* d_counter; };
+extern "C" __device__ void op(void* state_ptr, void* a_ptr, void* b_ptr, void* out_ptr) {
+  invocation_counter_state_t* state = static_cast<invocation_counter_state_t*>(state_ptr);
+  atomicAdd(state->d_counter, 1);
+  int a = *static_cast<int*>(a_ptr);
+  int b = *static_cast<int*>(b_ptr);
+  *static_cast<int*>(out_ptr) = a + b;
+})",
     invocation_counter_state_t{counter.ptr});
 
   const std::vector<int> input = generate<int>(num_items);

c/parallel/test/test_scan.cpp

@@ -398,15 +398,14 @@ C2H_TEST("Scan works with custom types", "[scan]")
 {
   const std::size_t num_items = GENERATE(0, 42, take(4, random(1 << 12, 1 << 24)));
 
-  operation_t op = make_operation(
-    "op",
-    "struct pair { short a; size_t b; };\n"
-    "extern \"C\" __device__ void op(void* lhs_ptr, void* rhs_ptr, void* out_ptr) {\n"
-    "  pair* lhs = static_cast<pair*>(lhs_ptr);\n"
-    "  pair* rhs = static_cast<pair*>(rhs_ptr);\n"
-    "  pair* out = static_cast<pair*>(out_ptr);\n"
-    "  *out = pair{ lhs->a + rhs->a, lhs->b + rhs->b };\n"
-    "}");
+  operation_t op              = make_operation("op",
+                                  R"(struct pair { short a; size_t b; };
+extern "C" __device__ void op(void* lhs_ptr, void* rhs_ptr, void* out_ptr) {
+  pair* lhs = static_cast<pair*>(lhs_ptr);
+  pair* rhs = static_cast<pair*>(rhs_ptr);
+  pair* out = static_cast<pair*>(out_ptr);
+  *out = pair{ lhs->a + rhs->a, lhs->b + rhs->b };
+})");
   const std::vector<short> a  = generate<short>(num_items);
   const std::vector<size_t> b = generate<size_t>(num_items);
   std::vector<pair> input(num_items);
@@ -439,15 +438,14 @@ C2H_TEST("Scan works with custom types with well-known operations", "[scan][well
 {
   const std::size_t num_items = GENERATE(0, 42, take(4, random(1 << 12, 1 << 24)));
 
-  operation_t op_state = make_operation(
-    "op",
-    "struct pair { short a; size_t b; };\n"
-    "extern \"C\" __device__ void op(void* lhs_ptr, void* rhs_ptr, void* out_ptr) {\n"
-    "  pair* lhs = static_cast<pair*>(lhs_ptr);\n"
-    "  pair* rhs = static_cast<pair*>(rhs_ptr);\n"
-    "  pair* out = static_cast<pair*>(out_ptr);\n"
-    "  *out = pair{ lhs->a + rhs->a, lhs->b + rhs->b };\n"
-    "}");
+  operation_t op_state        = make_operation("op",
+                                        R"(struct pair { short a; size_t b; };
+extern "C" __device__ void op(void* lhs_ptr, void* rhs_ptr, void* out_ptr) {
+  pair* lhs = static_cast<pair*>(lhs_ptr);
+  pair* rhs = static_cast<pair*>(rhs_ptr);
+  pair* out = static_cast<pair*>(out_ptr);
+  *out = pair{ lhs->a + rhs->a, lhs->b + rhs->b };
+})");
   cccl_op_t op                = op_state;
   op.type                     = cccl_op_kind_t::CCCL_PLUS;
   const std::vector<short> a  = generate<short>(num_items);

c/parallel/test/test_three_way_partition.cpp

@@ -329,21 +329,21 @@ C2H_TEST("ThreeWayPartition works with stateful operations", "[three_way_partiti
   selector_state_t op_state                      = {21};
   stateful_operation_t<selector_state_t> less_op = make_operation(
     "less_op",
-    "struct selector_state_t { int comparison_value; };\n"
-    "extern \"C\" __device__ void less_op(void* state_ptr, void* x_ptr, void* out_ptr) {\n"
-    "  selector_state_t* state = static_cast<selector_state_t*>(state_ptr);\n"
-    "  *static_cast<int*>(x_ptr) < state->comparison_value;\n"
-    "  *static_cast<bool*>(out_ptr) = *static_cast<int*>(x_ptr) < state->comparison_value;\n"
-    "}",
+    R"(struct selector_state_t { int comparison_value; };
+extern "C" __device__ void less_op(void* state_ptr, void* x_ptr, void* out_ptr) {
+  selector_state_t* state = static_cast<selector_state_t*>(state_ptr);
+  *static_cast<int*>(x_ptr) < state->comparison_value;
+  *static_cast<bool*>(out_ptr) = *static_cast<int*>(x_ptr) < state->comparison_value;
+})",
     op_state);
   stateful_operation_t<selector_state_t> greater_or_equal_op = make_operation(
     "greater_or_equal_op",
-    "struct selector_state_t { int comparison_value; };\n"
-    "extern \"C\" __device__ void greater_or_equal_op(void* state_ptr, void* x_ptr, void* out_ptr) {\n"
-    "  selector_state_t* state = static_cast<selector_state_t*>(state_ptr);\n"
-    "  *static_cast<int*>(x_ptr) >= state->comparison_value;\n"
-    "  *static_cast<bool*>(out_ptr) = *static_cast<int*>(x_ptr) >= state->comparison_value;\n"
-    "}",
+    R"(struct selector_state_t { int comparison_value; };
+extern "C" __device__ void greater_or_equal_op(void* state_ptr, void* x_ptr, void* out_ptr) {
+  selector_state_t* state = static_cast<selector_state_t*>(state_ptr);
+  *static_cast<int*>(x_ptr) >= state->comparison_value;
+  *static_cast<bool*>(out_ptr) = *static_cast<int*>(x_ptr) >= state->comparison_value;
+})",
     op_state);
 
   const std::size_t num_items      = GENERATE(0, 42, take(4, random(1 << 12, 1 << 20)));
@@ -409,21 +409,21 @@ C2H_TEST("ThreeWayPartition works with custom types", "[three_way_partition]")
 
   operation_t less_op = make_operation(
     "less_op",
-    std::format("struct pair_type {{ int a; size_t b; }};"
-                "extern \"C\" __device__ void less_op(void* x_ptr, void* out_ptr) {{ "
-                "  pair_type* x = static_cast<pair_type*>(x_ptr); "
-                "  bool* out = static_cast<bool*>(out_ptr); "
-                "  *out = x->a < {0}; "
-                "}}",
+    std::format(R"(struct pair_type {{ int a; size_t b; }};
+extern "C" __device__ void less_op(void* x_ptr, void* out_ptr) {{
+  pair_type* x = static_cast<pair_type*>(x_ptr);
+  bool* out = static_cast<bool*>(out_ptr);
+  *out = x->a < {0};
+}})",
                 comparison_value));
   operation_t greater_or_equal_op = make_operation(
     "greater_or_equal_op",
-    std::format("struct pair_type {{ int a; size_t b; }};"
-                "extern \"C\" __device__ void greater_or_equal_op(void* x_ptr, void* out_ptr) {{ "
-                "  pair_type* x = static_cast<pair_type*>(x_ptr); "
-                "  bool* out = static_cast<bool*>(out_ptr); "
-                "  *out = x->a >= {0}; "
-                "}}",
+    std::format(R"(struct pair_type {{ int a; size_t b; }};
+extern "C" __device__ void greater_or_equal_op(void* x_ptr, void* out_ptr) {{
+  pair_type* x = static_cast<pair_type*>(x_ptr);
+  bool* out = static_cast<bool*>(out_ptr);
+  *out = x->a >= {0};
+}})",
                 comparison_value));
 
   const std::size_t num_items      = GENERATE(0, 42, take(4, random(1 << 12, 1 << 20)));