// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef PPAPI_TESTS_TEST_CASE_H_
#define PPAPI_TESTS_TEST_CASE_H_
#include <stdint.h>
#include <cmath>
#include <limits>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include "ppapi/c/pp_resource.h"
#include "ppapi/c/pp_time.h"
#include "ppapi/c/private/ppb_testing_private.h"
#include "ppapi/cpp/message_loop.h"
#include "ppapi/cpp/view.h"
#include "ppapi/tests/test_utils.h"
#include "ppapi/tests/testing_instance.h"
#if (defined __native_client__)
#include "ppapi/cpp/var.h"
#else
#include "ppapi/cpp/private/var_private.h"
#endif
class TestingInstance;
namespace pp {
namespace deprecated {
class ScriptableObject;
}
}
// Individual classes of tests derive from this generic test case.
class TestCase {
public:
explicit TestCase(TestingInstance* instance);
virtual ~TestCase();
// Optionally override to do testcase specific initialization.
// Default implementation just returns true.
virtual bool Init();
// Override to implement the test case. It will be called after the plugin is
// first displayed, passing a string. If the string is empty, RunTests should
// run all tests for this test case. Otherwise, it must be a comma-delimited
// list of test names, possibly prefixed. E.g.:
// "Foo_GoodTest,DISABLED_Foo_BadTest,Foo_OtherGoodTest"
// All listed tests which are not prefixed will be run.
//
// This should generally be implemented in a TestCase subclass using the
// RUN_TEST* macros.
virtual void RunTests(const std::string& test_filter) = 0;
static std::string MakeFailureMessage(const char* file, int line,
const char* cmd);
#if !(defined __native_client__)
// Returns the scriptable test object for the current test, if any.
// Internally, this uses CreateTestObject which each test overrides.
pp::VarPrivate GetTestObject();
void ResetTestObject() { test_object_ = pp::VarPrivate(); }
#endif
// A function that is invoked whenever HandleMessage is called on the
// associated TestingInstance. Default implementation does nothing. TestCases
// that want to handle incoming postMessage events should override this
// method.
virtual void HandleMessage(const pp::Var& message_data);
// A function that is invoked whenever DidChangeView is called on the
// associated TestingInstance. Default implementation does nothing. TestCases
// that want to handle view changes should override this method.
virtual void DidChangeView(const pp::View& view);
// A function that is invoked whenever HandleInputEvent is called on the
// associated TestingInstance. Default implementation returns false. TestCases
// that want to handle view changes should override this method.
virtual bool HandleInputEvent(const pp::InputEvent& event);
void IgnoreLeakedVar(int64_t id);
TestingInstance* instance() { return instance_; }
const PPB_Testing_Private* testing_interface() { return testing_interface_; }
static void QuitMainMessageLoop(PP_Instance instance);
const std::map<std::string, bool>& remaining_tests() {
return remaining_tests_;
}
const std::set<std::string>& skipped_tests() {
return skipped_tests_;
}
protected:
#if !(defined __native_client__)
// Overridden by each test to supply a ScriptableObject corresponding to the
// test. There can only be one object created for all tests in a given class,
// so be sure your object is designed to be re-used.
//
// This object should be created on the heap. Ownership will be passed to the
// caller. Return NULL if there is no supported test object (the default).
virtual pp::deprecated::ScriptableObject* CreateTestObject();
#endif
// Checks whether the testing interface is available. Returns true if it is,
// false otherwise. If it is not available, adds a descriptive error. This is
// for use by tests that require the testing interface.
bool CheckTestingInterface();
// Makes sure the test is run over HTTP.
bool EnsureRunningOverHTTP();
// Returns true if |filter| only contains a TestCase name, which normally
// means "run all tests". Some TestCases require special setup for individual
// tests, and can use this function to decide whether to ignore those tests.
bool ShouldRunAllTests(const std::string& filter);
// Return true if the given test name matches the filter. This is true if
// (a) filter is empty or (b) test_name matches a test name listed in filter
// exactly.
bool ShouldRunTest(const std::string& test_name, const std::string& filter);
// Check for leaked resources and vars at the end of the test. If any exist,
// return a string with some information about the error. Otherwise, return
// an empty string.
//
// You should pass the error string from the test so far; if it is non-empty,
// CheckResourcesAndVars will do nothing and return the same string.
std::string CheckResourcesAndVars(std::string errors);
PP_TimeTicks NowInTimeTicks();
// Run the given test method on a background thread and return the result.
template <class T>
std::string RunOnThread(std::string(T::*test_to_run)()) {
if (!testing_interface_) {
return "Testing blocking callbacks requires the testing interface. In "
"Chrome, use the --enable-pepper-testing flag.";
}
// These tests are only valid if running out-of-process (threading is not
// supported in-process). For in-process, just consider it a pass.
if (!testing_interface_->IsOutOfProcess())
return std::string();
pp::MessageLoop background_loop(instance_);
ThreadedTestRunner<T> runner(instance_->pp_instance(),
static_cast<T*>(this), test_to_run, background_loop);
RunOnThreadInternal(&ThreadedTestRunner<T>::ThreadFunction, &runner,
testing_interface_);
return runner.result();
}
// Pointer to the instance that owns us.
TestingInstance* instance_;
// NULL unless InitTestingInterface is called.
const PPB_Testing_Private* testing_interface_;
void set_callback_type(CallbackType callback_type) {
callback_type_ = callback_type;
}
CallbackType callback_type() const {
return callback_type_;
}
private:
template <class T>
class ThreadedTestRunner {
public:
typedef std::string(T::*TestMethodType)();
ThreadedTestRunner(PP_Instance instance,
T* test_case,
TestMethodType test_to_run,
pp::MessageLoop loop)
: instance_(instance),
test_case_(test_case),
test_to_run_(test_to_run),
loop_(loop) {
}
const std::string& result() { return result_; }
static void ThreadFunction(void* runner) {
static_cast<ThreadedTestRunner<T>*>(runner)->Run();
}
private:
void Run() {
int32_t result = loop_.AttachToCurrentThread();
static_cast<void>(result); // result is not used in the RELEASE build.
PP_DCHECK(PP_OK == result);
result_ = (test_case_->*test_to_run_)();
// Now give the loop a chance to clean up.
loop_.PostQuit(true /* should_destroy */);
loop_.Run();
// Tell the main thread to quit its nested run loop, now that the test
// is complete.
TestCase::QuitMainMessageLoop(instance_);
}
std::string result_;
PP_Instance instance_;
T* test_case_;
TestMethodType test_to_run_;
pp::MessageLoop loop_;
};
// The internals for RunOnThread. This allows us to avoid including
// pp_thread.h in this header file, since it includes system headers like
// windows.h.
// RunOnThreadInternal launches a new thread to run |thread_func|, waits
// for it to complete using RunMessageLoop(), then joins.
void RunOnThreadInternal(void (*thread_func)(void*),
void* thread_param,
const PPB_Testing_Private* testing_interface);
static void DoQuitMainMessageLoop(void* pp_instance, int32_t result);
// Passed when creating completion callbacks in some tests. This determines
// what kind of callback we use for the test.
CallbackType callback_type_;
// Var ids that should be ignored when checking for leaks on shutdown.
std::set<int64_t> ignored_leaked_vars_;
// The tests that were found in test_filter. The bool indicates whether the
// test should be run (i.e., it will be false if the test name was prefixed in
// the test_filter string).
//
// This is initialized lazily the first time that ShouldRunTest is called.
std::map<std::string, bool> filter_tests_;
// Flag indicating whether we have populated filter_tests_ yet.
bool have_populated_filter_tests_;
// This is initialized with the contents of filter_tests_. As each test is
// run, it is removed from remaining_tests_. When RunTests is finished,
// remaining_tests_ should be empty. Any remaining tests are tests that were
// listed in the test_filter but didn't match any calls to ShouldRunTest,
// meaning it was probably a typo. TestingInstance should log this and
// consider it a failure.
std::map<std::string, bool> remaining_tests_;
// If ShouldRunTest is called but the given test name doesn't match anything
// in the test_filter, the test name will be added here. This allows
// TestingInstance to detect when not all tests were listed.
std::set<std::string> skipped_tests_;
#if !(defined __native_client__)
// Holds the test object, if any was retrieved from CreateTestObject.
pp::VarPrivate test_object_;
#endif
};
// This class is an implementation detail.
class TestCaseFactory {
public:
typedef TestCase* (*Method)(TestingInstance* instance);
TestCaseFactory(const char* name, Method method)
: next_(head_),
name_(name),
method_(method) {
head_ = this;
}
private:
friend class TestingInstance;
TestCaseFactory* next_;
const char* name_;
Method method_;
static TestCaseFactory* head_;
};
namespace internal {
// The internal namespace contains implementation details that are used by
// the ASSERT macros.
// This base class provides a ToString that works for classes that can be
// converted to a string using std::stringstream. Later, we'll do
// specializations for types that we know will work with this approach.
template <class T>
struct StringinatorBase {
static std::string ToString(const T& value) {
std::stringstream stream;
stream << value;
return stream.str();
}
protected:
// Not implemented, do not use.
// Note, these are protected because Windows complains if I make these private
// and then inherit StringinatorBase (even though they're never used).
StringinatorBase();
~StringinatorBase();
};
// This default class template is for types that we don't recognize as
// something we can convert into a string using stringstream. Types that we
// know *can* be turned to a string should have specializations below.
template <class T>
struct Stringinator {
static std::string ToString(const T& value) {
return std::string();
}
private:
// Not implemented, do not use.
Stringinator();
~Stringinator();
};
// Define some full specializations for types that can just use stringstream.
#define DEFINE_STRINGINATOR_FOR_TYPE(type) \
template <> \
struct Stringinator<type> : public StringinatorBase<type> {}
DEFINE_STRINGINATOR_FOR_TYPE(int32_t);
DEFINE_STRINGINATOR_FOR_TYPE(uint32_t);
DEFINE_STRINGINATOR_FOR_TYPE(int64_t);
DEFINE_STRINGINATOR_FOR_TYPE(uint64_t);
DEFINE_STRINGINATOR_FOR_TYPE(float);
DEFINE_STRINGINATOR_FOR_TYPE(double);
DEFINE_STRINGINATOR_FOR_TYPE(bool);
DEFINE_STRINGINATOR_FOR_TYPE(std::string);
#undef DEFINE_STRINGINATOR_FOR_TYPE
template <class T>
std::string ToString(const T& param) {
return Stringinator<T>::ToString(param);
}
// This overload is necessary to allow enum values (such as those from
// pp_errors.h, including PP_OK) to work. They won't automatically convert to
// an integral type to instantiate the above function template.
inline std::string ToString(int32_t param) {
return Stringinator<int32_t>::ToString(param);
}
inline std::string ToString(const char* c_string) {
return std::string(c_string);
}
// This overload deals with pointers.
template <class T>
std::string ToString(const T* ptr) {
uintptr_t ptr_val = reinterpret_cast<uintptr_t>(ptr);
std::stringstream stream;
stream << ptr_val;
return stream.str();
}
// ComparisonHelper classes wrap the left-hand parameter of a binary comparison
// ASSERT. The correct class gets chosen based on whether or not it's a NULL or
// 0 literal. If it is a NULL/0 literal, we use NullLiteralComparisonHelper.
// For all other parameters, we use ComparisonHelper. There's also a
// specialization of ComparisonHelper for int below (see below for why
// that is.)
//
// ComparisonHelper does two things for the left param:
// 1) Provides all the appropriate CompareXX functions (CompareEQ, etc).
// 2) Provides ToString.
template <class T>
struct ComparisonHelper {
explicit ComparisonHelper(const T& param) : value(param) {}
template <class U>
bool CompareEQ(const U& right) const {
return value == right;
}
template <class U>
bool CompareNE(const U& right) const {
return value != right;
}
template <class U>
bool CompareLT(const U& right) const {
return value < right;
}
template <class U>
bool CompareGT(const U& right) const {
return value > right;
}
template <class U>
bool CompareLE(const U& right) const {
return value <= right;
}
template <class U>
bool CompareGE(const U& right) const {
return value >= right;
}
std::string ToString() const {
return internal::ToString(value);
}
const T& value;
};
// Used for NULL or 0.
struct NullLiteralComparisonHelper {
NullLiteralComparisonHelper() : value(0) {}
template <class U>
bool CompareEQ(const U& right) const {
return 0 == right;
}
template <class U>
bool CompareNE(const U& right) const {
return 0 != right;
}
template <class U>
bool CompareLT(const U& right) const {
return 0 < right;
}
template <class U>
bool CompareGT(const U& right) const {
return 0 > right;
}
template <class U>
bool CompareLE(const U& right) const {
return 0 <= right;
}
template <class U>
bool CompareGE(const U& right) const {
return 0 >= right;
}
std::string ToString() const {
return std::string("0");
}
const int value;
};
// This class makes it safe to use an integer literal (like 5, or 123) when
// comparing with an unsigned. For example:
// ASSERT_EQ(1, some_vector.size());
// We do a lot of those comparisons, so this makes it easy to get it right
// (rather than forcing assertions to use unsigned literals like 5u or 123u).
//
// This is slightly risky; we're static_casting an int to whatever's on the
// right. If the left value is negative and the right hand side is a large
// unsigned value, it's possible that the comparison will succeed when maybe
// it shouldn't have.
// TODO(dmichael): It should be possible to fix this and upgrade int32_t and
// uint32_t to int64_t for the comparison, and make any unsafe
// comparisons into compile errors.
template <>
struct ComparisonHelper<int> {
explicit ComparisonHelper(int param) : value(param) {}
template <class U>
bool CompareEQ(const U& right) const {
return static_cast<U>(value) == right;
}
template <class U>
bool CompareNE(const U& right) const {
return static_cast<U>(value) != right;
}
template <class U>
bool CompareLT(const U& right) const {
return static_cast<U>(value) < right;
}
template <class U>
bool CompareGT(const U& right) const {
return static_cast<U>(value) > right;
}
template <class U>
bool CompareLE(const U& right) const {
return static_cast<U>(value) <= right;
}
template <class U>
bool CompareGE(const U& right) const {
return static_cast<U>(value) >= right;
}
std::string ToString() const {
return internal::ToString(value);
}
const int value;
private:
};
// The default is for the case there the parameter is *not* a NULL or 0 literal.
template <bool is_null_literal>
struct ParameterWrapper {
template <class T>
static ComparisonHelper<T> WrapValue(const T& value) {
return ComparisonHelper<T>(value);
}
// This overload is so that we can deal with values from anonymous enums,
// like the one in pp_errors.h. The function template above won't be
// considered a match by the compiler.
static ComparisonHelper<int> WrapValue(int value) {
return ComparisonHelper<int>(value);
}
};
// The parameter to WrapValue *is* a NULL or 0 literal.
template <>
struct ParameterWrapper<true> {
// We just use "..." and ignore the parameter. This sidesteps some problems we
// would run in to (not all compilers have the same set of constraints).
// - We can't use a pointer type, because int and enums won't convert.
// - We can't use an integral type, because pointers won't convert.
// - We can't overload, because it will sometimes be ambiguous.
// - We can't templatize and deduce the parameter. Some compilers will deduce
// int for NULL, and then refuse to convert NULL to an int.
//
// We know in this case that the value is 0, so there's no need to capture the
// value. We also know it's a fundamental type, so it's safe to pass to "...".
// (It's illegal to pass non-POD types to ...).
static NullLiteralComparisonHelper WrapValue(...) {
return NullLiteralComparisonHelper();
}
};
// IS_NULL_LITERAL(type) is a little template metaprogramming for determining
// if a type is a null or zero literal (NULL or 0 or a constant that evaluates
// to one of those).
// The idea is that for NULL or 0, any pointer type is always a better match
// than "...". But no other pointer types or literals should convert
// automatically to InternalDummyClass.
struct InternalDummyClass {};
char TestNullLiteral(const InternalDummyClass*);
struct BiggerThanChar { char dummy[2]; };
BiggerThanChar TestNullLiteral(...);
// If the compiler chooses the overload of TestNullLiteral which returns char,
// then we know the value converts automatically to InternalDummyClass*, which
// should only be true of NULL and 0 constants.
#define IS_NULL_LITERAL(a) sizeof(internal::TestNullLiteral(a)) == sizeof(char)
template <class T, class U>
static std::string MakeBinaryComparisonFailureMessage(
const char* comparator,
const T& left,
const U& right,
const char* left_precompiler_string,
const char* right_precompiler_string,
const char* file_name,
int line_number) {
std::string error_msg =
std::string("Failed ASSERT_") + comparator + "(" +
left_precompiler_string + ", " + right_precompiler_string + ")";
std::string left_string(left.ToString());
std::string right_string(ToString(right));
if (!left_string.empty())
error_msg += " Left: (" + left_string + ")";
if (!right_string.empty())
error_msg += " Right: (" + right_string + ")";
return TestCase::MakeFailureMessage(file_name, line_number,
error_msg.c_str());
}
// The Comparison function templates allow us to pass the parameter for
// ASSERT macros below and have them be evaluated only once. This is important
// for cases where the parameter might be an expression with side-effects, like
// a function call.
#define DEFINE_COMPARE_FUNCTION(comparator_name) \
template <class T, class U> \
std::string Compare ## comparator_name ( \
const T& left, \
const U& right, \
const char* left_precompiler_string, \
const char* right_precompiler_string, \
const char* file_name, \
int line_num) { \
if (!(left.Compare##comparator_name(right))) { \
return MakeBinaryComparisonFailureMessage(#comparator_name, \
left, \
right, \
left_precompiler_string, \
right_precompiler_string, \
file_name, \
line_num); \
} \
return std::string(); \
}
DEFINE_COMPARE_FUNCTION(EQ)
DEFINE_COMPARE_FUNCTION(NE)
DEFINE_COMPARE_FUNCTION(LT)
DEFINE_COMPARE_FUNCTION(LE)
DEFINE_COMPARE_FUNCTION(GT)
DEFINE_COMPARE_FUNCTION(GE)
#undef DEFINE_COMPARE_FUNCTION
inline std::string CompareDoubleEq(ComparisonHelper<double> left,
double right,
const char* left_precompiler_string,
const char* right_precompiler_string,
const char* file_name,
int linu_num) {
if (!(std::fabs(left.value - right) <=
std::numeric_limits<double>::epsilon())) {
return MakeBinaryComparisonFailureMessage(
"~=", left, right, left_precompiler_string, right_precompiler_string,
__FILE__, __LINE__);
}
return std::string();
}
} // namespace internal
// Use the REGISTER_TEST_CASE macro in your TestCase implementation file to
// register your TestCase. If your test is named TestFoo, then add the
// following to test_foo.cc:
//
// REGISTER_TEST_CASE(Foo);
//
// This will cause your test to be included in the set of known tests.
//
#define REGISTER_TEST_CASE(name) \
static TestCase* Test##name##_FactoryMethod(TestingInstance* instance) { \
return new Test##name(instance); \
} \
static TestCaseFactory g_Test##name_factory( \
#name, &Test##name##_FactoryMethod \
)
// Helper macro for calling functions implementing specific tests in the
// RunTest function. This assumes the function name is TestFoo where Foo is the
// test |name|.
#define RUN_TEST(name, test_filter) \
if (ShouldRunTest(#name, test_filter)) { \
set_callback_type(PP_OPTIONAL); \
PP_TimeTicks start_time(NowInTimeTicks()); \
instance_->LogTest(#name, \
CheckResourcesAndVars(Test##name()), \
start_time); \
}
// Like RUN_TEST above but forces functions taking callbacks to complete
// asynchronously on success or error.
#define RUN_TEST_FORCEASYNC(name, test_filter) \
if (ShouldRunTest(#name, test_filter)) { \
set_callback_type(PP_REQUIRED); \
PP_TimeTicks start_time(NowInTimeTicks()); \
instance_->LogTest(#name"ForceAsync", \
CheckResourcesAndVars(Test##name()), \
start_time); \
}
#define RUN_TEST_BLOCKING(test_case, name, test_filter) \
if (ShouldRunTest(#name, test_filter)) { \
set_callback_type(PP_BLOCKING); \
PP_TimeTicks start_time(NowInTimeTicks()); \
instance_->LogTest( \
#name"Blocking", \
CheckResourcesAndVars(RunOnThread(&test_case::Test##name)), \
start_time); \
}
#define RUN_TEST_BACKGROUND(test_case, name, test_filter) \
if (ShouldRunTest(#name, test_filter)) { \
PP_TimeTicks start_time(NowInTimeTicks()); \
instance_->LogTest( \
#name"Background", \
CheckResourcesAndVars(RunOnThread(&test_case::Test##name)), \
start_time); \
}
#define RUN_TEST_FORCEASYNC_AND_NOT(name, test_filter) \
do { \
RUN_TEST_FORCEASYNC(name, test_filter); \
RUN_TEST(name, test_filter); \
} while (false)
// Run a test with all possible callback types.
#define RUN_CALLBACK_TEST(test_case, name, test_filter) \
do { \
RUN_TEST_FORCEASYNC(name, test_filter); \
RUN_TEST(name, test_filter); \
RUN_TEST_BLOCKING(test_case, name, test_filter); \
RUN_TEST_BACKGROUND(test_case, name, test_filter); \
} while (false)
#define RUN_TEST_WITH_REFERENCE_CHECK(name, test_filter) \
if (ShouldRunTest(#name, test_filter)) { \
set_callback_type(PP_OPTIONAL); \
uint32_t objects = testing_interface_->GetLiveObjectsForInstance( \
instance_->pp_instance()); \
std::string error_message = Test##name(); \
if (error_message.empty() && \
testing_interface_->GetLiveObjectsForInstance( \
instance_->pp_instance()) != objects) \
error_message = MakeFailureMessage(__FILE__, __LINE__, \
"reference leak check"); \
PP_TimeTicks start_time(NowInTimeTicks()); \
instance_->LogTest(#name, \
CheckResourcesAndVars(error_message), \
start_time); \
}
// TODO(dmichael): Add CheckResourcesAndVars above when Windows tests pass
// cleanly. crbug.com/173503
// Helper macros for checking values in tests, and returning a location
// description of the test fails.
#define ASSERT_TRUE(cmd) \
do { \
if (!(cmd)) \
return MakeFailureMessage(__FILE__, __LINE__, #cmd); \
} while (false)
#define ASSERT_FALSE(cmd) ASSERT_TRUE(!(cmd))
#define COMPARE_BINARY_INTERNAL(comparison_type, a, b) \
internal::Compare##comparison_type( \
internal::ParameterWrapper<IS_NULL_LITERAL(a)>::WrapValue(a), \
(b), \
#a, \
#b, \
__FILE__, \
__LINE__)
#define ASSERT_BINARY_INTERNAL(comparison_type, a, b) \
do { \
std::string internal_assert_result_string = \
COMPARE_BINARY_INTERNAL(comparison_type, a, b); \
if (!internal_assert_result_string.empty()) { \
return internal_assert_result_string; \
} \
} while(false)
#define ASSERT_EQ(a, b) ASSERT_BINARY_INTERNAL(EQ, a, b)
#define ASSERT_NE(a, b) ASSERT_BINARY_INTERNAL(NE, a, b)
#define ASSERT_LT(a, b) ASSERT_BINARY_INTERNAL(LT, a, b)
#define ASSERT_LE(a, b) ASSERT_BINARY_INTERNAL(LE, a, b)
#define ASSERT_GT(a, b) ASSERT_BINARY_INTERNAL(GT, a, b)
#define ASSERT_GE(a, b) ASSERT_BINARY_INTERNAL(GE, a, b)
#define ASSERT_DOUBLE_EQ(a, b) \
do { \
std::string internal_assert_result_string = \
internal::CompareDoubleEq( \
internal::ParameterWrapper<IS_NULL_LITERAL(a)>::WrapValue(a), \
(b), \
#a, \
#b, \
__FILE__, \
__LINE__); \
if (!internal_assert_result_string.empty()) { \
return internal_assert_result_string; \
} \
} while(false)
// Runs |function| as a subtest and asserts that it has passed.
#define ASSERT_SUBTEST_SUCCESS(function) \
do { \
std::string result = (function); \
if (!result.empty()) \
return TestCase::MakeFailureMessage(__FILE__, __LINE__, result.c_str()); \
} while (false)
#define PASS() return std::string()
#endif // PPAPI_TESTS_TEST_CASE_H_
Codebase Browser
chromium