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 
4 void clang_analyzer_eval(int);
5 void clang_analyzer_warnIfReached();
6 
7 namespace std {
8   class string {
9     public:
10     ~string();
11     const char *c_str();
12   };
13 }
14 
15 namespace testing {
16 
17 class Message { };
18 class TestPartResult {
19  public:
20   enum Type {
21     kSuccess,
22     kNonFatalFailure,
23     kFatalFailure
24   };
25 };
26 
27 namespace internal {
28 
29 class 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 
38 template <typename T>
39 struct AddReference { typedef T& type; };
40 template <typename T>
41 struct AddReference<T&> { typedef T& type; };
42 template <typename From, typename To>
43 class 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 };
52 template <typename From, typename To>
53 const bool ImplicitlyConvertible<From, To>::value;
54 template<bool> struct EnableIf;
55 template<> struct EnableIf<true> { typedef void type; };
56 
57 } // end internal
58 
59 
60 class AssertionResult {
61 public:
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();
85 private:
86 
87   bool success_;
88 };
89 
90 namespace internal {
91 std::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 
135 void testAssertTrue(int *p) {
136   ASSERT_TRUE(p != nullptr);
137   EXPECT_TRUE(1 == *p); // no-warning
138 }
139 
140 void testAssertFalse(int *p) {
141   ASSERT_FALSE(p == nullptr);
142   EXPECT_TRUE(1 == *p); // no-warning
143 }
144 
145 void 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 
154 void testAssertSymbolicPtr(const bool *b) {
155   ASSERT_TRUE(*b); // no-crash
156 
157   clang_analyzer_eval(*b); // expected-warning{{TRUE}}
158 }
159 
160 void testAssertSymbolicRef(const bool &b) {
161   ASSERT_TRUE(b); // no-crash
162 
163   clang_analyzer_eval(b); // expected-warning{{TRUE}}
164 }
165