lldb/unittests/DataFormatter/FormattersContainerTest.cpp

   1 //===-- FormattersContainerTests.cpp --------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/DataFormatters/FormattersContainer.h"
  10
  11 #include "gtest/gtest.h"
  12
  13 using namespace lldb;
  14 using namespace lldb_private;
  15
  16 // All the prefixes that the exact name matching will strip from the type.
  17 static const std::vector<std::string> exact_name_prefixes = {
  18     "", // no prefix.
  19     "class ", "struct ", "union ", "enum ",
  20 };
  21
  22 // TypeMatcher that uses a exact type name string that needs to be matched.
  23 TEST(TypeMatcherTests, ExactName) {
  24   for (const std::string &prefix : exact_name_prefixes) {
  25     SCOPED_TRACE("Prefix: " + prefix);
  26
  27     TypeMatcher matcher(ConstString(prefix + "Name"));
  28     EXPECT_TRUE(matcher.Matches(ConstString("class Name")));
  29     EXPECT_TRUE(matcher.Matches(ConstString("struct Name")));
  30     EXPECT_TRUE(matcher.Matches(ConstString("union Name")));
  31     EXPECT_TRUE(matcher.Matches(ConstString("enum Name")));
  32     EXPECT_TRUE(matcher.Matches(ConstString("Name")));
  33
  34     EXPECT_FALSE(matcher.Matches(ConstString("Name ")));
  35     EXPECT_FALSE(matcher.Matches(ConstString("ame")));
  36     EXPECT_FALSE(matcher.Matches(ConstString("Nam")));
  37     EXPECT_FALSE(matcher.Matches(ConstString("am")));
  38     EXPECT_FALSE(matcher.Matches(ConstString("a")));
  39     EXPECT_FALSE(matcher.Matches(ConstString(" ")));
  40     EXPECT_FALSE(matcher.Matches(ConstString("class N")));
  41     EXPECT_FALSE(matcher.Matches(ConstString("class ")));
  42     EXPECT_FALSE(matcher.Matches(ConstString("class")));
  43   }
  44 }
  45
  46 // TypeMatcher that uses a regex to match a type name.
  47 TEST(TypeMatcherTests, RegexName) {
  48   TypeMatcher matcher(RegularExpression("^a[a-z]c$"));
  49   EXPECT_TRUE(matcher.Matches(ConstString("abc")));
  50   EXPECT_TRUE(matcher.Matches(ConstString("azc")));
  51
  52   // FIXME: This isn't consistent with the 'exact' type name matches above.
  53   EXPECT_FALSE(matcher.Matches(ConstString("class abc")));
  54
  55   EXPECT_FALSE(matcher.Matches(ConstString("abbc")));
  56   EXPECT_FALSE(matcher.Matches(ConstString(" abc")));
  57   EXPECT_FALSE(matcher.Matches(ConstString("abc ")));
  58   EXPECT_FALSE(matcher.Matches(ConstString(" abc ")));
  59   EXPECT_FALSE(matcher.Matches(ConstString("XabcX")));
  60   EXPECT_FALSE(matcher.Matches(ConstString("ac")));
  61   EXPECT_FALSE(matcher.Matches(ConstString("a[a-z]c")));
  62   EXPECT_FALSE(matcher.Matches(ConstString("aAc")));
  63   EXPECT_FALSE(matcher.Matches(ConstString("ABC")));
  64   EXPECT_FALSE(matcher.Matches(ConstString("")));
  65 }
  66
  67 // TypeMatcher that only searches the type name.
  68 TEST(TypeMatcherTests, RegexMatchPart) {
  69   TypeMatcher matcher(RegularExpression("a[a-z]c"));
  70   EXPECT_TRUE(matcher.Matches(ConstString("class abc")));
  71   EXPECT_TRUE(matcher.Matches(ConstString("abc")));
  72   EXPECT_TRUE(matcher.Matches(ConstString(" abc ")));
  73   EXPECT_TRUE(matcher.Matches(ConstString("azc")));
  74   EXPECT_TRUE(matcher.Matches(ConstString("abc ")));
  75   EXPECT_TRUE(matcher.Matches(ConstString(" abc ")));
  76   EXPECT_TRUE(matcher.Matches(ConstString(" abc")));
  77   EXPECT_TRUE(matcher.Matches(ConstString("XabcX")));
  78
  79   EXPECT_FALSE(matcher.Matches(ConstString("abbc")));
  80   EXPECT_FALSE(matcher.Matches(ConstString("ac")));
  81   EXPECT_FALSE(matcher.Matches(ConstString("a[a-z]c")));
  82   EXPECT_FALSE(matcher.Matches(ConstString("aAc")));
  83   EXPECT_FALSE(matcher.Matches(ConstString("ABC")));
  84   EXPECT_FALSE(matcher.Matches(ConstString("")));
  85 }
  86
  87 // GetMatchString for exact type name matchers.
  88 TEST(TypeMatcherTests, GetMatchStringExactName) {
  89   EXPECT_EQ(TypeMatcher(ConstString("aa")).GetMatchString(), "aa");
  90   EXPECT_EQ(TypeMatcher(ConstString("")).GetMatchString(), "");
  91   EXPECT_EQ(TypeMatcher(ConstString("[a]")).GetMatchString(), "[a]");
  92 }
  93
  94 // GetMatchString for regex matchers.
  95 TEST(TypeMatcherTests, GetMatchStringRegex) {
  96   EXPECT_EQ(TypeMatcher(RegularExpression("aa")).GetMatchString(), "aa");
  97   EXPECT_EQ(TypeMatcher(RegularExpression("")).GetMatchString(), "");
  98   EXPECT_EQ(TypeMatcher(RegularExpression("[a]")).GetMatchString(), "[a]");
  99 }
 100
 101 // GetMatchString for regex matchers.
 102 TEST(TypeMatcherTests, CreatedBySameMatchString) {
 103   TypeMatcher empty_str(ConstString(""));
 104   TypeMatcher empty_regex(RegularExpression(""));
 105   EXPECT_TRUE(empty_str.CreatedBySameMatchString(empty_str));
 106   EXPECT_TRUE(empty_str.CreatedBySameMatchString(empty_regex));
 107
 108   TypeMatcher a_str(ConstString("a"));
 109   TypeMatcher a_regex(RegularExpression("a"));
 110   EXPECT_TRUE(a_str.CreatedBySameMatchString(a_str));
 111   EXPECT_TRUE(a_str.CreatedBySameMatchString(a_regex));
 112
 113   TypeMatcher digit_str(ConstString("[0-9]"));
 114   TypeMatcher digit_regex(RegularExpression("[0-9]"));
 115   EXPECT_TRUE(digit_str.CreatedBySameMatchString(digit_str));
 116   EXPECT_TRUE(digit_str.CreatedBySameMatchString(digit_regex));
 117
 118   EXPECT_FALSE(empty_str.CreatedBySameMatchString(a_str));
 119   EXPECT_FALSE(empty_str.CreatedBySameMatchString(a_regex));
 120   EXPECT_FALSE(empty_str.CreatedBySameMatchString(digit_str));
 121   EXPECT_FALSE(empty_str.CreatedBySameMatchString(digit_regex));
 122
 123   EXPECT_FALSE(empty_regex.CreatedBySameMatchString(a_str));
 124   EXPECT_FALSE(empty_regex.CreatedBySameMatchString(a_regex));
 125   EXPECT_FALSE(empty_regex.CreatedBySameMatchString(digit_str));
 126   EXPECT_FALSE(empty_regex.CreatedBySameMatchString(digit_regex));
 127
 128   EXPECT_FALSE(a_str.CreatedBySameMatchString(empty_str));
 129   EXPECT_FALSE(a_str.CreatedBySameMatchString(empty_regex));
 130   EXPECT_FALSE(a_str.CreatedBySameMatchString(digit_str));
 131   EXPECT_FALSE(a_str.CreatedBySameMatchString(digit_regex));
 132
 133   EXPECT_FALSE(a_regex.CreatedBySameMatchString(empty_str));
 134   EXPECT_FALSE(a_regex.CreatedBySameMatchString(empty_regex));
 135   EXPECT_FALSE(a_regex.CreatedBySameMatchString(digit_str));
 136   EXPECT_FALSE(a_regex.CreatedBySameMatchString(digit_regex));
 137
 138   EXPECT_FALSE(digit_str.CreatedBySameMatchString(empty_str));
 139   EXPECT_FALSE(digit_str.CreatedBySameMatchString(empty_regex));
 140   EXPECT_FALSE(digit_str.CreatedBySameMatchString(a_str));
 141   EXPECT_FALSE(digit_str.CreatedBySameMatchString(a_regex));
 142
 143   EXPECT_FALSE(digit_regex.CreatedBySameMatchString(empty_str));
 144   EXPECT_FALSE(digit_regex.CreatedBySameMatchString(empty_regex));
 145   EXPECT_FALSE(digit_regex.CreatedBySameMatchString(a_str));
 146   EXPECT_FALSE(digit_regex.CreatedBySameMatchString(a_regex));
 147 }
 148
 149 // Test CreatedBySameMatchString with stripped exact name prefixes.
 150 TEST(TypeMatcherTests, CreatedBySameMatchStringExactNamePrefixes) {
 151   for (const std::string &prefix : exact_name_prefixes) {
 152     SCOPED_TRACE("Prefix: " + prefix);
 153     TypeMatcher with_prefix(ConstString(prefix + "Name"));
 154     TypeMatcher without_prefix(RegularExpression(""));
 155
 156     EXPECT_TRUE(with_prefix.CreatedBySameMatchString(with_prefix));
 157     EXPECT_TRUE(without_prefix.CreatedBySameMatchString(without_prefix));
 158   }
 159 }