diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index 8aed7089dc5..ed600000135 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -576,7 +576,7 @@ add_library(cudftestutil STATIC
             tests/utilities/column_utilities.cu
             tests/utilities/table_utilities.cu
             tests/io/metadata_utilities.cpp
-            tests/strings/utilities.cu)
+            tests/strings/utilities.cpp)
 
 set_target_properties(cudftestutil
     PROPERTIES BUILD_RPATH                         "\$ORIGIN"
diff --git a/cpp/src/hash/md5_hash.cu b/cpp/src/hash/md5_hash.cu
index d0e47d93bc6..b9915da90b9 100644
--- a/cpp/src/hash/md5_hash.cu
+++ b/cpp/src/hash/md5_hash.cu
@@ -238,6 +238,7 @@ struct HasherDispatcher {
                   std::is_same_v<Element, string_view>) {
       hasher->process(input_col.element<Element>(row_index));
     } else {
+      (void)row_index;
       cudf_assert(false && "Unsupported type for hash function.");
     }
   }
@@ -263,6 +264,8 @@ struct ListHasherDispatcher {
         if (input_col.is_valid(i)) { hasher->process(input_col.element<Element>(i)); }
       }
     } else {
+      (void)offset_begin;
+      (void)offset_end;
       cudf_assert(false && "Unsupported type for hash function.");
     }
   }
diff --git a/cpp/tests/strings/chars_types_tests.cpp b/cpp/tests/strings/chars_types_tests.cpp
index 17e08bd21c5..ff9f79ea87f 100644
--- a/cpp/tests/strings/chars_types_tests.cpp
+++ b/cpp/tests/strings/chars_types_tests.cpp
@@ -28,12 +28,11 @@
 struct StringsCharsTest : public cudf::test::BaseFixture {
 };
 
-class StringsCharsTestTypes
-  : public StringsCharsTest,
-    public testing::WithParamInterface<cudf::strings::string_character_types> {
+class CharsTypes : public StringsCharsTest,
+                   public testing::WithParamInterface<cudf::strings::string_character_types> {
 };
 
-TEST_P(StringsCharsTestTypes, AllTypes)
+TEST_P(CharsTypes, AllTypes)
 {
   std::vector<const char*> h_strings{"Héllo",
                                      "thesé",
@@ -84,8 +83,8 @@ TEST_P(StringsCharsTestTypes, AllTypes)
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, expected);
 }
 
-INSTANTIATE_TEST_CASE_P(StringsCharsTestAllTypes,
-                        StringsCharsTestTypes,
+INSTANTIATE_TEST_CASE_P(StringsCharsTest,
+                        CharsTypes,
                         testing::ValuesIn(std::array<cudf::strings::string_character_types, 7>{
                           cudf::strings::string_character_types::DECIMAL,
                           cudf::strings::string_character_types::NUMERIC,
diff --git a/cpp/tests/strings/pad_tests.cpp b/cpp/tests/strings/pad_tests.cpp
index a64304d1027..f344b5432a2 100644
--- a/cpp/tests/strings/pad_tests.cpp
+++ b/cpp/tests/strings/pad_tests.cpp
@@ -104,11 +104,10 @@ TEST_F(StringsPadTest, ZeroSizeStringsColumn)
   cudf::test::expect_strings_empty(results->view());
 }
 
-class StringsPadParmsTest : public StringsPadTest,
-                            public testing::WithParamInterface<cudf::size_type> {
+class PadParameters : public StringsPadTest, public testing::WithParamInterface<cudf::size_type> {
 };
 
-TEST_P(StringsPadParmsTest, Padding)
+TEST_P(PadParameters, Padding)
 {
   std::vector<std::string> h_strings{"eee ddd", "bb cc", "aa", "bbb", "fff", "", "o"};
   cudf::test::strings_column_wrapper strings(h_strings.begin(), h_strings.end());
@@ -128,8 +127,8 @@ TEST_P(StringsPadParmsTest, Padding)
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, expected);
 }
 
-INSTANTIATE_TEST_CASE_P(StringsPadParmWidthTest,
-                        StringsPadParmsTest,
+INSTANTIATE_TEST_CASE_P(StringsPadTest,
+                        PadParameters,
                         testing::ValuesIn(std::array<cudf::size_type, 3>{5, 6, 7}));
 
 TEST_F(StringsPadTest, ZFill)
diff --git a/cpp/tests/strings/replace_regex_tests.cpp b/cpp/tests/strings/replace_regex_tests.cpp
index 1f01f0f1429..fc1c20d8719 100644
--- a/cpp/tests/strings/replace_regex_tests.cpp
+++ b/cpp/tests/strings/replace_regex_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019-2020, NVIDIA CORPORATION.
+ * Copyright (c) 2019-2021, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,10 +23,10 @@
 
 #include <vector>
 
-struct StringsReplaceTests : public cudf::test::BaseFixture {
+struct StringsReplaceRegexTest : public cudf::test::BaseFixture {
 };
 
-TEST_F(StringsReplaceTests, ReplaceRegexTest)
+TEST_F(StringsReplaceRegexTest, ReplaceRegexTest)
 {
   std::vector<const char*> h_strings{"the quick brown fox jumps over the lazy dog",
                                      "the fat cat lays next to the other accénted cat",
@@ -59,7 +59,7 @@ TEST_F(StringsReplaceTests, ReplaceRegexTest)
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, expected);
 }
 
-TEST_F(StringsReplaceTests, ReplaceMultiRegexTest)
+TEST_F(StringsReplaceRegexTest, ReplaceMultiRegexTest)
 {
   std::vector<const char*> h_strings{"the quick brown fox jumps over the lazy dog",
                                      "the fat cat lays next to the other accénted cat",
@@ -95,7 +95,7 @@ TEST_F(StringsReplaceTests, ReplaceMultiRegexTest)
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, expected);
 }
 
-TEST_F(StringsReplaceTests, InvalidRegex)
+TEST_F(StringsReplaceRegexTest, InvalidRegex)
 {
   cudf::test::strings_column_wrapper strings(
     {"abc*def|ghi+jkl", ""});  // these do not really matter
@@ -116,7 +116,7 @@ TEST_F(StringsReplaceTests, InvalidRegex)
                cudf::logic_error);
 }
 
-TEST_F(StringsReplaceTests, WithEmptyPattern)
+TEST_F(StringsReplaceRegexTest, WithEmptyPattern)
 {
   std::vector<const char*> h_strings{"asd", "xcv"};
   cudf::test::strings_column_wrapper strings(
@@ -133,7 +133,7 @@ TEST_F(StringsReplaceTests, WithEmptyPattern)
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, strings);
 }
 
-TEST_F(StringsReplaceTests, ReplaceBackrefsRegexTest)
+TEST_F(StringsReplaceRegexTest, ReplaceBackrefsRegexTest)
 {
   std::vector<const char*> h_strings{"the quick brown fox jumps over the lazy dog",
                                      "the fat cat lays next to the other accénted cat",
@@ -167,7 +167,7 @@ TEST_F(StringsReplaceTests, ReplaceBackrefsRegexTest)
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, expected);
 }
 
-TEST_F(StringsReplaceTests, ReplaceBackrefsRegexAltIndexPatternTest)
+TEST_F(StringsReplaceRegexTest, ReplaceBackrefsRegexAltIndexPatternTest)
 {
   cudf::test::strings_column_wrapper strings({"12-3 34-5 67-89", "0-99: 777-888:: 5673-0"});
   auto strings_view = cudf::strings_column_view(strings);
@@ -181,7 +181,7 @@ TEST_F(StringsReplaceTests, ReplaceBackrefsRegexAltIndexPatternTest)
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, expected);
 }
 
-TEST_F(StringsReplaceTests, ReplaceBackrefsRegexReversedTest)
+TEST_F(StringsReplaceRegexTest, ReplaceBackrefsRegexReversedTest)
 {
   cudf::test::strings_column_wrapper strings(
     {"A543", "Z756", "", "tést-string", "two-thréé four-fivé", "abcd-éfgh", "tést-string-again"});
@@ -200,7 +200,7 @@ TEST_F(StringsReplaceTests, ReplaceBackrefsRegexReversedTest)
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, expected);
 }
 
-TEST_F(StringsReplaceTests, BackrefWithGreedyQuantifier)
+TEST_F(StringsReplaceRegexTest, BackrefWithGreedyQuantifier)
 {
   cudf::test::strings_column_wrapper input(
     {"<h1>title</h1><h2>ABC</h2>", "<h1>1234567</h1><h2>XYZ</h2>"});
@@ -217,7 +217,7 @@ TEST_F(StringsReplaceTests, BackrefWithGreedyQuantifier)
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, expected);
 }
 
-TEST_F(StringsReplaceTests, ReplaceBackrefsRegexErrorTest)
+TEST_F(StringsReplaceRegexTest, ReplaceBackrefsRegexErrorTest)
 {
   cudf::test::strings_column_wrapper strings({"this string left intentionally blank"});
   auto view = cudf::strings_column_view(strings);
@@ -228,7 +228,7 @@ TEST_F(StringsReplaceTests, ReplaceBackrefsRegexErrorTest)
   EXPECT_THROW(cudf::strings::replace_with_backrefs(view, "(\\w)", ""), cudf::logic_error);
 }
 
-TEST_F(StringsReplaceTests, MediumReplaceRegex)
+TEST_F(StringsReplaceRegexTest, MediumReplaceRegex)
 {
   // This results in 95 regex instructions and falls in the 'medium' range.
   std::string medium_regex =
@@ -256,7 +256,7 @@ TEST_F(StringsReplaceTests, MediumReplaceRegex)
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, expected);
 }
 
-TEST_F(StringsReplaceTests, LargeReplaceRegex)
+TEST_F(StringsReplaceRegexTest, LargeReplaceRegex)
 {
   // This results in 117 regex instructions and falls in the 'large' range.
   std::string large_regex =
diff --git a/cpp/tests/strings/substring_tests.cpp b/cpp/tests/strings/substring_tests.cpp
index f9a71407a0d..448b61300fd 100644
--- a/cpp/tests/strings/substring_tests.cpp
+++ b/cpp/tests/strings/substring_tests.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include <cudf/column/column.hpp>
+#include <cudf/column/column_view.hpp>
 #include <cudf/scalar/scalar.hpp>
 #include <cudf/strings/strings_column_view.hpp>
 #include <cudf/strings/substring.hpp>
@@ -28,8 +28,6 @@
 #include <string>
 #include <vector>
 
-constexpr cudf::test::debug_output_level verbosity{cudf::test::debug_output_level::ALL_ERRORS};
-
 struct StringsSubstringsTest : public cudf::test::BaseFixture {
 };
 
@@ -51,11 +49,11 @@ TEST_F(StringsSubstringsTest, Substring)
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, expected);
 }
 
-class SubstringParmsTest : public StringsSubstringsTest,
-                           public testing::WithParamInterface<cudf::size_type> {
+class Parameters : public StringsSubstringsTest,
+                   public testing::WithParamInterface<cudf::size_type> {
 };
 
-TEST_P(SubstringParmsTest, Substring)
+TEST_P(Parameters, Substring)
 {
   std::vector<std::string> h_strings{"basic strings", "that can", "be used", "with STL"};
   cudf::size_type start = GetParam();
@@ -72,7 +70,7 @@ TEST_P(SubstringParmsTest, Substring)
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, expected);
 }
 
-TEST_P(SubstringParmsTest, Substring_From)
+TEST_P(Parameters, Substring_From)
 {
   std::vector<std::string> h_strings{"basic strings", "that can", "be used", "with STL"};
   cudf::test::strings_column_wrapper strings(h_strings.begin(), h_strings.end());
@@ -96,7 +94,7 @@ TEST_P(SubstringParmsTest, Substring_From)
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, expected);
 }
 
-TEST_P(SubstringParmsTest, AllEmpty)
+TEST_P(Parameters, AllEmpty)
 {
   std::vector<std::string> h_strings{"", "", "", ""};
   cudf::size_type start = GetParam();
@@ -118,7 +116,7 @@ TEST_P(SubstringParmsTest, AllEmpty)
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, expected);
 }
 
-TEST_P(SubstringParmsTest, AllNulls)
+TEST_P(Parameters, AllNulls)
 {
   std::vector<const char*> h_strings{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
   cudf::test::strings_column_wrapper strings(
@@ -147,23 +145,9 @@ TEST_P(SubstringParmsTest, AllNulls)
 }
 
 INSTANTIATE_TEST_CASE_P(StringsSubstringsTest,
-                        SubstringParmsTest,
+                        Parameters,
                         testing::ValuesIn(std::array<cudf::size_type, 3>{1, 2, 3}));
 
-TEST_F(StringsSubstringsTest, ZeroSizeStringsColumn)
-{
-  cudf::column_view zero_size_strings_column(
-    cudf::data_type{cudf::type_id::STRING}, 0, nullptr, nullptr, 0);
-  auto strings_column = cudf::strings_column_view(zero_size_strings_column);
-  auto results        = cudf::strings::slice_strings(strings_column, 1, 2);
-  cudf::test::expect_strings_empty(results->view());
-
-  cudf::column_view starts_column(cudf::data_type{cudf::type_id::INT32}, 0, nullptr, nullptr, 0);
-  cudf::column_view stops_column(cudf::data_type{cudf::type_id::INT32}, 0, nullptr, nullptr, 0);
-  results = cudf::strings::slice_strings(strings_column, starts_column, stops_column);
-  cudf::test::expect_strings_empty(results->view());
-}
-
 TEST_F(StringsSubstringsTest, NegativePositions)
 {
   cudf::test::strings_column_wrapper strings{
@@ -270,34 +254,59 @@ TEST_F(StringsSubstringsTest, MaxPositions)
 TEST_F(StringsSubstringsTest, Error)
 {
   cudf::test::strings_column_wrapper strings{"this string intentionally left blank"};
-  auto strings_column = cudf::strings_column_view(strings);
-  EXPECT_THROW(cudf::strings::slice_strings(strings_column, 0, 0, 0), cudf::logic_error);
-}
+  auto strings_view = cudf::strings_column_view(strings);
+  EXPECT_THROW(cudf::strings::slice_strings(strings_view, 0, 0, 0), cudf::logic_error);
 
-struct StringsSubstringsScalarDelimiterTest : public cudf::test::BaseFixture {
-};
+  auto delim_col = cudf::test::strings_column_wrapper({"", ""});
+  EXPECT_THROW(cudf::strings::slice_strings(strings_view, cudf::strings_column_view{delim_col}, -1),
+               cudf::logic_error);
+
+  auto indexes = cudf::test::fixed_width_column_wrapper<int32_t>({1, 2});
+  EXPECT_THROW(cudf::strings::slice_strings(strings_view, indexes, indexes), cudf::logic_error);
 
-TEST_F(StringsSubstringsScalarDelimiterTest, ZeroSizeStringsColumn)
+  auto indexes_null = cudf::test::fixed_width_column_wrapper<int32_t>({1}, {0});
+  EXPECT_THROW(cudf::strings::slice_strings(strings_view, indexes_null, indexes_null),
+               cudf::logic_error);
+
+  auto indexes_bad = cudf::test::fixed_width_column_wrapper<float>({1});
+  EXPECT_THROW(cudf::strings::slice_strings(strings_view, indexes_bad, indexes_bad),
+               cudf::logic_error);
+}
+
+TEST_F(StringsSubstringsTest, ZeroSizeStringsColumn)
 {
-  cudf::column_view col0(cudf::data_type{cudf::type_id::STRING}, 0, nullptr, nullptr, 0);
-  auto strings_view = cudf::strings_column_view(col0);
+  cudf::column_view zero_size_strings_column(
+    cudf::data_type{cudf::type_id::STRING}, 0, nullptr, nullptr, 0);
+  auto strings_view = cudf::strings_column_view(zero_size_strings_column);
+
+  auto results = cudf::strings::slice_strings(strings_view, 1, 2);
+  cudf::test::expect_strings_empty(results->view());
+
+  results = cudf::strings::slice_strings(strings_view, cudf::string_scalar("foo"), 1);
+  cudf::test::expect_strings_empty(results->view());
+
+  cudf::column_view starts_column(cudf::data_type{cudf::type_id::INT32}, 0, nullptr, nullptr, 0);
+  cudf::column_view stops_column(cudf::data_type{cudf::type_id::INT32}, 0, nullptr, nullptr, 0);
+  results = cudf::strings::slice_strings(strings_view, starts_column, stops_column);
+  cudf::test::expect_strings_empty(results->view());
 
-  auto results = cudf::strings::slice_strings(strings_view, cudf::string_scalar("foo"), 1);
+  results = cudf::strings::slice_strings(strings_view, strings_view, 1);
   cudf::test::expect_strings_empty(results->view());
 }
 
-TEST_F(StringsSubstringsScalarDelimiterTest, AllEmpty)
+TEST_F(StringsSubstringsTest, AllEmpty)
 {
   auto strings_col  = cudf::test::strings_column_wrapper({"", "", "", "", ""});
   auto strings_view = cudf::strings_column_view(strings_col);
-
-  auto exp_results = cudf::test::strings_column_wrapper({"", "", "", "", ""});
+  auto exp_results  = cudf::column_view(strings_col);
 
   auto results = cudf::strings::slice_strings(strings_view, cudf::string_scalar("e"), -1);
-  CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results, verbosity);
+  CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results);
+  results = cudf::strings::slice_strings(strings_view, strings_view, -1);
+  CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results);
 }
 
-TEST_F(StringsSubstringsScalarDelimiterTest, EmptyDelimiter)
+TEST_F(StringsSubstringsTest, EmptyDelimiter)
 {
   auto strings_col = cudf::test::strings_column_wrapper(
     {"Héllo", "thesé", "", "lease", "tést strings", ""}, {true, true, false, true, true, true});
@@ -306,11 +315,18 @@ TEST_F(StringsSubstringsScalarDelimiterTest, EmptyDelimiter)
 
   auto exp_results = cudf::test::strings_column_wrapper({"", "", "", "", "", ""},
                                                         {true, true, false, true, true, true});
-  auto results     = cudf::strings::slice_strings(strings_view, cudf::string_scalar(""), 1);
-  CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results, verbosity);
+
+  auto results = cudf::strings::slice_strings(strings_view, cudf::string_scalar(""), 1);
+  CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results);
+
+  auto delim_col = cudf::test::strings_column_wrapper({"", "", "", "", "", ""},
+                                                      {true, false, true, false, true, false});
+
+  results = cudf::strings::slice_strings(strings_view, cudf::strings_column_view{delim_col}, 1);
+  CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results);
 }
 
-TEST_F(StringsSubstringsScalarDelimiterTest, ZeroCount)
+TEST_F(StringsSubstringsTest, ZeroCount)
 {
   auto strings_col = cudf::test::strings_column_wrapper(
     {"Héllo", "thesé", "", "lease", "tést strings", ""}, {true, true, false, true, true, true});
@@ -321,10 +337,16 @@ TEST_F(StringsSubstringsScalarDelimiterTest, ZeroCount)
                                                         {true, true, false, true, true, true});
 
   auto results = cudf::strings::slice_strings(strings_view, cudf::string_scalar("é"), 0);
-  CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results, verbosity);
+  CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results);
+
+  auto delim_col = cudf::test::strings_column_wrapper({"", "", "", "", "", ""},
+                                                      {true, false, true, false, true, false});
+
+  results = cudf::strings::slice_strings(strings_view, cudf::strings_column_view{delim_col}, 0);
+  CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results);
 }
 
-TEST_F(StringsSubstringsScalarDelimiterTest, SearchDelimiter)
+TEST_F(StringsSubstringsTest, SearchScalarDelimiter)
 {
   auto strings_col = cudf::test::strings_column_wrapper(
     {"Héllo", "thesé", "", "lease", "tést strings", ""}, {true, true, false, true, true, true});
@@ -336,7 +358,7 @@ TEST_F(StringsSubstringsScalarDelimiterTest, SearchDelimiter)
                                                           {true, true, false, true, true, true});
 
     auto results = cudf::strings::slice_strings(strings_view, cudf::string_scalar("é"), 1);
-    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results, verbosity);
+    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results);
   }
 
   {
@@ -344,17 +366,17 @@ TEST_F(StringsSubstringsScalarDelimiterTest, SearchDelimiter)
       {"llo", "", "", "lease", "st strings", ""}, {true, true, false, true, true, true});
 
     auto results = cudf::strings::slice_strings(strings_view, cudf::string_scalar("é"), -1);
-    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results, verbosity);
+    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results);
   }
 
   {
     auto results = cudf::strings::slice_strings(strings_view, cudf::string_scalar("é"), 2);
-    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, strings_view.parent(), verbosity);
+    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, strings_col);
   }
 
   {
     auto results = cudf::strings::slice_strings(strings_view, cudf::string_scalar("é"), -2);
-    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, strings_view.parent(), verbosity);
+    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, strings_col);
   }
 
   {
@@ -367,7 +389,7 @@ TEST_F(StringsSubstringsScalarDelimiterTest, SearchDelimiter)
 
     auto results =
       cudf::strings::slice_strings(cudf::strings_column_view{col0}, cudf::string_scalar("o"), 2);
-    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results, verbosity);
+    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results);
   }
 
   {
@@ -380,7 +402,7 @@ TEST_F(StringsSubstringsScalarDelimiterTest, SearchDelimiter)
 
     auto results =
       cudf::strings::slice_strings(cudf::strings_column_view{col0}, cudf::string_scalar("o"), -2);
-    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results, verbosity);
+    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results);
   }
 
   {
@@ -394,7 +416,7 @@ TEST_F(StringsSubstringsScalarDelimiterTest, SearchDelimiter)
 
     auto results =
       cudf::strings::slice_strings(cudf::strings_column_view{col0}, cudf::string_scalar("éé"), 3);
-    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results, verbosity);
+    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results);
   }
 
   {
@@ -408,7 +430,7 @@ TEST_F(StringsSubstringsScalarDelimiterTest, SearchDelimiter)
 
     auto results =
       cudf::strings::slice_strings(cudf::strings_column_view{col0}, cudf::string_scalar("éé"), -3);
-    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results, verbosity);
+    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results);
   }
 
   {
@@ -424,7 +446,7 @@ TEST_F(StringsSubstringsScalarDelimiterTest, SearchDelimiter)
 
     auto results =
       cudf::strings::slice_strings(cudf::strings_column_view{col0}, cudf::string_scalar("."), 3);
-    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results, verbosity);
+    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results);
   }
 
   {
@@ -441,76 +463,11 @@ TEST_F(StringsSubstringsScalarDelimiterTest, SearchDelimiter)
 
     auto results =
       cudf::strings::slice_strings(cudf::strings_column_view{col0}, cudf::string_scalar(".."), -2);
-    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results, verbosity);
+    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results);
   }
 }
 
-struct StringsSubstringsColumnDelimiterTest : public cudf::test::BaseFixture {
-};
-
-TEST_F(StringsSubstringsColumnDelimiterTest, ZeroSizeStringsColumn)
-{
-  cudf::column_view col0(cudf::data_type{cudf::type_id::STRING}, 0, nullptr, nullptr, 0);
-  auto strings_view = cudf::strings_column_view(col0);
-
-  auto results = cudf::strings::slice_strings(strings_view, strings_view, 1);
-  // Check empty column
-  cudf::test::expect_strings_empty(results->view());
-}
-
-TEST_F(StringsSubstringsColumnDelimiterTest, GenerateExceptions)
-{
-  auto col0      = cudf::test::strings_column_wrapper({"", "", "", "", ""});
-  auto delim_col = cudf::test::strings_column_wrapper({"", "foo", "bar", "."});
-
-  EXPECT_THROW(cudf::strings::slice_strings(
-                 cudf::strings_column_view{col0}, cudf::strings_column_view{delim_col}, -1),
-               cudf::logic_error);
-}
-
-TEST_F(StringsSubstringsColumnDelimiterTest, ColumnAllEmpty)
-{
-  auto col0      = cudf::test::strings_column_wrapper({"", "", "", "", ""});
-  auto delim_col = cudf::test::strings_column_wrapper({"", "foo", "bar", ".", "/"});
-
-  auto exp_results = cudf::test::strings_column_wrapper({"", "", "", "", ""});
-
-  auto results = cudf::strings::slice_strings(
-    cudf::strings_column_view{col0}, cudf::strings_column_view{delim_col}, -1);
-  CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results, verbosity);
-}
-
-TEST_F(StringsSubstringsColumnDelimiterTest, DelimiterAllEmptyAndInvalid)
-{
-  auto col0 = cudf::test::strings_column_wrapper(
-    {"Héllo", "thesé", "", "lease", "tést strings", ""}, {true, true, false, true, true, true});
-  auto delim_col = cudf::test::strings_column_wrapper({"", "", "", "", "", ""},
-                                                      {true, false, true, false, true, false});
-
-  auto exp_results = cudf::test::strings_column_wrapper({"", "", "", "", "", ""},
-                                                        {true, true, false, true, true, true});
-
-  auto results = cudf::strings::slice_strings(
-    cudf::strings_column_view{col0}, cudf::strings_column_view{delim_col}, 1);
-  CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results, verbosity);
-}
-
-TEST_F(StringsSubstringsColumnDelimiterTest, ZeroDelimiterCount)
-{
-  auto col0 = cudf::test::strings_column_wrapper(
-    {"Héllo", "thesé", "", "lease", "tést strings", ""}, {true, true, false, true, true, true});
-  auto delim_col = cudf::test::strings_column_wrapper({"", "", "", "", "", ""},
-                                                      {true, false, true, false, true, false});
-
-  auto exp_results = cudf::test::strings_column_wrapper({"", "", "", "", "", ""},
-                                                        {true, true, false, true, true, true});
-
-  auto results = cudf::strings::slice_strings(
-    cudf::strings_column_view{col0}, cudf::strings_column_view{delim_col}, 0);
-  CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results, verbosity);
-}
-
-TEST_F(StringsSubstringsColumnDelimiterTest, SearchDelimiter)
+TEST_F(StringsSubstringsTest, SearchColumnDelimiter)
 {
   {
     auto col0 = cudf::test::strings_column_wrapper(
@@ -523,7 +480,7 @@ TEST_F(StringsSubstringsColumnDelimiterTest, SearchDelimiter)
 
     auto results = cudf::strings::slice_strings(
       cudf::strings_column_view{col0}, cudf::strings_column_view{delim_col}, 1);
-    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results, verbosity);
+    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results);
   }
 
   {
@@ -541,7 +498,7 @@ TEST_F(StringsSubstringsColumnDelimiterTest, SearchDelimiter)
 
     auto results = cudf::strings::slice_strings(
       cudf::strings_column_view{col0}, cudf::strings_column_view{delim_col}, -1);
-    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results, verbosity);
+    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results);
   }
 
   {
@@ -565,7 +522,7 @@ TEST_F(StringsSubstringsColumnDelimiterTest, SearchDelimiter)
 
     auto results = cudf::strings::slice_strings(
       cudf::strings_column_view{col0}, cudf::strings_column_view{delim_col}, 3);
-    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results, verbosity);
+    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results);
   }
 
   {
@@ -587,6 +544,6 @@ TEST_F(StringsSubstringsColumnDelimiterTest, SearchDelimiter)
 
     auto results = cudf::strings::slice_strings(
       cudf::strings_column_view{col0}, cudf::strings_column_view{delim_col}, -3);
-    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results, verbosity);
+    CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, exp_results);
   }
 }
diff --git a/cpp/tests/strings/utilities.cu b/cpp/tests/strings/utilities.cpp
similarity index 100%
rename from cpp/tests/strings/utilities.cu
rename to cpp/tests/strings/utilities.cpp