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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
|
#pragma once
#include <string>
#include <vector>
#include <set>
#include <map>
#include <iostream>
#include <stdio.h>
#include "meta.h"
#include "util.h"
// define some common lists of types
typedef unittest::type_list<int,
unsigned int,
float> ThirtyTwoBitTypes;
typedef unittest::type_list<long long,
unsigned long long,
double> SixtyFourBitTypes;
typedef unittest::type_list<char,
signed char,
unsigned char,
short,
unsigned short,
int,
unsigned int,
long,
unsigned long,
long long,
unsigned long long> IntegralTypes;
typedef unittest::type_list<signed char,
signed short,
signed int,
signed long,
signed long long> SignedIntegralTypes;
typedef unittest::type_list<unsigned char,
unsigned short,
unsigned int,
unsigned long,
unsigned long long> UnsignedIntegralTypes;
typedef unittest::type_list<char,
signed char,
unsigned char> ByteTypes;
typedef unittest::type_list<char,
signed char,
unsigned char,
short,
unsigned short> SmallIntegralTypes;
typedef unittest::type_list<long long,
unsigned long long> LargeIntegralTypes;
typedef unittest::type_list<float,
double> FloatingPointTypes;
typedef unittest::type_list<char,
signed char,
unsigned char,
short,
unsigned short,
int,
unsigned int,
long,
unsigned long,
long long,
unsigned long long,
float> NumericTypes;
// exclude double from NumericTypes
inline void chop_prefix(std::string& str, const std::string& prefix)
{
str.replace(str.find(prefix) == 0 ? 0 : str.size(), prefix.size(), "");
}
inline std::string base_class_name(const std::string& name)
{
std::string result = name;
// if the name begins with "struct ", chop it off
chop_prefix(result, "struct ");
// if the name begins with "class ", chop it off
chop_prefix(result, "class ");
// chop everything including and after first "<"
return result.replace(result.find_first_of("<"),
result.size(),
"");
}
enum TestStatus { Pass = 0, Failure = 1, KnownFailure = 2, Error = 3, UnknownException = 4};
typedef std::set<std::string> ArgumentSet;
typedef std::map<std::string, std::string> ArgumentMap;
std::vector<size_t> get_test_sizes(void);
void set_test_sizes(const std::string&);
class UnitTest {
public:
std::string name;
UnitTest() {}
UnitTest(const char * name);
virtual ~UnitTest() {}
virtual void run() {}
bool operator<(const UnitTest& u) const
{
return name < u.name;
}
};
class UnitTestDriver
{
typedef std::map<std::string, UnitTest*> TestMap;
TestMap test_map;
bool run_tests(std::vector<UnitTest *>& tests_to_run, const ArgumentMap& kwargs);
public:
void register_test(UnitTest * test);
bool run_tests(const ArgumentSet& args, const ArgumentMap& kwargs);
void list_tests(void);
static UnitTestDriver &s_driver();
};
// Macro to create a single unittest
#define DECLARE_UNITTEST(TEST) \
class TEST##UnitTest : public UnitTest { \
public: \
TEST##UnitTest() : UnitTest(#TEST) {} \
void run(){ \
TEST(); \
} \
}; \
TEST##UnitTest TEST##Instance
// Macro to create host and device versions of a
// unit test for a couple data types
#define DECLARE_VECTOR_UNITTEST(VTEST) \
void VTEST##Host(void) { VTEST< thrust::host_vector<short> >(); VTEST< thrust::host_vector<int> >(); } \
void VTEST##Device(void) { VTEST< thrust::device_vector<short> >(); VTEST< thrust::device_vector<int> >(); } \
DECLARE_UNITTEST(VTEST##Host); \
DECLARE_UNITTEST(VTEST##Device);
// Macro to create instances of a test for several
// data types and array sizes
#define DECLARE_VARIABLE_UNITTEST(TEST) \
class TEST##UnitTest : public UnitTest { \
public: \
TEST##UnitTest() : UnitTest(#TEST) {} \
void run() \
{ \
std::vector<size_t> sizes = get_test_sizes(); \
for(size_t i = 0; i != sizes.size(); ++i) \
{ \
TEST<char>(sizes[i]); \
TEST<unsigned char>(sizes[i]); \
TEST<short>(sizes[i]); \
TEST<unsigned short>(sizes[i]); \
TEST<int>(sizes[i]); \
TEST<unsigned int>(sizes[i]); \
TEST<float>(sizes[i]); \
} \
} \
}; \
TEST##UnitTest TEST##Instance
template<template <typename> class TestName, typename TypeList>
class SimpleUnitTest : public UnitTest
{
public:
SimpleUnitTest()
: UnitTest(base_class_name(unittest::type_name<TestName<int> >()).c_str()) {}
void run()
{
// get the first type in the list
typedef typename unittest::get_type<TypeList,0>::type first_type;
unittest::for_each_type<TypeList,TestName,first_type,0> for_each;
// loop over the types
for_each();
}
}; // end SimpleUnitTest
template<template <typename> class TestName, typename TypeList>
class VariableUnitTest : public UnitTest
{
public:
VariableUnitTest()
: UnitTest(base_class_name(unittest::type_name<TestName<int> >()).c_str()) {}
void run()
{
std::vector<size_t> sizes = get_test_sizes();
for(size_t i = 0; i != sizes.size(); ++i)
{
// get the first type in the list
typedef typename unittest::get_type<TypeList,0>::type first_type;
unittest::for_each_type<TypeList,TestName,first_type,0> loop;
// loop over the types
loop(sizes[i]);
}
}
}; // end VariableUnitTest
template<template <typename> class TestName,
typename TypeList,
template <typename, typename> class Vector,
template <typename> class Alloc>
struct VectorUnitTest
: public UnitTest
{
VectorUnitTest()
: UnitTest((base_class_name(unittest::type_name<TestName< Vector<int, Alloc<int> > > >()) + "<" +
base_class_name(unittest::type_name<Vector<int, Alloc<int> > >()) + ">").c_str())
{ }
void run()
{
// zip up the type list with Alloc
typedef typename unittest::transform1<TypeList, Alloc>::type AllocList;
// zip up the type list & alloc list with Vector
typedef typename unittest::transform2<TypeList, AllocList, Vector>::type VectorList;
// get the first type in the list
typedef typename unittest::get_type<VectorList,0>::type first_type;
unittest::for_each_type<VectorList,TestName,first_type,0> loop;
// loop over the types
loop(0);
}
}; // end VectorUnitTest
|
