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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
// Copyright (c) 2011 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"
#if (defined __native_client__)
#include "ppapi/cpp/var.h"
#else
#include "ppapi/cpp/private/var_private.h"
#endif
struct PPB_Testing_Dev;
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.
virtual bool Init() { return true; }
// Override to implement the test. It will be called after the plugin is
// first displayed.
virtual void RunTest() = 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();
#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);
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 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();
#endif
// 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_;
// NULL unless InitTestingInterface is called.
const PPB_Testing_Dev* testing_interface_;
// Force asynchronous completion of any operation taking a callback.
bool force_async_;
private:
#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_;
};
// 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) \
force_async_ = false; \
instance_->LogTest(#name, Test##name());
// Like RUN_TEST above but forces functions taking callbacks to complete
// asynchronously on success or error.
#define RUN_TEST_FORCEASYNC(name) \
force_async_ = true; \
instance_->LogTest(#name"ForceAsync", Test##name());
#define RUN_TEST_FORCEASYNC_AND_NOT(name) \
RUN_TEST_FORCEASYNC(name); \
RUN_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_
|
