forked from OSchip/llvm-project
306 lines
11 KiB
C++
306 lines
11 KiB
C++
// RUN: %check_clang_tidy %s abseil-string-find-str-contains %t -- \
|
|
// RUN: -config="{CheckOptions: []}"
|
|
|
|
using size_t = decltype(sizeof(int));
|
|
|
|
namespace std {
|
|
|
|
// Lightweight standin for std::string.
|
|
template <typename C>
|
|
class basic_string {
|
|
public:
|
|
basic_string();
|
|
basic_string(const basic_string &);
|
|
basic_string(const C *);
|
|
~basic_string();
|
|
int find(basic_string s, int pos = 0);
|
|
int find(const C *s, int pos = 0);
|
|
int find(const C *s, int pos, int n);
|
|
int find(char c, int pos = 0);
|
|
static constexpr size_t npos = -1;
|
|
};
|
|
typedef basic_string<char> string;
|
|
|
|
// Lightweight standin for std::string_view.
|
|
template <typename C>
|
|
class basic_string_view {
|
|
public:
|
|
basic_string_view();
|
|
basic_string_view(const basic_string_view &);
|
|
basic_string_view(const C *);
|
|
~basic_string_view();
|
|
int find(basic_string_view s, int pos = 0);
|
|
int find(const C *s, int pos = 0);
|
|
int find(const C *s, int pos, int n);
|
|
int find(char c, int pos = 0);
|
|
static constexpr size_t npos = -1;
|
|
};
|
|
typedef basic_string_view<char> string_view;
|
|
|
|
} // namespace std
|
|
|
|
namespace absl {
|
|
|
|
// Lightweight standin for absl::string_view.
|
|
class string_view {
|
|
public:
|
|
string_view();
|
|
string_view(const string_view &);
|
|
string_view(const char *);
|
|
~string_view();
|
|
int find(string_view s, int pos = 0);
|
|
int find(const char *s, int pos = 0);
|
|
int find(const char *s, int pos, int n);
|
|
int find(char c, int pos = 0);
|
|
static constexpr size_t npos = -1;
|
|
};
|
|
|
|
} // namespace absl
|
|
|
|
// Functions that take and return our various string-like types.
|
|
std::string foo_ss(std::string);
|
|
std::string_view foo_ssv(std::string_view);
|
|
absl::string_view foo_asv(absl::string_view);
|
|
std::string bar_ss();
|
|
std::string_view bar_ssv();
|
|
absl::string_view bar_asv();
|
|
|
|
// Confirms that find==npos and find!=npos work for each supported type, when
|
|
// npos comes from the correct type.
|
|
void basic_tests() {
|
|
std::string ss;
|
|
ss.find("a") == std::string::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of find() == npos
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, "a");{{$}}
|
|
|
|
ss.find("a") != std::string::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of find() != npos
|
|
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ss, "a");{{$}}
|
|
|
|
std::string::npos != ss.find("a");
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ss, "a");{{$}}
|
|
|
|
std::string_view ssv;
|
|
ssv.find("a") == std::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, "a");{{$}}
|
|
|
|
ssv.find("a") != std::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ssv, "a");{{$}}
|
|
|
|
std::string_view::npos != ssv.find("a");
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ssv, "a");{{$}}
|
|
|
|
absl::string_view asv;
|
|
asv.find("a") == absl::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, "a");{{$}}
|
|
|
|
asv.find("a") != absl::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(asv, "a");{{$}}
|
|
|
|
absl::string_view::npos != asv.find("a");
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(asv, "a");{{$}}
|
|
}
|
|
|
|
// Confirms that it works even if you mix-and-match the type for find and for
|
|
// npos. (One of the reasons for this checker is to clean up cases that
|
|
// accidentally mix-and-match like this. absl::StrContains is less
|
|
// error-prone.)
|
|
void mismatched_npos() {
|
|
std::string ss;
|
|
ss.find("a") == std::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, "a");{{$}}
|
|
|
|
ss.find("a") != absl::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ss, "a");{{$}}
|
|
|
|
std::string_view ssv;
|
|
ssv.find("a") == absl::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, "a");{{$}}
|
|
|
|
ssv.find("a") != std::string::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ssv, "a");{{$}}
|
|
|
|
absl::string_view asv;
|
|
asv.find("a") == std::string::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, "a");{{$}}
|
|
|
|
asv.find("a") != std::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(asv, "a");{{$}}
|
|
}
|
|
|
|
// Confirms that it works even when the needle or the haystack are more
|
|
// complicated expressions.
|
|
void subexpression_tests() {
|
|
std::string ss, ss2;
|
|
foo_ss(ss).find(ss2) == std::string::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(foo_ss(ss), ss2);{{$}}
|
|
|
|
ss.find(foo_ss(ss2)) != std::string::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ss, foo_ss(ss2));{{$}}
|
|
|
|
foo_ss(bar_ss()).find(foo_ss(ss2)) != std::string::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(foo_ss(bar_ss()), foo_ss(ss2));{{$}}
|
|
|
|
std::string_view ssv, ssv2;
|
|
foo_ssv(ssv).find(ssv2) == std::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(foo_ssv(ssv), ssv2);{{$}}
|
|
|
|
ssv.find(foo_ssv(ssv2)) != std::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(ssv, foo_ssv(ssv2));{{$}}
|
|
|
|
foo_ssv(bar_ssv()).find(foo_ssv(ssv2)) != std::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(foo_ssv(bar_ssv()), foo_ssv(ssv2));{{$}}
|
|
|
|
absl::string_view asv, asv2;
|
|
foo_asv(asv).find(asv2) == absl::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(foo_asv(asv), asv2);{{$}}
|
|
|
|
asv.find(foo_asv(asv2)) != absl::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(asv, foo_asv(asv2));{{$}}
|
|
|
|
foo_asv(bar_asv()).find(foo_asv(asv2)) != absl::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}absl::StrContains(foo_asv(bar_asv()), foo_asv(asv2));{{$}}
|
|
}
|
|
|
|
// Confirms that it works with string literal, char* and const char* parameters.
|
|
void string_literal_and_char_ptr_tests() {
|
|
char *c = nullptr;
|
|
const char *cc = nullptr;
|
|
|
|
std::string ss;
|
|
ss.find("c") == std::string::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, "c");{{$}}
|
|
|
|
ss.find(c) == std::string::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, c);{{$}}
|
|
|
|
ss.find(cc) == std::string::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, cc);{{$}}
|
|
|
|
std::string_view ssv;
|
|
ssv.find("c") == std::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, "c");{{$}}
|
|
|
|
ssv.find(c) == std::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, c);{{$}}
|
|
|
|
ssv.find(cc) == std::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, cc);{{$}}
|
|
|
|
absl::string_view asv;
|
|
asv.find("c") == absl::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, "c");{{$}}
|
|
|
|
asv.find(c) == absl::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, c);{{$}}
|
|
|
|
asv.find(cc) == absl::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, cc);{{$}}
|
|
}
|
|
|
|
void char_param_tests() {
|
|
std::string ss;
|
|
ss.find('c') == std::string::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ss, 'c');{{$}}
|
|
|
|
std::string_view ssv;
|
|
ssv.find('c') == std::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(ssv, 'c');{{$}}
|
|
|
|
absl::string_view asv;
|
|
asv.find('c') == absl::string_view::npos;
|
|
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use !absl::StrContains instead of
|
|
// CHECK-FIXES: {{^[[:space:]]*}}!absl::StrContains(asv, 'c');{{$}}
|
|
}
|
|
|
|
#define FOO(a, b, c, d) ((a).find(b) == std::string::npos ? (c) : (d))
|
|
|
|
// Confirms that it does not match when a macro would be "torn" by the fix.
|
|
void no_tearing_macros() {
|
|
std::string h = "helo";
|
|
FOO(h, "x", 5, 6);
|
|
}
|
|
|
|
// Confirms that it does not match when the pos parameter is non-zero.
|
|
void no_nonzero_pos() {
|
|
std::string ss;
|
|
ss.find("a", 1) == std::string::npos;
|
|
|
|
std::string_view ssv;
|
|
ssv.find("a", 2) == std::string_view::npos;
|
|
|
|
absl::string_view asv;
|
|
asv.find("a", 3) == std::string_view::npos;
|
|
}
|
|
|
|
// Confirms that it does not match when the count parameter is present.
|
|
void no_count() {
|
|
std::string ss;
|
|
ss.find("a", 0, 1) == std::string::npos;
|
|
|
|
std::string_view ssv;
|
|
ssv.find("a", 0, 1) == std::string_view::npos;
|
|
|
|
absl::string_view asv;
|
|
asv.find("a", 0, 1) == std::string_view::npos;
|
|
}
|
|
|
|
// Confirms that it does not match when it's compared to something other than
|
|
// npos, even if the value is the same as npos.
|
|
void no_non_npos() {
|
|
std::string ss;
|
|
ss.find("a") == 0;
|
|
ss.find("a") == 1;
|
|
ss.find("a") == -1;
|
|
|
|
std::string_view ssv;
|
|
ssv.find("a") == 0;
|
|
ssv.find("a") == 1;
|
|
ssv.find("a") == -1;
|
|
|
|
absl::string_view asv;
|
|
asv.find("a") == 0;
|
|
asv.find("a") == 1;
|
|
asv.find("a") == -1;
|
|
}
|
|
|
|
// Confirms that it does not match if the two operands are the same.
|
|
void no_symmetric_operands() {
|
|
std::string ss;
|
|
ss.find("a") == ss.find("a");
|
|
std::string::npos == std::string::npos;
|
|
}
|