Adds the WhenSerialized matcher which replaces SerializesTo and accepts matchers such as Eq and StrContains.

Also added EqSuashingWhitespace to compare strings ignoring differences in whitespace.

Author: EpsilonPrime

src/substrait/textplan/converter/tests/BinaryToTextPlanConversionTest.cpp

@@ -8,6 +8,9 @@
 #include "substrait/textplan/tests/ParseResultMatchers.h"
 
 namespace io::substrait::textplan {
+
+using ::testing::Eq;
+
 namespace {
 
 class TestCase {
@@ -31,15 +34,15 @@ std::vector<TestCase> GetTestCases() {
       {
           "empty plan",
           "",
-          SerializesTo(""),
+          WhenSerialized(Eq("")),
       },
       {
           "empty extension space",
           R"(extension_uris: {
             extension_uri_anchor: 42;
             uri: "http://life@everything",
           })",
-          SerializesTo(""),
+          WhenSerialized(Eq("")),
       },
       {
           "used extension space",
@@ -54,9 +57,10 @@ std::vector<TestCase> GetTestCases() {
               name: "sum:fp64_fp64"
             }
           })",
-          SerializesTo("extension_space http://life@everything {\n"
-                       "  function sum:fp64_fp64 as sum;\n"
-                       "}\n"),
+          WhenSerialized(EqSquashingWhitespace(
+              R"(extension_space http://life@everything {
+                   function sum:fp64_fp64 as sum;
+                 })")),
       },
       {
           "seven extensions, no uris",
@@ -109,15 +113,16 @@ std::vector<TestCase> GetTestCases() {
               name: "multiply:opt_fp64_fp64"
             }
           })",
-          SerializesTo("extension_space {\n"
-                       "  function lte:fp64_fp64 as lte;\n"
-                       "  function sum:fp64_fp64 as sum;\n"
-                       "  function lt:fp64_fp64 as lt;\n"
-                       "  function is_not_null:fp64 as is_not_null;\n"
-                       "  function and:bool_bool as and;\n"
-                       "  function gte:fp64_fp64 as gte;\n"
-                       "  function multiply:opt_fp64_fp64 as multiply;\n"
-                       "}\n"),
+          WhenSerialized(EqSquashingWhitespace(
+              R"(extension_space {
+                   function lte:fp64_fp64 as lte;
+                   function sum:fp64_fp64 as sum;
+                   function lt:fp64_fp64 as lt;
+                   function is_not_null:fp64 as is_not_null;
+                   function and:bool_bool as and;
+                   function gte:fp64_fp64 as gte;
+                   function multiply:opt_fp64_fp64 as multiply;
+                 })")),
       },
       {
           "read local files",
@@ -140,32 +145,33 @@ std::vector<TestCase> GetTestCases() {
           })",
           AllOf(
               HasSymbols({"local", "read", "root"}),
-              SerializesTo(
-                  "read relation read {\n"
-                  "}\n"
-                  "\n"
-                  "source local_files local {\n"
-                  "  items = [\n"
-                  "    {uri_file: \"/mock_lineitem.orc\" start: 0 length: 3719 orc: {}}\n"
-                  "  ]\n"
-                  "}\n")),
+              WhenSerialized(EqSquashingWhitespace(
+                  R"(read relation read {
+                  }
+
+                  source local_files local {
+                    items = [
+                      {uri_file: "/mock_lineitem.orc" start: 0 length: 3719 orc: {}}
+                    ]
+                  })"))),
       },
       {
           "read named table",
           "relations: { root: { input: { read: { base_schema {} named_table { names: \"#2\" } } } } }",
           AllOf(
               HasSymbols({"schema", "named", "read", "root"}),
-              SerializesTo("read relation read {\n"
-                           "}\n"
-                           "\n"
-                           "schema schema {\n"
-                           "}\n"
-                           "\n"
-                           "source named_table named {\n"
-                           "  names = [\n"
-                           "    \"#2\",\n"
-                           "  ]\n"
-                           "}\n")),
+              WhenSerialized(EqSquashingWhitespace(
+                  R"(read relation read {
+                     }
+
+                     schema schema {
+                     }
+
+                     source named_table named {
+                       names = [
+                         "#2",
+                       ]
+                     })"))),
       },
       {
           "single three node pipeline",

src/substrait/textplan/tests/ParseResultMatchers.cpp

@@ -25,6 +25,45 @@ std::vector<std::string> symbolNames(
   return names;
 }
 
+bool StringEqSquashingWhitespace(
+    const std::string& have,
+    const std::string& expected) {
+  auto atHave = have.begin();
+  auto atExpected = expected.begin();
+  while (atHave != have.end() && atExpected != expected.end()) {
+    if (isspace(*atExpected)) {
+      if (!isspace(*atHave)) {
+        return false;
+      }
+      // Have a match, consume all remaining space.
+      do {
+        atExpected++;
+      } while (atExpected != expected.end() && isspace(*atExpected));
+      do {
+        atHave++;
+      } while (atHave != have.end() && isspace(*atHave));
+      continue;
+    }
+    if (*atHave != *atExpected) {
+      return false;
+    }
+    atHave++;
+    atExpected++;
+  }
+  // For convenience consume any trailing whitespace on both sides.
+  if (atExpected != expected.end()) {
+    do {
+      atExpected++;
+    } while (atExpected != expected.end() && isspace(*atExpected));
+  }
+  if (atHave != have.end()) {
+    do {
+      atHave++;
+    } while (atHave != have.end() && isspace(*atHave));
+  }
+  return atHave == have.end() && atExpected == expected.end();
+}
+
 } // namespace
 
 class ParsesOkMatcher {
@@ -117,39 +156,39 @@ ::testing::Matcher<const ParseResult&> HasSymbols(
   return HasSymbolsMatcher(std::move(expected_symbols));
 }
 
-class SerializesToMatcher {
+class WhenSerializedMatcher {
  public:
   using is_gtest_matcher = void;
 
-  explicit SerializesToMatcher(std::string expected_result)
-      : expected_result_(std::move(expected_result)) {}
+  explicit WhenSerializedMatcher(
+      ::testing::Matcher<const std::string&> string_matcher)
+      : string_matcher_(std::move(string_matcher)) {}
 
-  bool MatchAndExplain(const ParseResult& result, std::ostream* listener)
-      const {
+  bool MatchAndExplain(
+      const ParseResult& result,
+      ::testing::MatchResultListener* listener) const {
     std::string outputText =
         SymbolTablePrinter::outputToText(result.getSymbolTable());
-    if (listener) {
-      *listener << "has output text \"" << outputText << "\"";
-    }
-    return outputText == expected_result_;
+    return MatchPrintAndExplain(outputText, string_matcher_, listener);
   }
 
-  void DescribeTo(std::ostream* os) const {
-    *os << "serializes to: " << ::testing::PrintToString(expected_result_);
+  void DescribeTo(::std::ostream* os) const {
+    *os << "matches after serializing ";
+    string_matcher_.DescribeTo(os);
   }
 
-  void DescribeNegationTo(std::ostream* os) const {
-    *os << "does not serialize to: "
-        << ::testing::PrintToString(expected_result_);
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "does not match after serializing ";
+    string_matcher_.DescribeTo(os);
   }
 
  private:
-  const std::string expected_result_;
+  ::testing::Matcher<const std::string&> string_matcher_;
 };
 
-::testing::Matcher<const ParseResult&> SerializesTo(
-    std::string expected_symbols) {
-  return SerializesToMatcher(std::move(expected_symbols));
+::testing::Matcher<const ParseResult&> WhenSerialized(
+    ::testing::Matcher<const std::string&> string_matcher) {
+  return WhenSerializedMatcher(std::move(string_matcher));
 }
 
 class HasErrorsMatcher {
@@ -183,4 +222,35 @@ ::testing::Matcher<const ParseResult&> HasErrors(
   return HasErrorsMatcher(std::move(expected_errors));
 }
 
+class EqSquashingWhitespaceMatcher {
+ public:
+  using is_gtest_matcher = void;
+
+  explicit EqSquashingWhitespaceMatcher(std::string expected_string)
+      : expected_string_(std::move(expected_string)) {}
+
+  bool MatchAndExplain(const std::string& str, std::ostream* /* listener */)
+      const {
+    return StringEqSquashingWhitespace(str, expected_string_);
+  }
+
+  void DescribeTo(std::ostream* os) const {
+    *os << "equals squashing whitespace "
+        << ::testing::PrintToString(expected_string_);
+  }
+
+  void DescribeNegationTo(std::ostream* os) const {
+    *os << "does not equal squashing whitespace "
+        << ::testing::PrintToString(expected_string_);
+  }
+
+ private:
+  std::string expected_string_;
+};
+
+::testing::Matcher<const std::string&> EqSquashingWhitespace(
+    std::string expected_string) {
+  return EqSquashingWhitespaceMatcher(std::move(expected_string));
+}
+
 } // namespace io::substrait::textplan

src/substrait/textplan/tests/ParseResultMatchers.h

@@ -14,10 +14,15 @@ namespace io::substrait::textplan {
 [[maybe_unused]] ::testing::Matcher<const ParseResult&> HasSymbols(
     std::vector<std::string> expected_symbols);
 
-[[maybe_unused]] ::testing::Matcher<const ParseResult&> SerializesTo(
-    std::string expected_result);
+[[maybe_unused]] ::testing::Matcher<const ParseResult&> WhenSerialized(
+    ::testing::Matcher<const std::string&> string_matcher);
 
 [[maybe_unused]] ::testing::Matcher<const ParseResult&> HasErrors(
     std::vector<std::string> expected_errors);
 
+// Matches strings ignoring differences in kinds of whitespace (as long as they
+// are present) and ignoring trailing whitespace as well.
+[[maybe_unused]] ::testing::Matcher<const std::string&> EqSquashingWhitespace(
+    std::string expected_string);
+
 } // namespace io::substrait::textplan