nlib
ParamValue.h
Go to the documentation of this file.
1 
2 /*--------------------------------------------------------------------------------*
3  Project: CrossRoad
4  Copyright (C)Nintendo All rights reserved.
5 
6  These coded instructions, statements, and computer programs contain proprietary
7  information of Nintendo and/or its licensed developers and are protected by
8  national and international copyright laws. They may not be disclosed to third
9  parties or copied or duplicated in any form, in whole or in part, without the
10  prior written consent of Nintendo.
11 
12  The content herein is highly confidential and should be handled accordingly.
13  *--------------------------------------------------------------------------------*/
14 
15 #pragma once
16 #ifndef INCLUDE_NN_NLIB_TESTING_PARAMVALUE_H_
17 #define INCLUDE_NN_NLIB_TESTING_PARAMVALUE_H_
18 
19 #include "nn/nlib/Config.h"
20 #include "nn/nlib/testing/NTest.h"
21 #include "nn/nlib/testing/ParamValueTypes.h"
22 #include "nn/nlib/UniquePtr.h"
23 #include "nn/nlib/Nlist.h"
24 
25 #if defined(_MSC_VER) && defined(nx_testing_EXPORTS)
26 #undef NLIB_VIS_PUBLIC
27 #define NLIB_VIS_PUBLIC NLIB_WINEXPORT
28 #endif
29 
30 NLIB_NAMESPACE_BEGIN
31 namespace testing {
32 
33 class NLIB_VIS_PUBLIC TestWithParamBase : public Test {
34  public:
35  virtual void TestBody() NLIB_OVERRIDE;
36 
37  private:
38  virtual void TestBodySub() = 0;
39  virtual bool SetParam(size_t i) = 0;
40 };
41 
42 template <class T>
43 class TestWithParam : public TestWithParamBase {
44  public:
45  typedef T ParamType;
46  TestWithParam() : param_(NULL) {}
47  const ParamType& GetParam() const { return *param_; }
48  static Nlist<ParamType>* GetParams() { return &param_vec_; }
49 
50  private:
51  virtual bool SetParam(size_t i) NLIB_OVERRIDE;
52 
53  private:
54  const ParamType* param_;
55  static Nlist<ParamType> param_vec_;
56 
57  NLIB_DISALLOW_COPY_AND_ASSIGN(TestWithParam);
58 };
59 
60 template <class T>
61 bool TestWithParam<T>::SetParam(size_t i) {
62  if (i < param_vec_.size()) {
63  param_ = &param_vec_[i];
64  return true;
65  }
66  return false;
67 }
68 
69 template <>
70 NLIB_VIS_PUBLIC bool TestWithParam<bool>::SetParam(size_t i);
71 
72 template <class T>
73 Nlist<T> TestWithParam<T>::param_vec_;
74 
75 class NLIB_VIS_PUBLIC TestParamAdderBase {
76  public:
77  virtual ~TestParamAdderBase() {}
78  virtual void AddParams() = 0;
79 
80  protected:
81  TestParamAdderBase() {}
82 
83  private:
84  NLIB_DISALLOW_COPY_AND_ASSIGN(TestParamAdderBase);
85 };
86 
87 class NLIB_VIS_PUBLIC TestParamAdderList {
88  public:
89  static void AddParams();
90  static void AddTestParamAdder(TestParamAdderBase* v);
91 
92  public:
93  TestParamAdderList() {}
94  ~TestParamAdderList() {}
95 
96  private:
97  static TestParamAdderBase* adder_list_[1024];
98  static int adder_list_idx_;
99 
100  NLIB_DISALLOW_COPY_AND_ASSIGN(TestParamAdderList);
101 };
102 
103 inline detail::ValuesBool Bool() { return detail::ValuesBool(); }
104 
105 template <class C, size_t N>
106 detail::ValuesInObjArray<C, N> ValuesIn(const C (&a)[N]) {
107  return detail::ValuesInObjArray<C, N>(a);
108 }
109 
110 template <class Container>
111 detail::ValuesInObjContainer<Container> ValuesIn(const Container& c) {
112  return detail::ValuesInObjContainer<Container>(c);
113 }
114 
115 template <class Iterator>
116 detail::ValuesInObjIterator<Iterator> ValuesIn(Iterator first, Iterator last) {
117  return detail::ValuesInObjIterator<Iterator>(first, last);
118 }
119 
120 template <class T>
121 detail::ValuesRange<T, T> Range(T first, T last) {
122  return detail::ValuesRange<T, T>(first, last, T(1));
123 }
124 
125 template <class T, class S>
126 detail::ValuesRange<T, S> Range(T first, T last, S step) {
127  return detail::ValuesRange<T, S>(first, last, step);
128 }
129 
130 template <class T1>
131 detail::Values1<T1> Values(T1 v1) {
132  return detail::Values1<T1>(v1);
133 }
134 
135 template <class T1, class T2>
136 detail::Values2<T1, T2> Values(T1 v1, T2 v2) {
137  return detail::Values2<T1, T2>(v1, v2);
138 }
139 
140 template <class T1, class T2, class T3>
141 detail::Values3<T1, T2, T3> Values(T1 v1, T2 v2, T3 v3) {
142  return detail::Values3<T1, T2, T3>(v1, v2, v3);
143 }
144 
145 template <class T1, class T2, class T3, class T4>
146 detail::Values4<T1, T2, T3, T4> Values(T1 v1, T2 v2, T3 v3, T4 v4) {
147  return detail::Values4<T1, T2, T3, T4>(v1, v2, v3, v4);
148 }
149 
150 template <class T1, class T2, class T3, class T4, class T5>
151 detail::Values5<T1, T2, T3, T4, T5> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
152  return detail::Values5<T1, T2, T3, T4, T5>(v1, v2, v3, v4, v5);
153 }
154 
155 template <class T1, class T2, class T3, class T4, class T5, class T6>
156 detail::Values6<T1, T2, T3, T4, T5, T6> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) {
157  return detail::Values6<T1, T2, T3, T4, T5, T6>(v1, v2, v3, v4, v5, v6);
158 }
159 
160 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
161 detail::Values7<T1, T2, T3, T4, T5, T6, T7> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
162  T7 v7) {
163  return detail::Values7<T1, T2, T3, T4, T5, T6, T7>(v1, v2, v3, v4, v5, v6, v7);
164 }
165 
166 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
167 detail::Values8<T1, T2, T3, T4, T5, T6, T7, T8> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
168  T7 v7, T8 v8) {
169  return detail::Values8<T1, T2, T3, T4, T5, T6, T7, T8>(v1, v2, v3, v4, v5, v6, v7, v8);
170 }
171 
172 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
173 detail::Values9<T1, T2, T3, T4, T5, T6, T7, T8, T9> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
174  T7 v7, T8 v8, T9 v9) {
175  return detail::Values9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(v1, v2, v3, v4, v5, v6, v7, v8, v9);
176 }
177 
178 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9,
179  class T10>
180 detail::Values10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
181  T6 v6, T7 v7, T8 v8, T9 v9,
182  T10 v10) {
183  return detail::Values10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(v1, v2, v3, v4, v5, v6, v7, v8,
184  v9, v10);
185 }
186 
187 } // namespace testing
188 NLIB_NAMESPACE_END
189 
190 #define TEST_P(test_case, test_name) \
191 class NLIB_TESTING_CLASS_NAME_(test_case, test_name) \
192  : public test_case { \
193 public: \
194  NLIB_TESTING_CLASS_NAME_(test_case, test_name)() {} \
195 private: \
196  virtual void TestBodySub(); \
197  static ::nlib_ns::testing::TestInfo* info_; \
198  NLIB_DISALLOW_COPY_AND_ASSIGN(NLIB_TESTING_CLASS_NAME_(test_case, test_name)); \
199 }; \
200 ::nlib_ns::testing::TestInfo* NLIB_TESTING_CLASS_NAME_(test_case, test_name)::info_ = \
201  ::nlib_ns::testing::TestInfo::AddTestInfo< \
202  NLIB_TESTING_CLASS_NAME_(test_case, test_name)>( \
203  #test_case, #test_name, -1, test_case::SetUpTestCase, test_case::TearDownTestCase); \
204 void NLIB_TESTING_CLASS_NAME_(test_case, test_name)::TestBodySub()
205 
206 #define INSTANTIATE_TEST_CASE_P(prefix, test_case, generator) \
207 class TestParamAdder_##test_case##prefix : public ::nlib_ns::testing::TestParamAdderBase { \
208 public: /* NOLINT */ \
209  TestParamAdder_##test_case##prefix() { \
210  ::nlib_ns::testing::TestParamAdderList::AddTestParamAdder(this); \
211  } \
212  virtual void AddParams() { \
213  generator.Gen(test_case::GetParams()); \
214  } \
215 } \
216  ntest_##test_case##prefix##_glbval_
217 
218 #if defined(_MSC_VER) && defined(nx_testing_EXPORTS)
219 #undef NLIB_VIS_PUBLIC
220 #define NLIB_VIS_PUBLIC NLIB_WINIMPORT
221 #endif
222 
223 #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:228
#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:163
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:89
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.