nlib
ParamValue.h
Go to the documentation of this file.
1 
2 #pragma once
3 #ifndef INCLUDE_NN_NLIB_TESTING_PARAMVALUE_H_
4 #define INCLUDE_NN_NLIB_TESTING_PARAMVALUE_H_
5 
6 #include "nn/nlib/Config.h"
8 #include "nn/nlib/testing/ParamValueTypes.h"
9 #include "nn/nlib/UniquePtr.h"
10 #include "nn/nlib/Nlist.h"
11 
12 #if defined(_MSC_VER) && defined(nx_testing_EXPORTS)
13 #undef NLIB_VIS_PUBLIC
14 #define NLIB_VIS_PUBLIC NLIB_WINEXPORT
15 #endif
16 
17 NLIB_NAMESPACE_BEGIN
18 namespace testing {
19 
20 class NLIB_VIS_PUBLIC TestWithParamBase : public Test {
21  public:
22  virtual void TestBody() NLIB_OVERRIDE;
23 
24  private:
25  virtual void TestBodySub() = 0;
26  virtual bool SetParam(size_t i) = 0;
27 };
28 
29 template <class T>
30 class TestWithParam : public TestWithParamBase {
31  public:
32  typedef T ParamType;
33  TestWithParam() : param_(NULL) {}
34  const ParamType& GetParam() const { return *param_; }
35  static Nlist<ParamType>* GetParams() { return &param_vec_; }
36 
37  private:
38  virtual bool SetParam(size_t i) NLIB_OVERRIDE;
39 
40  private:
41  const ParamType* param_;
42  static Nlist<ParamType> param_vec_;
43 
44  NLIB_DISALLOW_COPY_AND_ASSIGN(TestWithParam);
45 };
46 
47 template <class T>
48 bool TestWithParam<T>::SetParam(size_t i) {
49  if (i < param_vec_.size()) {
50  param_ = &param_vec_[i];
51  return true;
52  }
53  return false;
54 }
55 
56 template <>
57 NLIB_VIS_PUBLIC bool TestWithParam<bool>::SetParam(size_t i);
58 
59 template <class T>
60 Nlist<T> TestWithParam<T>::param_vec_;
61 
62 class NLIB_VIS_PUBLIC TestParamAdderBase {
63  public:
64  virtual ~TestParamAdderBase() {}
65  virtual void AddParams() = 0;
66 
67  protected:
68  TestParamAdderBase() {}
69 
70  private:
71  NLIB_DISALLOW_COPY_AND_ASSIGN(TestParamAdderBase);
72 };
73 
74 class NLIB_VIS_PUBLIC TestParamAdderList {
75  public:
76  static void AddParams();
77  static void AddTestParamAdder(TestParamAdderBase* v);
78 
79  public:
80  TestParamAdderList() {}
81  ~TestParamAdderList() {}
82 
83  private:
84  static TestParamAdderBase* adder_list_[1024];
85  static int adder_list_idx_;
86 
87  NLIB_DISALLOW_COPY_AND_ASSIGN(TestParamAdderList);
88 };
89 
90 inline detail::ValuesBool Bool() { return detail::ValuesBool(); }
91 
92 template <class C, size_t N>
93 detail::ValuesInObjArray<C, N> ValuesIn(const C (&a)[N]) {
94  return detail::ValuesInObjArray<C, N>(a);
95 }
96 
97 template <class Container>
98 detail::ValuesInObjContainer<Container> ValuesIn(const Container& c) {
99  return detail::ValuesInObjContainer<Container>(c);
100 }
101 
102 template <class Iterator>
103 detail::ValuesInObjIterator<Iterator> ValuesIn(Iterator first, Iterator last) {
104  return detail::ValuesInObjIterator<Iterator>(first, last);
105 }
106 
107 template <class T>
108 detail::ValuesRange<T, T> Range(T first, T last) {
109  return detail::ValuesRange<T, T>(first, last, T(1));
110 }
111 
112 template <class T, class S>
113 detail::ValuesRange<T, S> Range(T first, T last, S step) {
114  return detail::ValuesRange<T, S>(first, last, step);
115 }
116 
117 template <class T1>
118 detail::Values1<T1> Values(T1 v1) {
119  return detail::Values1<T1>(v1);
120 }
121 
122 template <class T1, class T2>
123 detail::Values2<T1, T2> Values(T1 v1, T2 v2) {
124  return detail::Values2<T1, T2>(v1, v2);
125 }
126 
127 template <class T1, class T2, class T3>
128 detail::Values3<T1, T2, T3> Values(T1 v1, T2 v2, T3 v3) {
129  return detail::Values3<T1, T2, T3>(v1, v2, v3);
130 }
131 
132 template <class T1, class T2, class T3, class T4>
133 detail::Values4<T1, T2, T3, T4> Values(T1 v1, T2 v2, T3 v3, T4 v4) {
134  return detail::Values4<T1, T2, T3, T4>(v1, v2, v3, v4);
135 }
136 
137 template <class T1, class T2, class T3, class T4, class T5>
138 detail::Values5<T1, T2, T3, T4, T5> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
139  return detail::Values5<T1, T2, T3, T4, T5>(v1, v2, v3, v4, v5);
140 }
141 
142 template <class T1, class T2, class T3, class T4, class T5, class T6>
143 detail::Values6<T1, T2, T3, T4, T5, T6> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) {
144  return detail::Values6<T1, T2, T3, T4, T5, T6>(v1, v2, v3, v4, v5, v6);
145 }
146 
147 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
148 detail::Values7<T1, T2, T3, T4, T5, T6, T7> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
149  T7 v7) {
150  return detail::Values7<T1, T2, T3, T4, T5, T6, T7>(v1, v2, v3, v4, v5, v6, v7);
151 }
152 
153 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
154 detail::Values8<T1, T2, T3, T4, T5, T6, T7, T8> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
155  T7 v7, T8 v8) {
156  return detail::Values8<T1, T2, T3, T4, T5, T6, T7, T8>(v1, v2, v3, v4, v5, v6, v7, v8);
157 }
158 
159 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
160 detail::Values9<T1, T2, T3, T4, T5, T6, T7, T8, T9> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
161  T7 v7, T8 v8, T9 v9) {
162  return detail::Values9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(v1, v2, v3, v4, v5, v6, v7, v8, v9);
163 }
164 
165 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9,
166  class T10>
167 detail::Values10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
168  T6 v6, T7 v7, T8 v8, T9 v9,
169  T10 v10) {
170  return detail::Values10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(v1, v2, v3, v4, v5, v6, v7, v8,
171  v9, v10);
172 }
173 
174 } // namespace testing
175 NLIB_NAMESPACE_END
176 
177 #define TEST_P(test_case, test_name) \
178 class NLIB_TESTING_CLASS_NAME_(test_case, test_name) \
179  : public test_case { \
180 public: \
181  NLIB_TESTING_CLASS_NAME_(test_case, test_name)() {} \
182 private: \
183  virtual void TestBodySub(); \
184  static ::nlib_ns::testing::TestInfo* info_; \
185  NLIB_DISALLOW_COPY_AND_ASSIGN(NLIB_TESTING_CLASS_NAME_(test_case, test_name)); \
186 }; \
187 ::nlib_ns::testing::TestInfo* NLIB_TESTING_CLASS_NAME_(test_case, test_name)::info_ = \
188  ::nlib_ns::testing::TestInfo::AddTestInfo< \
189  NLIB_TESTING_CLASS_NAME_(test_case, test_name)>( \
190  #test_case, #test_name, -1, test_case::SetUpTestCase, test_case::TearDownTestCase); \
191 void NLIB_TESTING_CLASS_NAME_(test_case, test_name)::TestBodySub()
192 
193 #define INSTANTIATE_TEST_CASE_P(prefix, test_case, generator) \
194 class TestParamAdder_##test_case##prefix : public ::nlib_ns::testing::TestParamAdderBase { \
195 public: /* NOLINT */ \
196  TestParamAdder_##test_case##prefix() { \
197  ::nlib_ns::testing::TestParamAdderList::AddTestParamAdder(this); \
198  } \
199  virtual void AddParams() { \
200  generator.Gen(test_case::GetParams()); \
201  } \
202 } \
203  ntest_##test_case##prefix##_glbval_
204 
205 #if defined(_MSC_VER) && defined(nx_testing_EXPORTS)
206 #undef NLIB_VIS_PUBLIC
207 #define NLIB_VIS_PUBLIC NLIB_WINIMPORT
208 #endif
209 
210 #endif // INCLUDE_NN_NLIB_TESTING_PARAMVALUE_H_
#define NLIB_OVERRIDE
Defines override if it is available for use. If not, holds an empty string.
Definition: Config.h:210
#define NLIB_DISALLOW_COPY_AND_ASSIGN(TypeName)
Prohibits use of the copy constructor and assignment operator for the class specified by TypeName...
Definition: Config.h:145
Defines that class that is corresponding to std::unique_ptr.
#define NLIB_VIS_PUBLIC
Symbols for functions and classes are made available outside of the library.
Definition: Platform_unix.h:61
Defines the class that resembles std::vector but can store objects that cannot be copied...
A file that contains the configuration information for each development environment.
Defines the macro for a basic, simple test.