Merge vulkan-cts-1.0 to vulkan-cts-1.0-dev
[platform/upstream/VK-GL-CTS.git] / external / vulkancts / modules / vulkan / vktTestGroupUtil.hpp
1 #ifndef _VKTTESTGROUPUTIL_HPP
2 #define _VKTTESTGROUPUTIL_HPP
3 /*-------------------------------------------------------------------------
4  * Vulkan Conformance Tests
5  * ------------------------
6  *
7  * Copyright (c) 2016 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 TestCaseGroup utilities
24  *//*--------------------------------------------------------------------*/
25
26 #include "tcuDefs.hpp"
27 #include "tcuTestCase.hpp"
28
29 namespace vkt
30 {
31
32 class TestGroupHelper0 : public tcu::TestCaseGroup
33 {
34 public:
35         typedef void (*CreateChildrenFunc) (tcu::TestCaseGroup* testGroup);
36
37                                                                 TestGroupHelper0        (tcu::TestContext&              testCtx,
38                                                                                                          const std::string&             name,
39                                                                                                          const std::string&             description,
40                                                                                                          CreateChildrenFunc             createChildren);
41                                                                 ~TestGroupHelper0       (void);
42
43         void                                            init                            (void);
44
45 private:
46         const CreateChildrenFunc        m_createChildren;
47 };
48
49 template<typename Arg0>
50 class TestGroupHelper1 : public tcu::TestCaseGroup
51 {
52 public:
53         typedef void (*CreateChildrenFunc) (tcu::TestCaseGroup* testGroup, Arg0 arg0);
54
55                                                                 TestGroupHelper1        (tcu::TestContext&              testCtx,
56                                                                                                          const std::string&             name,
57                                                                                                          const std::string&             description,
58                                                                                                          CreateChildrenFunc             createChildren,
59                                                                                                          const Arg0&                    arg0)
60                                                                         : tcu::TestCaseGroup    (testCtx, name.c_str(), description.c_str())
61                                                                         , m_createChildren              (createChildren)
62                                                                         , m_arg0                                (arg0)
63                                                                 {}
64
65         void                                            init                            (void) { m_createChildren(this, m_arg0); }
66
67 private:
68         const CreateChildrenFunc        m_createChildren;
69         const Arg0                                      m_arg0;
70 };
71
72 inline tcu::TestCaseGroup* createTestGroup (tcu::TestContext&                                           testCtx,
73                                                                                         const std::string&                                              name,
74                                                                                         const std::string&                                              description,
75                                                                                         TestGroupHelper0::CreateChildrenFunc    createChildren)
76 {
77         return new TestGroupHelper0(testCtx, name, description, createChildren);
78 }
79
80 template<typename Arg0>
81 tcu::TestCaseGroup* createTestGroup (tcu::TestContext&                                                                          testCtx,
82                                                                          const std::string&                                                                             name,
83                                                                          const std::string&                                                                             description,
84                                                                          typename TestGroupHelper1<Arg0>::CreateChildrenFunc    createChildren,
85                                                                          Arg0                                                                                                   arg0)
86 {
87         return new TestGroupHelper1<Arg0>(testCtx, name, description, createChildren, arg0);
88 }
89
90 inline void addTestGroup (tcu::TestCaseGroup*                                   parent,
91                                                   const std::string&                                    name,
92                                                   const std::string&                                    description,
93                                                   TestGroupHelper0::CreateChildrenFunc  createChildren)
94 {
95         parent->addChild(createTestGroup(parent->getTestContext(), name, description, createChildren));
96 }
97
98 template<typename Arg0>
99 void addTestGroup (tcu::TestCaseGroup*                                                                  parent,
100                                    const std::string&                                                                   name,
101                                    const std::string&                                                                   description,
102                                    typename TestGroupHelper1<Arg0>::CreateChildrenFunc  createChildren,
103                                    Arg0                                                                                                 arg0)
104 {
105         parent->addChild(createTestGroup<Arg0>(parent->getTestContext(), name, description, createChildren, arg0));
106 }
107
108 } // vkt
109
110 #endif // _VKTTESTGROUPUTIL_HPP