test_test_internals.cc 12 KB

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