1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
// Copyright (c) 2010 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.
#ifndef PPAPI_TESTS_TEST_CASE_H_
#define PPAPI_TESTS_TEST_CASE_H_
#include <cmath>
#include <limits>
#include <string>
#include "ppapi/c/pp_resource.h"
#include "ppapi/cpp/dev/scrollbar_dev.h"
#include "ppapi/cpp/var.h"
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) : instance_(instance) {}
virtual ~TestCase() {}
// Optionally override to do testcase specific initialization.
virtual bool Init() { return true; }
// Override to implement the test. It will be called after the plugin is
// first displayed.
virtual void RunTest() = 0;
std::string MakeFailureMessage(const char* file, int line, const char* cmd);
// Returns the scriptable test object for the current test, if any.
// Internally, this uses CreateTestObject which each test overrides.
pp::Var GetTestObject();
// 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);
protected:
// Overridden by each test to supply a ScriptableObject corresponding to the
// test. There can only be one object created for all test 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();
// Initializes the testing interface.
bool InitTestingInterface();
// Makes sure the test is run over HTTP.
bool EnsureRunningOverHTTP();
// Pointer to the instance that owns us.
TestingInstance* instance_;
private:
// Holds the test object, if any was retrieved from CreateTestObject.
pp::Var test_object_;
};
// 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_;
};
// 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) \
instance_->LogTest(#name, Test##name());
// Helper macros for checking values in tests, and returning a location
// description of the test fails.
#define ASSERT_TRUE(cmd) \
if (!(cmd)) { \
return MakeFailureMessage(__FILE__, __LINE__, #cmd); \
}
#define ASSERT_FALSE(cmd) ASSERT_TRUE(!(cmd))
#define ASSERT_EQ(a, b) ASSERT_TRUE((a) == (b))
#define ASSERT_NE(a, b) ASSERT_TRUE((a) != (b))
#define ASSERT_DOUBLE_EQ(a, b) ASSERT_TRUE( \
std::fabs((a)-(b)) <= std::numeric_limits<double>::epsilon())
#define PASS() return std::string()
#endif // PPAPI_TESTS_TEST_CASE_H_
|
