Clang Project

clang_source_code/test/Analysis/gtest.cpp
1//RUN: %clang_analyze_cc1 -cc1 -std=c++11  -analyzer-checker=core,apiModeling.google.GTest,debug.ExprInspection %s -verify
2//RUN: %clang_analyze_cc1 -cc1 -std=c++11  -analyzer-checker=core,apiModeling.google.GTest,debug.ExprInspection -DGTEST_VERSION_1_8_AND_LATER=1 %s -verify
3
4void clang_analyzer_eval(int);
5void clang_analyzer_warnIfReached();
6
7namespace std {
8  class string {
9    public:
10    ~string();
11    const char *c_str();
12  };
13}
14
15namespace testing {
16
17class Message { };
18class TestPartResult {
19 public:
20  enum Type {
21    kSuccess,
22    kNonFatalFailure,
23    kFatalFailure
24  };
25};
26
27namespace internal {
28
29class AssertHelper {
30 public:
31  AssertHelper(TestPartResult::Type type, const char* file, int line,
32               const char* message);
33  ~AssertHelper();
34  void operator=(const Message& message) const;
35};
36
37
38template <typename T>
39struct AddReference { typedef T& type; };
40template <typename T>
41struct AddReference<T&> { typedef T& type; };
42template <typename From, typename To>
43class ImplicitlyConvertible {
44 private:
45  static typename AddReference<From>::type MakeFrom();
46  static char Helper(To);
47  static char (&Helper(...))[2];
48 public:
49  static const bool value =
50      sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1;
51};
52template <typename From, typename To>
53const bool ImplicitlyConvertible<From, To>::value;
54template<bool> struct EnableIf;
55template<> struct EnableIf<true> { typedef void type; };
56
57} // end internal
58
59
60class AssertionResult {
61public:
62
63  // The implementation for the copy constructor is not exposed in the
64  // interface.
65  AssertionResult(const AssertionResult& other);
66
67#if defined(GTEST_VERSION_1_8_AND_LATER)
68  template <typename T>
69  explicit AssertionResult(
70      const T& success,
71      typename internal::EnableIf<
72          !internal::ImplicitlyConvertible<T, AssertionResult>::value>::type*
73          /*enabler*/ = 0)
74      : success_(success) {}
75#else
76  explicit AssertionResult(bool success) : success_(success) {}
77#endif
78
79  operator bool() const { return success_; }
80
81  // The actual AssertionResult does not have an explicit destructor, but
82  // it does have a non-trivial member veriable, so we add a destructor here
83  // to force temporary cleanups.
84  ~AssertionResult();
85private:
86
87  bool success_;
88};
89
90namespace internal {
91std::string GetBoolAssertionFailureMessage(
92    const AssertionResult& assertion_result,
93    const char* expression_text,
94    const char* actual_predicate_value,
95    const char* expected_predicate_value);
96} // end internal
97
98} // end testing
99
100#define GTEST_MESSAGE_AT_(file, line, message, result_type) \
101  ::testing::internal::AssertHelper(result_type, file, line, message) \
102    = ::testing::Message()
103
104#define GTEST_MESSAGE_(message, result_type) \
105  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
106
107#define GTEST_FATAL_FAILURE_(message) \
108  return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)
109
110#define GTEST_NONFATAL_FAILURE_(message) \
111  GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
112
113# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:
114
115#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
116  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
117  if (const ::testing::AssertionResult gtest_ar_ = \
118      ::testing::AssertionResult(expression)) \
119    ; \
120  else \
121    fail(::testing::internal::GetBoolAssertionFailureMessage(\
122        gtest_ar_, text, #actual, #expected).c_str())
123
124#define EXPECT_TRUE(condition) \
125  GTEST_TEST_BOOLEAN_((condition), #condition, false, true, \
126                      GTEST_NONFATAL_FAILURE_)
127#define ASSERT_TRUE(condition) \
128  GTEST_TEST_BOOLEAN_((condition), #condition, false, true, \
129                      GTEST_FATAL_FAILURE_)
130
131#define ASSERT_FALSE(condition) \
132  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
133                      GTEST_FATAL_FAILURE_)
134
135void testAssertTrue(int *p) {
136  ASSERT_TRUE(p != nullptr);
137  EXPECT_TRUE(1 == *p); // no-warning
138}
139
140void testAssertFalse(int *p) {
141  ASSERT_FALSE(p == nullptr);
142  EXPECT_TRUE(1 == *p); // no-warning
143}
144
145void testConstrainState(int p) {
146  ASSERT_TRUE(p == 7);
147
148  clang_analyzer_eval(p == 7); // expected-warning {{TRUE}}
149
150  ASSERT_TRUE(false);
151  clang_analyzer_warnIfReached(); // no-warning
152}
153
154void testAssertSymbolicPtr(const bool *b) {
155  ASSERT_TRUE(*b); // no-crash
156
157  clang_analyzer_eval(*b); // expected-warning{{TRUE}}
158}
159
160void testAssertSymbolicRef(const bool &b) {
161  ASSERT_TRUE(b); // no-crash
162
163  clang_analyzer_eval(b); // expected-warning{{TRUE}}
164}
165
CodeThinker, Enjoy your reading code