123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279 |
- // Copyright 2014 The Chromium Authors. All rights reserved.
- // Use of this source code is governed by a BSD-style license that can be
- // found in the LICENSE file.
- #include "ppapi/tests/test_test_internals.h"
- #include <stdint.h>
- #include <vector>
- namespace {
- std::string CheckEqual(const std::string& expected, const std::string& actual) {
- if (expected != actual) {
- return std::string("Expected : \"") + expected + "\", got : \"" + actual +
- "\"";
- }
- PASS();
- }
- std::string Negate(const std::string& result) {
- if (result.empty())
- return std::string("FAIL: String was empty.");
- return std::string();
- }
- class CallCounter {
- public:
- CallCounter() : num_calls_(0) {}
- int return_zero() {
- ++num_calls_;
- return 0;
- }
- double return_zero_as_double() {
- ++num_calls_;
- return 0.0;
- }
- int num_calls() const { return num_calls_; }
- private:
- int num_calls_;
- };
- }
- REGISTER_TEST_CASE(TestInternals);
- bool TestTestInternals::Init() {
- return true;
- }
- void TestTestInternals::RunTests(const std::string& filter) {
- RUN_TEST(ToString, filter);
- RUN_TEST(PassingComparisons, filter);
- RUN_TEST(FailingComparisons, filter);
- RUN_TEST(EvaluateOnce, filter);
- }
- #define WRAP_LEFT_PARAM(a) \
- internal::ParameterWrapper<IS_NULL_LITERAL(a)>::WrapValue(a)
- std::string TestTestInternals::TestToString() {
- // We don't use most ASSERT macros here, because they rely on ToString.
- // ASSERT_SUBTEST_SUCCESS does not use ToString.
- ASSERT_SUBTEST_SUCCESS(CheckEqual(WRAP_LEFT_PARAM(NULL).ToString(), "0"));
- ASSERT_SUBTEST_SUCCESS(CheckEqual(WRAP_LEFT_PARAM(0).ToString(), "0"));
- ASSERT_SUBTEST_SUCCESS(CheckEqual(internal::ToString(5), "5"));
- int32_t x = 5;
- ASSERT_SUBTEST_SUCCESS(CheckEqual(internal::ToString(x + 1), "6"));
- std::string str = "blah";
- ASSERT_SUBTEST_SUCCESS(CheckEqual(internal::ToString(str + "blah"),
- "blahblah"));
- std::vector<int> vec;
- ASSERT_SUBTEST_SUCCESS(CheckEqual(internal::ToString(vec), std::string()));
- PASS();
- }
- #define COMPARE_DOUBLE_EQ(a, b) \
- internal::CompareDoubleEq( \
- internal::ParameterWrapper<IS_NULL_LITERAL(a)>::WrapValue(a), \
- (b), #a, #b, __FILE__, __LINE__)
- std::string TestTestInternals::TestPassingComparisons() {
- // These comparisons should all "pass", meaning they should return the empty
- // string.
- {
- const std::string* const kNull = NULL;
- const std::string* const kDeadBeef =
- reinterpret_cast<const std::string*>(0xdeadbeef);
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, NULL, kNull));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, kDeadBeef, kDeadBeef));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, NULL, kDeadBeef));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, kDeadBeef, kNull));
- } {
- const int64_t zero_int32 = 0;
- const int64_t zero_int64 = 0;
- const int32_t zero_uint32 = 0;
- const int64_t zero_uint64 = 0;
- const int32_t one_int32 = 1;
- const int64_t one_int64 = 1;
- const int32_t one_uint32 = 1;
- const int64_t one_uint64 = 1;
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, 0, zero_int32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, 0, zero_int64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, 0, zero_uint32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, 0, zero_uint64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, 1, one_int32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, 1, one_int64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, 1, one_uint32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(EQ, 1, one_uint64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, 1, zero_int32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, 1, zero_int64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, 1, zero_uint32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, 1, zero_uint64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, 0, one_int32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, 0, one_int64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, 0, one_uint32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(NE, 0, one_uint64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LT, 0, one_int32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LT, 0, one_uint32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LT, 0, one_int64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LT, 0, one_uint64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LE, 0, zero_int32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LE, 0, zero_uint32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LE, 0, zero_int64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LE, 0, zero_uint64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LE, 0, one_int32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LE, 0, one_uint32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LE, 0, one_int64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(LE, 0, one_uint64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GT, 1, zero_int32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GT, 1, zero_uint32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GT, 1, zero_int64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GT, 1, zero_uint64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GE, 1, zero_int32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GE, 1, zero_uint32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GE, 1, zero_int64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GE, 1, zero_uint64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GE, 1, one_int32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GE, 1, one_uint32));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GE, 1, one_int64));
- ASSERT_SUBTEST_SUCCESS(COMPARE_BINARY_INTERNAL(GE, 1, one_uint64));
- } {
- ASSERT_SUBTEST_SUCCESS(
- COMPARE_BINARY_INTERNAL(EQ, "hello", std::string("hello")));
- std::vector<int> int_vector1(10, 10);
- std::vector<int> int_vector2(int_vector1);
- ASSERT_SUBTEST_SUCCESS(
- COMPARE_BINARY_INTERNAL(EQ, int_vector1, int_vector2));
- } {
- const double kZeroDouble = 0.0;
- const double kPositiveDouble = 1.1;
- ASSERT_SUBTEST_SUCCESS(
- COMPARE_BINARY_INTERNAL(LT, kZeroDouble, kPositiveDouble));
- ASSERT_SUBTEST_SUCCESS(
- COMPARE_BINARY_INTERNAL(GT, kPositiveDouble, kZeroDouble));
- ASSERT_SUBTEST_SUCCESS(COMPARE_DOUBLE_EQ(0.0, kZeroDouble));
- ASSERT_SUBTEST_SUCCESS(COMPARE_DOUBLE_EQ(1.0 + 0.1, kPositiveDouble));
- }
- // TODO: Things that return non-empty string.
- // TODO: Test that the parameter is evaluated exactly once.
- PASS();
- }
- #define ASSERT_SUBTEST_FAILURE(param) ASSERT_SUBTEST_SUCCESS(Negate(param))
- std::string TestTestInternals::TestFailingComparisons() {
- // Note, we don't really worry about the content of failure strings here.
- // That's mostly covered by the ToString test above. This test just makes
- // sure that comparisons which should return a non-empty string do so.
- {
- const std::string* const kNull = NULL;
- const std::string* const kDeadBeef =
- reinterpret_cast<const std::string*>(0xdeadbeef);
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, NULL, kNull));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, kDeadBeef, kDeadBeef));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, NULL, kDeadBeef));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, kDeadBeef, kNull));
- }
- // Now, just make sure we get any non-empty string at all, which will indicate
- // test failure. We mostly rely on the ToString test to get the formats right.
- {
- const int64_t zero_int32 = 0;
- const int64_t zero_int64 = 0;
- const int32_t zero_uint32 = 0;
- const int64_t zero_uint64 = 0;
- const int32_t one_int32 = 1;
- const int64_t one_int64 = 1;
- const int32_t one_uint32 = 1;
- const int64_t one_uint64 = 1;
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, 1, zero_int32));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, 1, zero_int64));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, 1, zero_uint32));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, 1, zero_uint64));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, 0, one_int32));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, 0, one_int64));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, 0, one_uint32));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(EQ, 0, one_uint64));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, 0, zero_int32));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, 0, zero_int64));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, 0, zero_uint32));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, 0, zero_uint64));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, 1, one_int32));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, 1, one_int64));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, 1, one_uint32));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(NE, 1, one_uint64));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(LT, 1, one_int32));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(LT, 1, one_uint32));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(LT, 1, one_int64));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(LT, 1, one_uint64));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(LE, 1, zero_int32));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(LE, 1, zero_uint32));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(LE, 1, zero_int64));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(LE, 1, zero_uint64));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(GT, 0, zero_int32));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(GT, 0, zero_uint32));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(GT, 0, zero_int64));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(GT, 0, zero_uint64));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(GE, 0, one_int32));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(GE, 0, one_uint32));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(GE, 0, one_int64));
- ASSERT_SUBTEST_FAILURE(COMPARE_BINARY_INTERNAL(GE, 0, one_uint64));
- } {
- ASSERT_SUBTEST_FAILURE(
- COMPARE_BINARY_INTERNAL(EQ, "goodbye", std::string("hello")));
- std::vector<int> int_vector1(10, 10);
- std::vector<int> int_vector2;
- ASSERT_SUBTEST_FAILURE(
- COMPARE_BINARY_INTERNAL(EQ, int_vector1, int_vector2));
- } {
- const double kZeroDouble = 0.0;
- const double kPositiveDouble = 1.1;
- ASSERT_SUBTEST_FAILURE(
- COMPARE_BINARY_INTERNAL(GT, kZeroDouble, kPositiveDouble));
- ASSERT_SUBTEST_FAILURE(
- COMPARE_BINARY_INTERNAL(LT, kPositiveDouble, kZeroDouble));
- ASSERT_SUBTEST_FAILURE(COMPARE_DOUBLE_EQ(1.1, kZeroDouble));
- ASSERT_SUBTEST_FAILURE(COMPARE_DOUBLE_EQ(0.0, kPositiveDouble));
- }
- // TODO: Test that the parameter is evaluated exactly once.
- PASS();
- }
- #undef COMPARE
- #undef COMPARE_DOUBLE_EQ
- std::string TestTestInternals::TestEvaluateOnce() {
- // Make sure that the ASSERT macros only evaluate each parameter once.
- {
- CallCounter call_counter1;
- CallCounter call_counter2;
- ASSERT_EQ(call_counter1.return_zero(), call_counter2.return_zero());
- assert(call_counter1.num_calls() == 1);
- assert(call_counter2.num_calls() == 1);
- } {
- CallCounter call_counter1;
- CallCounter call_counter2;
- ASSERT_DOUBLE_EQ(call_counter1.return_zero_as_double(),
- call_counter2.return_zero_as_double());
- assert(call_counter1.num_calls() == 1);
- assert(call_counter2.num_calls() == 1);
- }
- PASS();
- }
|