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
9namespace {
10
11std::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
19std::string Negate(const std::string& result) {
20  if (result.empty())
21    return std::string("FAIL: String was empty.");
22  return std::string();
23}
24
25class CallCounter {
26 public:
27  CallCounter() : num_calls_(0) {}
28
29  int return_zero() {
30    ++num_calls_;
31    return 0;
32  }
33  double return_zero_as_double() {
34    ++num_calls_;
35    return 0.0;
36  }
37
38  int num_calls() const { return num_calls_; }
39
40 private:
41  int num_calls_;
42};
43
44}
45
46REGISTER_TEST_CASE(TestInternals);
47
48bool TestTestInternals::Init() {
49  return true;
50}
51
52void 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)
61std::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__)
82std::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))
173std::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
259std::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