1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2017 The Khronos Group Inc.
6 * Copyright (c) 2017 Samsung Electronics Co., Ltd.
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 *
20 *//*!
21 * \file
22 * \brief Protected memory blit image tests
23 *//*--------------------------------------------------------------------*/
24
25 #include "vktProtectedMemBlitImageTests.hpp"
26
27 #include "deRandom.hpp"
28 #include "tcuTestLog.hpp"
29 #include "tcuVector.hpp"
30 #include "tcuVectorUtil.hpp"
31
32 #include "vkPrograms.hpp"
33 #include "vktTestCase.hpp"
34 #include "vktTestGroupUtil.hpp"
35 #include "vkTypeUtil.hpp"
36 #include "vkBuilderUtil.hpp"
37 #include "vkCmdUtil.hpp"
38
39 #include "vktProtectedMemContext.hpp"
40 #include "vktProtectedMemUtils.hpp"
41 #include "vktProtectedMemImageValidator.hpp"
42
43 namespace vkt
44 {
45 namespace ProtectedMem
46 {
47
48 namespace
49 {
50
51 enum {
52 RENDER_WIDTH = 128,
53 RENDER_HEIGHT = 128,
54 };
55
56 class BlitImageTestInstance : public ProtectedTestInstance
57 {
58 public:
59 BlitImageTestInstance (Context& ctx,
60 const vk::VkClearColorValue& clearColorValue,
61 const ValidationData& refData,
62 const ImageValidator& validator,
63 const CmdBufferType cmdBufferType);
64 virtual tcu::TestStatus iterate (void);
65
66 private:
67 const vk::VkFormat m_imageFormat;
68 const vk::VkClearColorValue& m_clearColorValue;
69 const ValidationData& m_refData;
70 const ImageValidator& m_validator;
71 const CmdBufferType m_cmdBufferType;
72 };
73
74 class BlitImageTestCase : public TestCase
75 {
76 public:
BlitImageTestCase(tcu::TestContext & testCtx,const std::string & name,vk::VkClearColorValue clearColorValue,ValidationData data,CmdBufferType cmdBufferType)77 BlitImageTestCase (tcu::TestContext& testCtx,
78 const std::string& name,
79 vk::VkClearColorValue clearColorValue,
80 ValidationData data,
81 CmdBufferType cmdBufferType)
82 : TestCase (testCtx, name, "Clear and blit image.")
83 , m_clearColorValue (clearColorValue)
84 , m_refData (data)
85 , m_cmdBufferType (cmdBufferType)
86 {
87 }
88
~BlitImageTestCase(void)89 virtual ~BlitImageTestCase (void) {}
createInstance(Context & ctx) const90 virtual TestInstance* createInstance (Context& ctx) const
91 {
92 return new BlitImageTestInstance(ctx, m_clearColorValue, m_refData, m_validator, m_cmdBufferType);
93 }
initPrograms(vk::SourceCollections & programCollection) const94 virtual void initPrograms (vk::SourceCollections& programCollection) const
95 {
96 m_validator.initPrograms(programCollection);
97 }
checkSupport(Context & context) const98 virtual void checkSupport (Context& context) const
99 {
100 checkProtectedQueueSupport(context);
101 }
102 private:
103 vk::VkClearColorValue m_clearColorValue;
104 ValidationData m_refData;
105 ImageValidator m_validator;
106 CmdBufferType m_cmdBufferType;
107 };
108
BlitImageTestInstance(Context & ctx,const vk::VkClearColorValue & clearColorValue,const ValidationData & refData,const ImageValidator & validator,const CmdBufferType cmdBufferType)109 BlitImageTestInstance::BlitImageTestInstance (Context& ctx,
110 const vk::VkClearColorValue& clearColorValue,
111 const ValidationData& refData,
112 const ImageValidator& validator,
113 const CmdBufferType cmdBufferType)
114 : ProtectedTestInstance (ctx)
115 , m_imageFormat (vk::VK_FORMAT_R8G8B8A8_UNORM)
116 , m_clearColorValue (clearColorValue)
117 , m_refData (refData)
118 , m_validator (validator)
119 , m_cmdBufferType (cmdBufferType)
120 {
121 }
122
iterate()123 tcu::TestStatus BlitImageTestInstance::iterate()
124 {
125 ProtectedContext& ctx (m_protectedContext);
126 const vk::DeviceInterface& vk = ctx.getDeviceInterface();
127 const vk::VkDevice device = ctx.getDevice();
128 const vk::VkQueue queue = ctx.getQueue();
129 const deUint32 queueFamilyIndex = ctx.getQueueFamilyIndex();
130
131 // Create images
132 de::MovePtr<vk::ImageWithMemory> colorImage = createImage2D(ctx, PROTECTION_ENABLED, queueFamilyIndex,
133 RENDER_WIDTH, RENDER_HEIGHT,
134 m_imageFormat,
135 vk::VK_IMAGE_USAGE_SAMPLED_BIT
136 | vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT);
137 de::MovePtr<vk::ImageWithMemory> colorImageSrc = createImage2D(ctx, PROTECTION_ENABLED, queueFamilyIndex,
138 RENDER_WIDTH, RENDER_HEIGHT,
139 m_imageFormat,
140 vk::VK_IMAGE_USAGE_SAMPLED_BIT
141 | vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT
142 | vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
143
144 vk::Unique<vk::VkPipelineLayout> pipelineLayout (createPipelineLayout(ctx, 0u, DE_NULL));
145
146 vk::Unique<vk::VkCommandPool> cmdPool (makeCommandPool(vk, device, PROTECTION_ENABLED, queueFamilyIndex));
147 vk::Unique<vk::VkCommandBuffer> cmdBuffer (vk::allocateCommandBuffer(vk, device, *cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY));
148 vk::Unique<vk::VkCommandBuffer> secondaryCmdBuffer (vk::allocateCommandBuffer(vk, device, *cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_SECONDARY));
149 vk::VkCommandBuffer targetCmdBuffer = (m_cmdBufferType == CMD_BUFFER_SECONDARY) ? *secondaryCmdBuffer : *cmdBuffer;
150
151 // Begin cmd buffer
152 beginCommandBuffer(vk, *cmdBuffer);
153
154 if (m_cmdBufferType == CMD_BUFFER_SECONDARY)
155 {
156 // Begin secondary command buffer
157 const vk::VkCommandBufferInheritanceInfo secCmdBufInheritInfo =
158 {
159 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
160 DE_NULL,
161 (vk::VkRenderPass)0u, // renderPass
162 0u, // subpass
163 (vk::VkFramebuffer)0u, // framebuffer
164 VK_FALSE, // occlusionQueryEnable
165 (vk::VkQueryControlFlags)0u, // queryFlags
166 (vk::VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
167 };
168 beginSecondaryCommandBuffer(vk, *secondaryCmdBuffer, secCmdBufInheritInfo);
169 }
170
171 // Start image barrier for source image.
172 {
173 const vk::VkImageMemoryBarrier startImgBarrier =
174 {
175 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
176 DE_NULL, // pNext
177 0, // srcAccessMask
178 vk::VK_ACCESS_TRANSFER_WRITE_BIT, // dstAccessMask
179 vk::VK_IMAGE_LAYOUT_UNDEFINED, // oldLayout
180 vk::VK_IMAGE_LAYOUT_GENERAL, // newLayout
181 queueFamilyIndex, // srcQueueFamilyIndex
182 queueFamilyIndex, // dstQueueFamilyIndex
183 **colorImageSrc, // image
184 {
185 vk::VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
186 0u, // baseMipLevel
187 1u, // mipLevels
188 0u, // baseArraySlice
189 1u, // subresourceRange
190 }
191 };
192
193 vk.cmdPipelineBarrier(targetCmdBuffer, // commandBuffer
194 vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // srcStageMask
195 vk::VK_PIPELINE_STAGE_TRANSFER_BIT, // dstStageMask
196 (vk::VkDependencyFlags)0, // dependencyFlags
197 0, (const vk::VkMemoryBarrier*)DE_NULL, // memoryBarrierCount, pMemoryBarriers
198 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, // bufferMemoryBarrierCount, pBufferMemoryBarriers
199 1, &startImgBarrier); // imageMemoryBarrierCount, pImageMemoryBarriers
200 }
201
202 // Image clear
203 const vk::VkImageSubresourceRange subresourceRange =
204 {
205 vk::VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask
206 0u, // uint32_t baseMipLevel
207 1u, // uint32_t levelCount
208 0u, // uint32_t baseArrayLayer
209 1u, // uint32_t layerCount
210 };
211 vk.cmdClearColorImage(targetCmdBuffer, **colorImageSrc, vk::VK_IMAGE_LAYOUT_GENERAL, &m_clearColorValue, 1, &subresourceRange);
212
213 // Image barrier to change accessMask to transfer read bit for source image.
214 {
215 const vk::VkImageMemoryBarrier initializeBarrier =
216 {
217 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
218 DE_NULL, // pNext
219 vk::VK_ACCESS_TRANSFER_WRITE_BIT, // srcAccessMask
220 vk::VK_ACCESS_TRANSFER_READ_BIT, // dstAccessMask
221 vk::VK_IMAGE_LAYOUT_GENERAL, // oldLayout
222 vk::VK_IMAGE_LAYOUT_GENERAL, // newLayout
223 queueFamilyIndex, // srcQueueFamilyIndex
224 queueFamilyIndex, // dstQueueFamilyIndex
225 **colorImageSrc, // image
226 {
227 vk::VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
228 0u, // baseMipLevel
229 1u, // mipLevels
230 0u, // baseArraySlice
231 1u, // subresourceRange
232 }
233 };
234
235 vk.cmdPipelineBarrier(targetCmdBuffer,
236 vk::VK_PIPELINE_STAGE_TRANSFER_BIT, // srcStageMask
237 vk::VK_PIPELINE_STAGE_TRANSFER_BIT, // dstStageMask
238 (vk::VkDependencyFlags)0,
239 0, (const vk::VkMemoryBarrier*)DE_NULL,
240 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
241 1, &initializeBarrier);
242 }
243
244 // Image barrier for destination image.
245 {
246 const vk::VkImageMemoryBarrier initializeBarrier =
247 {
248 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
249 DE_NULL, // pNext
250 0, // srcAccessMask
251 vk::VK_ACCESS_TRANSFER_WRITE_BIT, // dstAccessMask
252 vk::VK_IMAGE_LAYOUT_UNDEFINED, // oldLayout
253 vk::VK_IMAGE_LAYOUT_GENERAL, // newLayout
254 queueFamilyIndex, // srcQueueFamilyIndex
255 queueFamilyIndex, // dstQueueFamilyIndex
256 **colorImage, // image
257 {
258 vk::VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
259 0u, // baseMipLevel
260 1u, // mipLevels
261 0u, // baseArraySlice
262 1u, // subresourceRange
263 }
264 };
265
266 vk.cmdPipelineBarrier(targetCmdBuffer,
267 vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, // srcStageMask
268 vk::VK_PIPELINE_STAGE_TRANSFER_BIT, // dstStageMask
269 (vk::VkDependencyFlags)0,
270 0, (const vk::VkMemoryBarrier*)DE_NULL,
271 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
272 1, &initializeBarrier);
273 }
274
275 // Blit image
276 const vk::VkImageSubresourceLayers imgSubResCopy =
277 {
278 vk::VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask;
279 0u, // deUint32 mipLevel;
280 0u, // deUint32 baseArrayLayer;
281 1u, // deUint32 layerCount;
282 };
283 const vk::VkOffset3D nullOffset = {0u, 0u, 0u};
284 const vk::VkOffset3D imageOffset = {RENDER_WIDTH, RENDER_HEIGHT, 1};
285 const vk::VkImageBlit imageBlit =
286 {
287 imgSubResCopy, // VkImageSubresourceLayers srcSubresource;
288 {
289 nullOffset,
290 imageOffset,
291 }, // VkOffset3D srcOffsets[2];
292 imgSubResCopy, // VkImageSubresourceLayers dstSubresource;
293 {
294 nullOffset,
295 imageOffset,
296 }, // VkOffset3D dstOffsets[2];
297 };
298 vk.cmdBlitImage(targetCmdBuffer, **colorImageSrc, vk::VK_IMAGE_LAYOUT_GENERAL,
299 **colorImage, vk::VK_IMAGE_LAYOUT_GENERAL, 1u, &imageBlit, vk::VK_FILTER_NEAREST);
300
301 // Image barrier to change accessMask to shader read bit for destination image.
302 {
303 const vk::VkImageMemoryBarrier endImgBarrier =
304 {
305 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
306 DE_NULL, // pNext
307 vk::VK_ACCESS_TRANSFER_WRITE_BIT, // srcAccessMask
308 vk::VK_ACCESS_SHADER_READ_BIT, // dstAccessMask
309 vk::VK_IMAGE_LAYOUT_GENERAL, // oldLayout
310 vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, // newLayout
311 queueFamilyIndex, // srcQueueFamilyIndex
312 queueFamilyIndex, // dstQueueFamilyIndex
313 **colorImage, // image
314 {
315 vk::VK_IMAGE_ASPECT_COLOR_BIT, // aspectMask
316 0u, // baseMipLevel
317 1u, // mipLevels
318 0u, // baseArraySlice
319 1u, // subresourceRange
320 }
321 };
322 vk.cmdPipelineBarrier(targetCmdBuffer,
323 vk::VK_PIPELINE_STAGE_TRANSFER_BIT, // srcStageMask
324 vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, // dstStageMask
325 (vk::VkDependencyFlags)0,
326 0, (const vk::VkMemoryBarrier*)DE_NULL,
327 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
328 1, &endImgBarrier);
329 }
330
331 if (m_cmdBufferType == CMD_BUFFER_SECONDARY)
332 {
333 endCommandBuffer(vk, *secondaryCmdBuffer);
334 vk.cmdExecuteCommands(*cmdBuffer, 1u, &secondaryCmdBuffer.get());
335 }
336
337 endCommandBuffer(vk, *cmdBuffer);
338
339 // Submit command buffer
340 const vk::Unique<vk::VkFence> fence (vk::createFence(vk, device));
341 VK_CHECK(queueSubmit(ctx, PROTECTION_ENABLED, queue, *cmdBuffer, *fence, ~0ull));
342
343 // Log out test data
344 ctx.getTestContext().getLog()
345 << tcu::TestLog::Message << "Color clear value: " << tcu::Vec4(m_clearColorValue.float32) << tcu::TestLog::EndMessage;
346
347 // Validate resulting image
348 if (m_validator.validateImage(ctx, m_refData, **colorImage, m_imageFormat, vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL))
349 return tcu::TestStatus::pass("Everything went OK");
350 else
351 return tcu::TestStatus::fail("Something went really wrong");
352 }
353
createBlitImageTests(tcu::TestContext & testCtx,CmdBufferType cmdBufferType)354 tcu::TestCaseGroup* createBlitImageTests (tcu::TestContext& testCtx, CmdBufferType cmdBufferType)
355 {
356 struct {
357 const vk::VkClearColorValue clearColorValue;
358 const ValidationData data;
359 } testData[] = {
360 { { { 1.0f, 0.0f, 0.0f, 1.0f } },
361 {
362 { tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 0.0f, 0.0f),
363 tcu::Vec4(0.1f, 0.1f, 0.0f, 0.0f), tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f), },
364 { tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f),
365 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f), }
366 }
367 },
368 { { { 0.0f, 1.0f, 0.0f, 1.0f } },
369 {
370 { tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 0.0f, 0.0f),
371 tcu::Vec4(0.1f, 0.1f, 0.0f, 0.0f), tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f), },
372 { tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f), tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f),
373 tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f), tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f), }
374 }
375 },
376 { { { 0.0f, 0.0f, 1.0f, 1.0f } },
377 {
378 { tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 0.0f, 0.0f),
379 tcu::Vec4(0.1f, 0.1f, 0.0f, 0.0f), tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f), },
380 { tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f), tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f),
381 tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f), tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f), }
382 }
383 },
384 { { { 0.0f, 0.0f, 0.0f, 1.0f } },
385 {
386 { tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 0.0f, 0.0f),
387 tcu::Vec4(0.1f, 0.1f, 0.0f, 0.0f), tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f), },
388 { tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f),
389 tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f), }
390 }
391 },
392 { { { 1.0f, 0.0f, 0.0f, 1.0f } },
393 {
394 { tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 0.0f, 0.0f),
395 tcu::Vec4(0.1f, 0.1f, 0.0f, 0.0f), tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f), },
396 { tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f),
397 tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f), tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f), }
398 }
399 },
400 { { { 1.0f, 0.0f, 0.0f, 0.0f } },
401 {
402 { tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 0.0f, 0.0f),
403 tcu::Vec4(0.1f, 0.1f, 0.0f, 0.0f), tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f), },
404 { tcu::Vec4(1.0f, 0.0f, 0.0f, 0.0f), tcu::Vec4(1.0f, 0.0f, 0.0f, 0.0f),
405 tcu::Vec4(1.0f, 0.0f, 0.0f, 0.0f), tcu::Vec4(1.0f, 0.0f, 0.0f, 0.0f), }
406 }
407 },
408 { { { 0.1f, 0.2f, 0.3f, 0.0f } },
409 {
410 { tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 0.0f, 0.0f),
411 tcu::Vec4(0.1f, 0.1f, 0.0f, 0.0f), tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f), },
412 { tcu::Vec4(0.1f, 0.2f, 0.3f, 0.0f), tcu::Vec4(0.1f, 0.2f, 0.3f, 0.0f),
413 tcu::Vec4(0.1f, 0.2f, 0.3f, 0.0f), tcu::Vec4(0.1f, 0.2f, 0.3f, 0.0f), }
414 }
415 },
416 };
417
418 de::MovePtr<tcu::TestCaseGroup> blitStaticTests (new tcu::TestCaseGroup(testCtx, "static", "Blit Image Tests with static input"));
419
420 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(testData); ++ndx)
421 {
422 const std::string name = "blit_" + de::toString(ndx + 1);
423 blitStaticTests->addChild(new BlitImageTestCase(testCtx, name.c_str(), testData[ndx].clearColorValue, testData[ndx].data, cmdBufferType));
424 }
425
426 /* Add a few randomized tests */
427 de::MovePtr<tcu::TestCaseGroup> blitRandomTests (new tcu::TestCaseGroup(testCtx, "random", "Blit Image Tests with random input"));
428 const int testCount = 10;
429 de::Random rnd (testCtx.getCommandLine().getBaseSeed());
430 for (int ndx = 0; ndx < testCount; ++ndx)
431 {
432 const std::string name = "blit_" + de::toString(ndx + 1);
433 vk::VkClearValue clearValue = vk::makeClearValueColorVec4(tcu::randomVec4(rnd));
434 const tcu::Vec4 refValue (clearValue.color.float32[0], clearValue.color.float32[1], clearValue.color.float32[2], clearValue.color.float32[3]);
435 const tcu::Vec4 vec0 = tcu::randomVec4(rnd);
436 const tcu::Vec4 vec1 = tcu::randomVec4(rnd);
437 const tcu::Vec4 vec2 = tcu::randomVec4(rnd);
438 const tcu::Vec4 vec3 = tcu::randomVec4(rnd);
439
440 ValidationData data =
441 {
442 { vec0, vec1, vec2, vec3 },
443 { refValue, refValue, refValue, refValue }
444 };
445 blitRandomTests->addChild(new BlitImageTestCase(testCtx, name.c_str(), clearValue.color, data, cmdBufferType));
446 }
447
448 std::string groupName = getCmdBufferTypeStr(cmdBufferType);
449 std::string groupDesc = "Blit Image Tests with " + groupName + " command buffer";
450 de::MovePtr<tcu::TestCaseGroup> blitTests (new tcu::TestCaseGroup(testCtx, groupName.c_str(), groupDesc.c_str()));
451 blitTests->addChild(blitStaticTests.release());
452 blitTests->addChild(blitRandomTests.release());
453 return blitTests.release();
454 }
455
456 } // anonymous
457
createBlitImageTests(tcu::TestContext & testCtx)458 tcu::TestCaseGroup* createBlitImageTests (tcu::TestContext& testCtx)
459 {
460 de::MovePtr<tcu::TestCaseGroup> blitTests (new tcu::TestCaseGroup(testCtx, "blit", "Blit Image Tests"));
461
462 blitTests->addChild(createBlitImageTests(testCtx, CMD_BUFFER_PRIMARY));
463 blitTests->addChild(createBlitImageTests(testCtx, CMD_BUFFER_SECONDARY));
464
465 return blitTests.release();
466 }
467
468 } // ProtectedMem
469 } // vkt
470