1 #ifndef _VKTTESTCASEUTIL_HPP 2 #define _VKTTESTCASEUTIL_HPP 3 /*------------------------------------------------------------------------- 4 * Vulkan Conformance Tests 5 * ------------------------ 6 * 7 * Copyright (c) 2015 Google Inc. 8 * 9 * Licensed under the Apache License, Version 2.0 (the "License"); 10 * you may not use this file except in compliance with the License. 11 * You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, software 16 * distributed under the License is distributed on an "AS IS" BASIS, 17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 * See the License for the specific language governing permissions and 19 * limitations under the License. 20 * 21 *//*! 22 * \file 23 * \brief TestCase utilities 24 *//*--------------------------------------------------------------------*/ 25 26 #include "tcuDefs.hpp" 27 #include "vktTestCase.hpp" 28 29 namespace vkt 30 { 31 32 template<typename Arg0> 33 struct NoPrograms1 34 { 35 void init (vk::SourceCollections&, Arg0) const {} 36 }; 37 38 template<typename Instance, typename Arg0, typename Programs = NoPrograms1<Arg0> > 39 class InstanceFactory1 : public TestCase 40 { 41 public: 42 InstanceFactory1 (tcu::TestContext& testCtx, tcu::TestNodeType type, const std::string& name, const std::string& desc, const Arg0& arg0) 43 : TestCase (testCtx, type, name, desc) 44 , m_progs () 45 , m_arg0 (arg0) 46 {} 47 48 InstanceFactory1 (tcu::TestContext& testCtx, tcu::TestNodeType type, const std::string& name, const std::string& desc, const Programs& progs, const Arg0& arg0) 49 : TestCase (testCtx, type, name, desc) 50 , m_progs (progs) 51 , m_arg0 (arg0) 52 {} 53 54 void initPrograms (vk::SourceCollections& dst) const { m_progs.init(dst, m_arg0); } 55 TestInstance* createInstance (Context& context) const { return new Instance(context, m_arg0); } 56 57 private: 58 const Programs m_progs; 59 const Arg0 m_arg0; 60 }; 61 62 class FunctionInstance0 : public TestInstance 63 { 64 public: 65 typedef tcu::TestStatus (*Function) (Context& context); 66 67 FunctionInstance0 (Context& context, Function function) 68 : TestInstance (context) 69 , m_function (function) 70 {} 71 72 tcu::TestStatus iterate (void) { return m_function(m_context); } 73 74 private: 75 const Function m_function; 76 }; 77 78 template<typename Arg0> 79 class FunctionInstance1 : public TestInstance 80 { 81 public: 82 typedef tcu::TestStatus (*Function) (Context& context, Arg0 arg0); 83 84 struct Args 85 { 86 Args (Function func_, Arg0 arg0_) : func(func_), arg0(arg0_) {} 87 88 Function func; 89 Arg0 arg0; 90 }; 91 92 FunctionInstance1 (Context& context, const Args& args) 93 : TestInstance (context) 94 , m_args (args) 95 {} 96 97 tcu::TestStatus iterate (void) { return m_args.func(m_context, m_args.arg0); } 98 99 private: 100 const Args m_args; 101 }; 102 103 class FunctionPrograms0 104 { 105 public: 106 typedef void (*Function) (vk::SourceCollections& dst); 107 108 FunctionPrograms0 (Function func) 109 : m_func(func) 110 {} 111 112 void init (vk::SourceCollections& dst, FunctionInstance0::Function) const { m_func(dst); } 113 114 private: 115 const Function m_func; 116 }; 117 118 template<typename Arg0> 119 class FunctionPrograms1 120 { 121 public: 122 typedef void (*Function) (vk::SourceCollections& dst, Arg0 arg0); 123 124 FunctionPrograms1 (Function func) 125 : m_func(func) 126 {} 127 128 void init (vk::SourceCollections& dst, const typename FunctionInstance1<Arg0>::Args& args) const { m_func(dst, args.arg0); } 129 130 private: 131 const Function m_func; 132 }; 133 134 // createFunctionCase 135 136 inline TestCase* createFunctionCase (tcu::TestContext& testCtx, 137 tcu::TestNodeType type, 138 const std::string& name, 139 const std::string& desc, 140 FunctionInstance0::Function testFunction) 141 { 142 return new InstanceFactory1<FunctionInstance0, FunctionInstance0::Function>(testCtx, type, name, desc, testFunction); 143 } 144 145 inline TestCase* createFunctionCaseWithPrograms (tcu::TestContext& testCtx, 146 tcu::TestNodeType type, 147 const std::string& name, 148 const std::string& desc, 149 FunctionPrograms0::Function initPrograms, 150 FunctionInstance0::Function testFunction) 151 { 152 return new InstanceFactory1<FunctionInstance0, FunctionInstance0::Function, FunctionPrograms0>( 153 testCtx, type, name, desc, FunctionPrograms0(initPrograms), testFunction); 154 } 155 156 template<typename Arg0> 157 TestCase* createFunctionCase (tcu::TestContext& testCtx, 158 tcu::TestNodeType type, 159 const std::string& name, 160 const std::string& desc, 161 typename FunctionInstance1<Arg0>::Function testFunction, 162 Arg0 arg0) 163 { 164 return new InstanceFactory1<FunctionInstance1<Arg0>, typename FunctionInstance1<Arg0>::Args>( 165 testCtx, type, name, desc, typename FunctionInstance1<Arg0>::Args(testFunction, arg0)); 166 } 167 168 template<typename Arg0> 169 TestCase* createFunctionCaseWithPrograms (tcu::TestContext& testCtx, 170 tcu::TestNodeType type, 171 const std::string& name, 172 const std::string& desc, 173 typename FunctionPrograms1<Arg0>::Function initPrograms, 174 typename FunctionInstance1<Arg0>::Function testFunction, 175 Arg0 arg0) 176 { 177 return new InstanceFactory1<FunctionInstance1<Arg0>, typename FunctionInstance1<Arg0>::Args, FunctionPrograms1<Arg0> >( 178 testCtx, type, name, desc, FunctionPrograms1<Arg0>(initPrograms), typename FunctionInstance1<Arg0>::Args(testFunction, arg0)); 179 } 180 181 // addFunctionCase 182 183 inline void addFunctionCase (tcu::TestCaseGroup* group, 184 const std::string& name, 185 const std::string& desc, 186 FunctionInstance0::Function testFunc) 187 { 188 group->addChild(createFunctionCase(group->getTestContext(), tcu::NODETYPE_SELF_VALIDATE, name, desc, testFunc)); 189 } 190 191 inline void addFunctionCaseWithPrograms (tcu::TestCaseGroup* group, 192 const std::string& name, 193 const std::string& desc, 194 FunctionPrograms0::Function initPrograms, 195 FunctionInstance0::Function testFunc) 196 { 197 group->addChild(createFunctionCaseWithPrograms(group->getTestContext(), tcu::NODETYPE_SELF_VALIDATE, name, desc, initPrograms, testFunc)); 198 } 199 200 template<typename Arg0> 201 void addFunctionCase (tcu::TestCaseGroup* group, 202 const std::string& name, 203 const std::string& desc, 204 typename FunctionInstance1<Arg0>::Function testFunc, 205 Arg0 arg0) 206 { 207 group->addChild(createFunctionCase<Arg0>(group->getTestContext(), tcu::NODETYPE_SELF_VALIDATE, name, desc, testFunc, arg0)); 208 } 209 210 template<typename Arg0> 211 void addFunctionCase (tcu::TestCaseGroup* group, 212 tcu::TestNodeType type, 213 const std::string& name, 214 const std::string& desc, 215 typename FunctionInstance1<Arg0>::Function testFunc, 216 Arg0 arg0) 217 { 218 group->addChild(createFunctionCase<Arg0>(group->getTestContext(), type, name, desc, testFunc, arg0)); 219 } 220 221 template<typename Arg0> 222 void addFunctionCaseWithPrograms (tcu::TestCaseGroup* group, 223 const std::string& name, 224 const std::string& desc, 225 typename FunctionPrograms1<Arg0>::Function initPrograms, 226 typename FunctionInstance1<Arg0>::Function testFunc, 227 Arg0 arg0) 228 { 229 group->addChild(createFunctionCaseWithPrograms<Arg0>(group->getTestContext(), tcu::NODETYPE_SELF_VALIDATE, name, desc, initPrograms, testFunc, arg0)); 230 } 231 232 template<typename Arg0> 233 void addFunctionCaseWithPrograms (tcu::TestCaseGroup* group, 234 tcu::TestNodeType type, 235 const std::string& name, 236 const std::string& desc, 237 typename FunctionPrograms1<Arg0>::Function initPrograms, 238 typename FunctionInstance1<Arg0>::Function testFunc, 239 Arg0 arg0) 240 { 241 group->addChild(createFunctionCaseWithPrograms<Arg0>(group->getTestContext(), type, name, desc, initPrograms, testFunc, arg0)); 242 } 243 244 } // vkt 245 246 #endif // _VKTTESTCASEUTIL_HPP 247
