[PATCH v2 1/2] gdb: add selftests for split_name

[Simon Marchi <simon.marchi@efficios.com>]

Add selftests for split_name, covering all splitting styles.  Some
output is questionable, but the goal is to document the current
behavior.

Change-Id: Ib31a6f01762e84eefff647e0c141975ea23d469f
---
 gdb/split-name.c | 189 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 189 insertions(+)

diff --git a/gdb/split-name.c b/gdb/split-name.c
index bc145909c2e8..cb740a968d49 100644
--- a/gdb/split-name.c
+++ b/gdb/split-name.c
@@ -19,6 +19,8 @@
 
 #include "split-name.h"
 #include "cp-support.h"
+#include "gdbsupport/enumerate.h"
+#include "gdbsupport/selftest.h"
 
 /* See split-name.h.  */
 
@@ -64,3 +66,190 @@ split_name (const char *name, split_style style)
   result.emplace_back (&name[previous_len]);
   return result;
 }
+
+#if GDB_SELF_TEST
+
+namespace selftests {
+
+/* Return a string representation of COMPONENTS, for debugging.  */
+
+static std::string
+components_to_string (const std::vector<std::string_view> &components)
+{
+  std::string str = "{";
+
+  for (auto [i, component] : gdb::ranges::views::enumerate (components))
+    {
+      if (i > 0)
+	str += ",";
+
+      str += " \"";
+      str += component;
+      str += "\"";
+    }
+
+  str += " }";
+  return str;
+}
+
+/* Check that splitting NAME using STYLE gives EXPECTED.  */
+
+static void
+check_split_name (const char *name, split_style style,
+		  const std::vector<std::string_view> &expected)
+{
+  std::vector<std::string_view> result = split_name (name, style);
+
+  if (result != expected)
+    debug_printf ("split_name (\"%s\"): got %s, expected %s\n", name,
+		  components_to_string (result).c_str (),
+		  components_to_string (expected).c_str ());
+
+  SELF_CHECK (result == expected);
+}
+
+static void
+test_split_name_none ()
+{
+  /* No splitting is ever done.  */
+  check_split_name ("", split_style::NONE, { "" });
+  check_split_name ("foo", split_style::NONE, { "foo" });
+  check_split_name ("a::b", split_style::NONE, { "a::b" });
+  check_split_name ("a.b", split_style::NONE, { "a.b" });
+  check_split_name ("a..b", split_style::NONE, { "a..b" });
+  check_split_name ("::", split_style::NONE, { "::" });
+  check_split_name (".", split_style::NONE, { "." });
+}
+
+static void
+test_split_name_cxx ()
+{
+  /* Simple names.  */
+  check_split_name ("", split_style::CXX, { "" });
+  check_split_name ("foo", split_style::CXX, { "foo" });
+  check_split_name ("a::b", split_style::CXX, { "a", "b" });
+  check_split_name ("a::b::c", split_style::CXX, { "a", "b", "c" });
+
+  /* Dots are not separators.  */
+  check_split_name ("a.b", split_style::CXX, { "a.b" });
+  check_split_name ("a..b::c", split_style::CXX, { "a..b", "c" });
+
+  /* A single colon is not a separator.  */
+  check_split_name ("a:b", split_style::CXX, { "a:b" });
+  check_split_name ("a:::b", split_style::CXX, { "a", ":b" });
+
+  /* Templates.  */
+  check_split_name ("a<b::c>", split_style::CXX, { "a<b::c>" });
+  check_split_name ("a<b::c>::d", split_style::CXX, { "a<b::c>", "d" });
+  check_split_name ("a::b<c::d, e::f>::g", split_style::CXX,
+		    { "a", "b<c::d, e::f>", "g" });
+  check_split_name ("a<b::c<d::e>>::f", split_style::CXX,
+		    { "a<b::c<d::e>>", "f" });
+  check_split_name ("std::vector<int, std::allocator<int> >::size",
+		    split_style::CXX,
+		    { "std", "vector<int, std::allocator<int> >", "size" });
+
+  /* Parentheses: function parameters, function-local names,
+     anonymous namespaces.  */
+  check_split_name ("a::b(c::d)", split_style::CXX, { "a", "b(c::d)" });
+  check_split_name ("a::b(c::d) const", split_style::CXX,
+		    { "a", "b(c::d) const" });
+  check_split_name ("foo(int)::bar", split_style::CXX,
+		    { "foo(int)", "bar" });
+  check_split_name ("(anonymous namespace)::foo", split_style::CXX,
+		    { "(anonymous namespace)", "foo" });
+  check_split_name ("a::(anonymous namespace)::foo", split_style::CXX,
+		    { "a", "(anonymous namespace)", "foo" });
+
+  /* Operators, which can contain characters that would otherwise
+     be treated specially.  */
+  check_split_name ("A::operator<", split_style::CXX,
+		    { "A", "operator<" });
+  check_split_name ("A::operator<<", split_style::CXX,
+		    { "A", "operator<<" });
+  check_split_name ("A::operator>", split_style::CXX,
+		    { "A", "operator>" });
+  check_split_name ("A::operator>>", split_style::CXX,
+		    { "A", "operator>>" });
+  check_split_name ("A::operator->", split_style::CXX,
+		    { "A", "operator->" });
+  check_split_name ("A::operator()", split_style::CXX,
+		    { "A", "operator()" });
+  check_split_name ("A::operator< <int>", split_style::CXX,
+		    { "A", "operator< <int>" });
+  check_split_name ("A::operator<(A const&, A const&)", split_style::CXX,
+		    { "A", "operator<(A const&, A const&)" });
+
+  /* "operator" as part of an identifier is not an operator.  */
+  check_split_name ("cooperator::x", split_style::CXX,
+		    { "cooperator", "x" });
+  check_split_name ("operator_foo::x", split_style::CXX,
+		    { "operator_foo", "x" });
+
+  /* Malformed names are returned as a single component.  */
+  check_split_name ("a<b::c", split_style::CXX, { "a<b::c" });
+  check_split_name ("a(b::c", split_style::CXX, { "a(b::c" });
+  check_split_name ("a>b::c", split_style::CXX, { "a>b::c" });
+  check_split_name ("a)b::c", split_style::CXX, { "a)b::c" });
+
+  /* Leading, trailing or consecutive separators produce empty
+     components.  */
+  check_split_name ("::", split_style::CXX, { "", "" });
+  check_split_name ("::a", split_style::CXX, { "", "a" });
+  check_split_name ("a::", split_style::CXX, { "a", "" });
+  check_split_name ("a::::b", split_style::CXX, { "a", "", "b" });
+}
+
+static void
+test_split_name_dot_style ()
+{
+  /* Simple names.  */
+  check_split_name ("", split_style::DOT_STYLE, { "" });
+  check_split_name ("foo", split_style::DOT_STYLE, { "foo" });
+  check_split_name ("a.b", split_style::DOT_STYLE, { "a", "b" });
+  check_split_name ("a.b.c", split_style::DOT_STYLE, { "a", "b", "c" });
+  check_split_name ("pkg.sub.func", split_style::DOT_STYLE,
+		    { "pkg", "sub", "func" });
+
+  /* "::" is not a separator.  */
+  check_split_name ("a::b", split_style::DOT_STYLE, { "a::b" });
+  check_split_name ("a::b.c", split_style::DOT_STYLE, { "a::b", "c" });
+
+  /* Go method names.  */
+  check_split_name ("main.(*T).Method", split_style::DOT_STYLE,
+		    { "main", "(*T)", "Method" });
+
+  /* Ada operator names.  */
+  check_split_name ("pkg.\"+\"", split_style::DOT_STYLE,
+		    { "pkg", "\"+\"" });
+
+  /* Leading, trailing or consecutive dots produce empty components.  */
+  check_split_name (".", split_style::DOT_STYLE, { "", "" });
+  check_split_name ("..", split_style::DOT_STYLE, { "", "", "" });
+  check_split_name (".a", split_style::DOT_STYLE, { "", "a" });
+  check_split_name ("a.", split_style::DOT_STYLE, { "a", "" });
+  check_split_name ("a..b", split_style::DOT_STYLE, { "a", "", "b" });
+  check_split_name (".a.b", split_style::DOT_STYLE, { "", "a", "b" });
+  check_split_name ("a.b.", split_style::DOT_STYLE, { "a", "b", "" });
+  check_split_name ("a.b..c", split_style::DOT_STYLE,
+		    { "a", "b", "", "c" });
+  check_split_name ("a..b.c", split_style::DOT_STYLE,
+		    { "a", "", "b", "c" });
+  check_split_name ("a...b", split_style::DOT_STYLE, { "a", "", "", "b" });
+}
+
+} /* namespace selftests */
+
+#endif /* GDB_SELF_TEST */
+
+INIT_GDB_FILE (split_name)
+{
+#if GDB_SELF_TEST
+  selftests::register_test ("split_name_none",
+			    selftests::test_split_name_none);
+  selftests::register_test ("split_name_cxx",
+			    selftests::test_split_name_cxx);
+  selftests::register_test ("split_name_dot_style",
+			    selftests::test_split_name_dot_style);
+#endif
+}
-- 
2.56.0