1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "ppapi/tests/test_test_internals.h"
6
7 #include <vector>
8
9 namespace {
10
CheckEqual(const std::string & expected,const std::string & actual)11 std::string CheckEqual(const std::string& expected, const std::string& actual) {
12 if (expected != actual) {
13 return std::string("Expected : \"") + expected + "\", got : \"" + actual +
14 "\"";
15 }
16 PASS();
17 }
18
Negate(const std::string & result)19 std::string Negate(const std::string& result) {
20 if (result.empty())
21 return std::string("FAIL: String was empty.");
22 return std::string();
23 }
24
25 class CallCounter {
26 public:
CallCounter()27 CallCounter() : num_calls_(0) {}
28
return_zero()29 int return_zero() {
30 ++num_calls_;
31 return 0;
32 }
return_zero_as_double()33 double return_zero_as_double() {
34 ++num_calls_;
35 return 0.0;
36 }
37
num_calls() const38 int num_calls() const { return num_calls_; }
39
40 private:
41 int num_calls_;
42 };
43
44 }
45
46 REGISTER_TEST_CASE(TestInternals);
47
Init()48 bool TestTestInternals::Init() {
49 return true;
50 }
51
RunTests(const std::string & filter)52 void TestTestInternals::RunTests(const std::string& filter) {
53 RUN_TEST(ToString, filter);
54 RUN_TEST(PassingComparisons, filter);
55 RUN_TEST(FailingComparisons, filter);
56 RUN_TEST(EvaluateOnce, filter);
57 }
58
59 #define WRAP_LEFT_PARAM(a) \
60 internal::ParameterWrapper<IS_NULL_LITERAL(a)>::WrapValue(a)
TestToString()61 std::string TestTestInternals::TestToString() {
62 // We don't use most ASSERT macros here, because they rely on ToString.
63 // ASSERT_SUBTEST_SUCCESS does not use ToString.
64 ASSERT_SUBTEST_SUCCESS(CheckEqual(WRAP_LEFT_PARAM(NULL).ToString(), "0"));
65 ASSERT_SUBTEST_SUCCESS(CheckEqual(WRAP_LEFT_PARAM(0).ToString(), "0"));
66 ASSERT_SUBTEST_SUCCESS(CheckEqual(internal::ToString(5), "5"));
67 int32_t x = 5;
68 ASSERT_SUBTEST_SUCCESS(CheckEqual(internal::ToString(x + 1), "6"));
69 std::string str = "blah";
70 ASSERT_SUBTEST_SUCCESS(CheckEqual(internal::ToString(str + "blah"),
71 "blahblah"));
72 std::vector<int> vec;
73 ASSERT_SUBTEST_SUCCESS(CheckEqual(internal::ToString(vec), std::string()));
74
75 PASS();
76 }
77
78 #define COMPARE_DOUBLE_EQ(a, b) \
79 internal::CompareDoubleEq( \
80 internal::ParameterWrapper<IS_NULL_LITERAL(a)>::WrapValue(a), \
81 (b), #a, #b, __FILE__, __LINE__)
TestPassingComparisons()82 std::string TestTestInternals::TestPassingComparisons() {
83 // These comparisons should all "pass", meaning they should return the empty
84 // string.
85 {
86 const std::string* const kNull = NULL;
87 const std::string* const kDeadBeef =
88 reinterpret_cast<const std::string*>(0xdeadbeef);
89 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, NULL, kNull));
90 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, kDeadBeef, kDeadBeef));
91 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, NULL, kDeadBeef));
92 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, kDeadBeef, kNull));
93 } {
94 const int64_t zero_int32 = 0;
95 const int64_t zero_int64 = 0;
96 const int32_t zero_uint32 = 0;
97 const int64_t zero_uint64 = 0;
98 const int32_t one_int32 = 1;
99 const int64_t one_int64 = 1;
100 const int32_t one_uint32 = 1;
101 const int64_t one_uint64 = 1;
102 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, 0, zero_int32));
103 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, 0, zero_int64));
104 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, 0, zero_uint32));
105 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, 0, zero_uint64));
106 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, 1, one_int32));
107 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, 1, one_int64));
108 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, 1, one_uint32));
109 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, 1, one_uint64));
110
111 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, 1, zero_int32));
112 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, 1, zero_int64));
113 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, 1, zero_uint32));
114 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, 1, zero_uint64));
115 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, 0, one_int32));
116 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, 0, one_int64));
117 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, 0, one_uint32));
118 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, 0, one_uint64));
119
120 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LT, 0, one_int32));
121 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LT, 0, one_uint32));
122 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LT, 0, one_int64));
123 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LT, 0, one_uint64));
124
125 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LE, 0, zero_int32));
126 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LE, 0, zero_uint32));
127 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LE, 0, zero_int64));
128 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LE, 0, zero_uint64));
129
130 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LE, 0, one_int32));
131 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LE, 0, one_uint32));
132 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LE, 0, one_int64));
133 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LE, 0, one_uint64));
134
135 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GT, 1, zero_int32));
136 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GT, 1, zero_uint32));
137 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GT, 1, zero_int64));
138 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GT, 1, zero_uint64));
139
140 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GE, 1, zero_int32));
141 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GE, 1, zero_uint32));
142 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GE, 1, zero_int64));
143 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GE, 1, zero_uint64));
144
145 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GE, 1, one_int32));
146 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GE, 1, one_uint32));
147 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GE, 1, one_int64));
148 ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GE, 1, one_uint64));
149 } {
150 ASSERT_SUBTEST_SUCCESS(
151 COMPARE_BINARY_INTERNAL(EQ, "hello", std::string("hello")));
152 std::vector<int> int_vector1(10, 10);
153 std::vector<int> int_vector2(int_vector1);
154 ASSERT_SUBTEST_SUCCESS(
155 COMPARE_BINARY_INTERNAL(EQ, int_vector1, int_vector2));
156 } {
157 const double kZeroDouble = 0.0;
158 const double kPositiveDouble = 1.1;
159 ASSERT_SUBTEST_SUCCESS(
160 COMPARE_BINARY_INTERNAL(LT, kZeroDouble, kPositiveDouble));
161 ASSERT_SUBTEST_SUCCESS(
162 COMPARE_BINARY_INTERNAL(GT, kPositiveDouble, kZeroDouble));
163 ASSERT_SUBTEST_SUCCESS(COMPARE_DOUBLE_EQ(0.0, kZeroDouble));
164 ASSERT_SUBTEST_SUCCESS(COMPARE_DOUBLE_EQ(1.0 + 0.1, kPositiveDouble));
165 }
166
167 // TODO: Things that return non-empty string.
168 // TODO: Test that the parameter is evaluated exactly once.
169 PASS();
170 }
171
172 #define ASSERT_SUBTEST_FAILURE(param) ASSERT_SUBTEST_SUCCESS(Negate(param))
TestFailingComparisons()173 std::string TestTestInternals::TestFailingComparisons() {
174 // Note, we don't really worry about the content of failure strings here.
175 // That's mostly covered by the ToString test above. This test just makes
176 // sure that comparisons which should return a non-empty string do so.
177 {
178 const std::string* const kNull = NULL;
179 const std::string* const kDeadBeef =
180 reinterpret_cast<const std::string*>(0xdeadbeef);
181 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, NULL, kNull));
182 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, kDeadBeef, kDeadBeef));
183 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, NULL, kDeadBeef));
184 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, kDeadBeef, kNull));
185 }
186
187 // Now, just make sure we get any non-empty string at all, which will indicate
188 // test failure. We mostly rely on the ToString test to get the formats right.
189 {
190 const int64_t zero_int32 = 0;
191 const int64_t zero_int64 = 0;
192 const int32_t zero_uint32 = 0;
193 const int64_t zero_uint64 = 0;
194 const int32_t one_int32 = 1;
195 const int64_t one_int64 = 1;
196 const int32_t one_uint32 = 1;
197 const int64_t one_uint64 = 1;
198 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, 1, zero_int32));
199 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, 1, zero_int64));
200 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, 1, zero_uint32));
201 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, 1, zero_uint64));
202 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, 0, one_int32));
203 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, 0, one_int64));
204 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, 0, one_uint32));
205 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, 0, one_uint64));
206
207 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, 0, zero_int32));
208 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, 0, zero_int64));
209 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, 0, zero_uint32));
210 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, 0, zero_uint64));
211 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, 1, one_int32));
212 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, 1, one_int64));
213 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, 1, one_uint32));
214 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, 1, one_uint64));
215
216 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(LT, 1, one_int32));
217 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(LT, 1, one_uint32));
218 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(LT, 1, one_int64));
219 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(LT, 1, one_uint64));
220
221 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(LE, 1, zero_int32));
222 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(LE, 1, zero_uint32));
223 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(LE, 1, zero_int64));
224 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(LE, 1, zero_uint64));
225
226 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(GT, 0, zero_int32));
227 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(GT, 0, zero_uint32));
228 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(GT, 0, zero_int64));
229 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(GT, 0, zero_uint64));
230
231 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(GE, 0, one_int32));
232 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(GE, 0, one_uint32));
233 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(GE, 0, one_int64));
234 ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(GE, 0, one_uint64));
235 } {
236 ASSERT_SUBTEST_FAILURE(
237 COMPARE_BINARY_INTERNAL(EQ, "goodbye", std::string("hello")));
238 std::vector<int> int_vector1(10, 10);
239 std::vector<int> int_vector2;
240 ASSERT_SUBTEST_FAILURE(
241 COMPARE_BINARY_INTERNAL(EQ, int_vector1, int_vector2));
242 } {
243 const double kZeroDouble = 0.0;
244 const double kPositiveDouble = 1.1;
245 ASSERT_SUBTEST_FAILURE(
246 COMPARE_BINARY_INTERNAL(GT, kZeroDouble, kPositiveDouble));
247 ASSERT_SUBTEST_FAILURE(
248 COMPARE_BINARY_INTERNAL(LT, kPositiveDouble, kZeroDouble));
249 ASSERT_SUBTEST_FAILURE(COMPARE_DOUBLE_EQ(1.1, kZeroDouble));
250 ASSERT_SUBTEST_FAILURE(COMPARE_DOUBLE_EQ(0.0, kPositiveDouble));
251 }
252
253 // TODO: Test that the parameter is evaluated exactly once.
254 PASS();
255 }
256 #undef COMPARE
257 #undef COMPARE_DOUBLE_EQ
258
TestEvaluateOnce()259 std::string TestTestInternals::TestEvaluateOnce() {
260 // Make sure that the ASSERT macros only evaluate each parameter once.
261 {
262 CallCounter call_counter1;
263 CallCounter call_counter2;
264 ASSERT_EQ(call_counter1.return_zero(), call_counter2.return_zero());
265 assert(call_counter1.num_calls() == 1);
266 assert(call_counter2.num_calls() == 1);
267 } {
268 CallCounter call_counter1;
269 CallCounter call_counter2;
270 ASSERT_DOUBLE_EQ(call_counter1.return_zero_as_double(),
271 call_counter2.return_zero_as_double());
272 assert(call_counter1.num_calls() == 1);
273 assert(call_counter2.num_calls() == 1);
274 }
275 PASS();
276 }
277
278