blob: d8b373ea580ad72f58d78f4db10bc3951123e527 [file] [log] [blame]
Courtney Goeltzenleuchter7087dde2014-08-11 18:19:35 -06001// Copyright 2005, Google Inc.
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are
6// met:
7//
8// * Redistributions of source code must retain the above copyright
9// notice, this list of conditions and the following disclaimer.
10// * Redistributions in binary form must reproduce the above
11// copyright notice, this list of conditions and the following disclaimer
12// in the documentation and/or other materials provided with the
13// distribution.
14// * Neither the name of Google Inc. nor the names of its
15// contributors may be used to endorse or promote products derived from
16// this software without specific prior written permission.
17//
18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -060030
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -060031// VK tests
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -060032//
33// Copyright (C) 2014 LunarG, Inc.
34//
35// Permission is hereby granted, free of charge, to any person obtaining a
36// copy of this software and associated documentation files (the "Software"),
37// to deal in the Software without restriction, including without limitation
38// the rights to use, copy, modify, merge, publish, distribute, sublicense,
39// and/or sell copies of the Software, and to permit persons to whom the
40// Software is furnished to do so, subject to the following conditions:
41//
42// The above copyright notice and this permission notice shall be included
43// in all copies or substantial portions of the Software.
44//
45// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
46// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
47// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
48// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
49// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
50// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
51// DEALINGS IN THE SOFTWARE.
52
53
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -060054// Verify VK driver initialization
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -060055
Courtney Goeltzenleuchter7087dde2014-08-11 18:19:35 -060056#include <stdlib.h>
57#include <stdio.h>
58#include <stdbool.h>
59#include <string.h>
60
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -060061#include <vulkan.h>
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -060062#include "gtest-1.7.0/include/gtest/gtest.h"
Courtney Goeltzenleuchter7087dde2014-08-11 18:19:35 -060063
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -060064#include "vktestbinding.h"
Chia-I Wu3b78d312014-12-29 15:39:23 +080065#include "test_common.h"
Cody Northropd4e020a2015-03-17 14:54:35 -060066#include "icd-spv.h"
Courtney Goeltzenleuchter7087dde2014-08-11 18:19:35 -060067
Jon Ashburn07b309a2015-04-15 11:31:12 -060068#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
69
Tony-LunarGe4fe3152015-05-15 12:42:49 -060070class VkTest : public ::testing::Test {
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -060071public:
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -060072 void CreateImageTest();
Courtney Goeltzenleuchter0842df72014-08-20 15:26:55 -060073 void CreateCommandBufferTest();
74 void CreatePipelineTest();
75 void CreateShaderTest();
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -060076 void CreateShader(VkShader *pshader);
Courtney Goeltzenleuchter7087dde2014-08-11 18:19:35 -060077
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -060078 VkDevice device() {return m_device->obj();}
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -060079
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -060080protected:
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -060081 VkApplicationInfo app_info;
82 VkInstance inst;
Tony Barbour8205d902015-04-16 15:59:00 -060083 VkPhysicalDevice objs[16];
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -060084 uint32_t gpu_count;
Chia-I Wu3b78d312014-12-29 15:39:23 +080085
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -060086 uint32_t m_device_id;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -060087 vk_testing::Device *m_device;
Tony Barbour8205d902015-04-16 15:59:00 -060088 VkPhysicalDeviceProperties props;
89 std::vector<VkPhysicalDeviceQueueProperties> queue_props;
Courtney Goeltzenleuchterf3168062015-03-05 18:09:39 -070090 uint32_t graphics_queue_node_index;
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -060091
92 virtual void SetUp() {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -060093 VkResult err;
Courtney Goeltzenleuchterf3168062015-03-05 18:09:39 -070094 int i;
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -060095
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -060096 this->app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -060097 this->app_info.pNext = NULL;
Chia-I Wu7461fcf2014-12-27 15:16:07 +080098 this->app_info.pAppName = "base";
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -060099 this->app_info.appVersion = 1;
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800100 this->app_info.pEngineName = "unittest";
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600101 this->app_info.engineVersion = 1;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600102 this->app_info.apiVersion = VK_API_VERSION;
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600103 VkInstanceCreateInfo inst_info = {};
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600104 inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
Jon Ashburn29669a42015-04-04 14:52:07 -0600105 inst_info.pNext = NULL;
106 inst_info.pAppInfo = &app_info;
107 inst_info.pAllocCb = NULL;
108 inst_info.extensionCount = 0;
109 inst_info.ppEnabledExtensionNames = NULL;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600110 err = vkCreateInstance(&inst_info, &inst);
111 ASSERT_VK_SUCCESS(err);
Jon Ashburn07b309a2015-04-15 11:31:12 -0600112 err = vkEnumeratePhysicalDevices(inst, &this->gpu_count, NULL);
113 ASSERT_VK_SUCCESS(err);
114 ASSERT_LE(this->gpu_count, ARRAY_SIZE(objs)) << "Too many GPUs";
115 err = vkEnumeratePhysicalDevices(inst, &this->gpu_count, objs);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600116 ASSERT_VK_SUCCESS(err);
Jon Ashburn19733c92014-11-26 11:06:49 -0700117 ASSERT_GE(this->gpu_count, 1) << "No GPU available";
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600118
Chia-I Wu3b78d312014-12-29 15:39:23 +0800119 m_device_id = 0;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600120 this->m_device = new vk_testing::Device(objs[m_device_id]);
Chia-I Wu3b78d312014-12-29 15:39:23 +0800121 this->m_device->init();
122
123 props = m_device->gpu().properties();
Chia-I Wu3b78d312014-12-29 15:39:23 +0800124
Courtney Goeltzenleuchterf3168062015-03-05 18:09:39 -0700125 queue_props = this->m_device->gpu().queue_properties();
126 for (i = 0; i < queue_props.size(); i++) {
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600127 if (queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
Courtney Goeltzenleuchterf3168062015-03-05 18:09:39 -0700128 graphics_queue_node_index = i;
129 break;
130 }
131 }
132 ASSERT_LT(i, queue_props.size()) << "Could not find a Queue with Graphics support";
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600133 }
134
135 virtual void TearDown() {
Tony Barbour900ae862015-06-02 14:55:46 -0600136 delete m_device;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600137 vkDestroyInstance(inst);
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600138 }
139};
140
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600141TEST_F(VkTest, AllocMemory) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600142 VkResult err;
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600143 VkMemoryAllocInfo alloc_info = {};
Tony Barbour8205d902015-04-16 15:59:00 -0600144 VkDeviceMemory gpu_mem;
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600145 uint8_t *pData;
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600146
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600147 alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600148 alloc_info.allocationSize = 1024 * 1024; // 1MB
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600149 alloc_info.memProps = VK_MEMORY_PROPERTY_SHAREABLE_BIT |
Tony Barbour8205d902015-04-16 15:59:00 -0600150 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
Tony Barbourfa6cac72015-01-16 14:27:35 -0700151
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600152
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600153 // TODO: Try variety of memory priorities
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600154 alloc_info.memPriority = VK_MEMORY_PRIORITY_NORMAL;
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600155
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600156 err = vkAllocMemory(device(), &alloc_info, &gpu_mem);
157 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchter7087dde2014-08-11 18:19:35 -0600158
Mike Stroyan230e6252015-04-17 12:36:38 -0600159 err = vkMapMemory(device(), gpu_mem, 0, 0, 0, (void **) &pData);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600160 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchter6b814b32014-08-12 09:59:36 -0600161
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600162 memset(pData, 0x55, alloc_info.allocationSize);
163 EXPECT_EQ(0x55, pData[0]) << "Memory read not same a write";
164
Mike Stroyan230e6252015-04-17 12:36:38 -0600165 err = vkUnmapMemory(device(), gpu_mem);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600166 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchter6b814b32014-08-12 09:59:36 -0600167
Mike Stroyan230e6252015-04-17 12:36:38 -0600168 err = vkFreeMemory(device(), gpu_mem);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600169 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600170}
Courtney Goeltzenleuchter6b814b32014-08-12 09:59:36 -0600171
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600172TEST_F(VkTest, Event) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600173 VkEventCreateInfo event_info;
174 VkEvent event;
175 VkMemoryRequirements mem_req;
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600176 size_t data_size;
177 VkDeviceMemory event_mem;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600178 VkResult err;
Courtney Goeltzenleuchter6b814b32014-08-12 09:59:36 -0600179
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600180 // typedef struct VkEventCreateInfo_
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600181 // {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600182 // VkStructureType sType; // Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600183 // const void* pNext; // Pointer to next structure
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600184 // VkFlags flags; // Reserved
185 // } VkEventCreateInfo;
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600186 memset(&event_info, 0, sizeof(event_info));
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600187 event_info.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
Courtney Goeltzenleuchter6b814b32014-08-12 09:59:36 -0600188
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600189 err = vkCreateEvent(device(), &event_info, &event);
190 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600191
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600192 data_size = sizeof(mem_req);
Mike Stroyan230e6252015-04-17 12:36:38 -0600193 err = vkGetObjectInfo(device(), VK_OBJECT_TYPE_EVENT, event, VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600194 &data_size, &mem_req);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600195 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600196
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600197 if (mem_req.size) {
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600198
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600199 // VkResult VKAPI vkAllocMemory(
200 // VkDevice device,
201 // const VkMemoryAllocInfo* pAllocInfo,
202 // VkDeviceMemory* pMem);
203 VkMemoryAllocInfo mem_info;
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600204
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600205 memset(&mem_info, 0, sizeof(mem_info));
206 mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
207 mem_info.allocationSize = mem_req.size;
208 mem_info.memProps = VK_MEMORY_PROPERTY_SHAREABLE_BIT;
209 mem_info.memPriority = VK_MEMORY_PRIORITY_NORMAL;
210 err = vkAllocMemory(device(), &mem_info, &event_mem);
211 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600212
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600213 err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_EVENT, event, event_mem, 0);
214 ASSERT_VK_SUCCESS(err);
215 }
Mike Stroyan230e6252015-04-17 12:36:38 -0600216 err = vkResetEvent(device(), event);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600217 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600218
Mike Stroyan230e6252015-04-17 12:36:38 -0600219 err = vkGetEventStatus(device(), event);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600220 ASSERT_EQ(VK_EVENT_RESET, err);
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600221
Mike Stroyan230e6252015-04-17 12:36:38 -0600222 err = vkSetEvent(device(), event);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600223 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600224
Mike Stroyan230e6252015-04-17 12:36:38 -0600225 err = vkGetEventStatus(device(), event);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600226 ASSERT_EQ(VK_EVENT_SET, err);
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600227
228 // TODO: Test actual synchronization with command buffer event.
229
230 // All done with event memory, clean up
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600231 if (mem_req.size) {
232 err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_EVENT, event, VK_NULL_HANDLE, 0);
233 ASSERT_VK_SUCCESS(err);
234 err = vkFreeMemory(device(), event_mem);
235 ASSERT_VK_SUCCESS(err);
236 }
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600237
Mike Stroyan230e6252015-04-17 12:36:38 -0600238 err = vkDestroyObject(device(), VK_OBJECT_TYPE_EVENT, event);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600239 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600240}
241
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600242#define MAX_QUERY_SLOTS 10
243
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600244TEST_F(VkTest, Query) {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600245 VkQueryPoolCreateInfo query_info;
246 VkQueryPool query_pool;
Chia-I Wu54ed0792014-12-27 14:14:50 +0800247 size_t data_size;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600248 VkMemoryRequirements mem_req;
Chia-I Wu54ed0792014-12-27 14:14:50 +0800249 size_t query_result_size;
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600250 uint32_t *query_result_data;
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600251 VkDeviceMemory query_mem;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600252 VkResult err;
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600253
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600254 // typedef enum VkQueryType_
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600255 // {
Tony Barbour8205d902015-04-16 15:59:00 -0600256 // VK_QUERY_TYPE_OCCLUSION = 0x00000000,
257 // VK_QUERY_TYPE_PIPELINE_STATISTICS = 0x00000001,
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600258
Tony Barbour8205d902015-04-16 15:59:00 -0600259 // VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
260 // VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_PIPELINE_STATISTICS,
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600261 // VK_NUM_QUERY_TYPE = (VK_QUERY_TYPE_END_RANGE - VK_QUERY_TYPE_BEGIN_RANGE + 1),
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600262 // VK_MAX_ENUM(VkQueryType_)
263 // } VkQueryType;
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600264
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600265 // typedef struct VkQueryPoolCreateInfo_
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600266 // {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600267 // VkStructureType sType; // Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600268 // const void* pNext; // Pointer to next structure
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600269 // VkQueryType queryType;
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600270 // uint32_t slots;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600271 // } VkQueryPoolCreateInfo;
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600272
273 memset(&query_info, 0, sizeof(query_info));
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600274 query_info.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
Tony Barbour8205d902015-04-16 15:59:00 -0600275 query_info.queryType = VK_QUERY_TYPE_OCCLUSION;
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600276 query_info.slots = MAX_QUERY_SLOTS;
277
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600278 // VkResult VKAPI vkCreateQueryPool(
279 // VkDevice device,
280 // const VkQueryPoolCreateInfo* pCreateInfo,
281 // VkQueryPool* pQueryPool);
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600282
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600283 err = vkCreateQueryPool(device(), &query_info, &query_pool);
284 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600285
Jon Ashburnb8e43892014-09-25 14:36:58 -0600286 data_size = sizeof(mem_req);
Mike Stroyan230e6252015-04-17 12:36:38 -0600287 err = vkGetObjectInfo(device(), VK_OBJECT_TYPE_QUERY_POOL, query_pool, VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600288 &data_size, &mem_req);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600289 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600290
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600291 if (mem_req.size) {
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600292
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600293 // VkResult VKAPI vkAllocMemory(
294 // VkDevice device,
295 // const VkMemoryAllocInfo* pAllocInfo,
296 // VkDeviceMemory* pMem);
297 VkMemoryAllocInfo mem_info;
298
299 memset(&mem_info, 0, sizeof(mem_info));
300 mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
301 // TODO: Is a simple multiple all that's needed here?
302 mem_info.allocationSize = mem_req.size * MAX_QUERY_SLOTS;
303 mem_info.memProps = VK_MEMORY_PROPERTY_SHAREABLE_BIT;
304 mem_info.memPriority = VK_MEMORY_PRIORITY_NORMAL;
305 // TODO: Should this be pinned? Or maybe a separate test with pinned.
306 err = vkAllocMemory(device(), &mem_info, &query_mem);
307 ASSERT_VK_SUCCESS(err);
308
309 err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_QUERY_POOL, query_pool, query_mem, 0);
310 ASSERT_VK_SUCCESS(err);
311 }
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600312 // TODO: Test actual synchronization with command buffer event.
313 // TODO: Create command buffer
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600314 // TODO: vkCmdResetQueryPool
315 // TODO: vkCmdBeginQuery
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600316 // TODO: commands
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600317 // TOOD: vkCmdEndQuery
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600318
Mike Stroyan230e6252015-04-17 12:36:38 -0600319 err = vkGetQueryPoolResults(device(), query_pool, 0, MAX_QUERY_SLOTS,
Tony Barbour8205d902015-04-16 15:59:00 -0600320 &query_result_size, VK_NULL_HANDLE, 0);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600321 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600322
323 if (query_result_size > 0) {
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600324 query_result_data = new uint32_t [query_result_size];
Mike Stroyan230e6252015-04-17 12:36:38 -0600325 err = vkGetQueryPoolResults(device(), query_pool, 0, MAX_QUERY_SLOTS,
Tony Barbour8205d902015-04-16 15:59:00 -0600326 &query_result_size, query_result_data, 0);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600327 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600328
329 // TODO: Test Query result data.
330
331 }
332
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600333 if (mem_req.size) {
334 // All done with QueryPool memory, clean up
335 err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_QUERY_POOL, query_pool, VK_NULL_HANDLE, 0);
336 ASSERT_VK_SUCCESS(err);
337 err = vkFreeMemory(device(), query_mem);
338 ASSERT_VK_SUCCESS(err);
339 }
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600340
Mike Stroyan230e6252015-04-17 12:36:38 -0600341 err = vkDestroyObject(device(), VK_OBJECT_TYPE_QUERY_POOL, query_pool);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600342 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600343}
Courtney Goeltzenleuchter6b814b32014-08-12 09:59:36 -0600344
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600345void getQueue(vk_testing::Device *device, uint32_t queue_node_index, const char *qname)
Courtney Goeltzenleuchtercc32aa92014-08-14 10:15:09 -0600346{
347 int que_idx;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600348 VkResult err;
349 VkQueue queue;
Courtney Goeltzenleuchtercc32aa92014-08-14 10:15:09 -0600350
Tony Barbour8205d902015-04-16 15:59:00 -0600351 const VkPhysicalDeviceQueueProperties props = device->gpu().queue_properties()[queue_node_index];
Chia-I Wu3b78d312014-12-29 15:39:23 +0800352 for (que_idx = 0; que_idx < props.queueCount; que_idx++) {
Mark Lobodzinskicf26e072015-04-16 11:44:05 -0500353 // TODO: Need to add support for separate MEMMGR and work queues, including synchronization
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600354 err = vkGetDeviceQueue(device->obj(), queue_node_index, que_idx, &queue);
355 ASSERT_EQ(VK_SUCCESS, err) << "vkGetDeviceQueue: " << qname << " queue #" << que_idx << ": Failed with error: " << vk_result_string(err);
Courtney Goeltzenleuchtercc32aa92014-08-14 10:15:09 -0600356 }
357}
358
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600359void VkTest::CreateImageTest()
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600360{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600361 VkResult err;
362 VkImage image;
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600363 uint32_t w, h, mipCount;
364 size_t size;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600365 VkFormat fmt;
366 VkFormatProperties image_fmt;
Chia-I Wu54ed0792014-12-27 14:14:50 +0800367 size_t data_size;
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600368
369 w =512;
370 h = 256;
371 mipCount = 0;
372
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600373 uint32_t _w = w;
374 uint32_t _h = h;
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600375 while( ( _w > 0 ) || ( _h > 0 ) )
376 {
377 _w >>= 1;
378 _h >>= 1;
379 mipCount++;
380 }
381
Tony Barbour8205d902015-04-16 15:59:00 -0600382 fmt = VK_FORMAT_R8G8B8A8_UINT;
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600383 // TODO: Pick known good format rather than just expect common format
384 /*
385 * XXX: What should happen if given NULL HANDLE for the pData argument?
Tony Barbour8205d902015-04-16 15:59:00 -0600386 * We're not requesting VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS so there is
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600387 * an expectation that pData is a valid pointer.
388 * However, why include a returned size value? That implies that the
389 * amount of data may vary and that doesn't work well for using a
390 * fixed structure.
391 */
392
Jon Ashburnb8e43892014-09-25 14:36:58 -0600393 size = sizeof(image_fmt);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600394 err = vkGetFormatInfo(device(), fmt,
Tony Barbour8205d902015-04-16 15:59:00 -0600395 VK_FORMAT_INFO_TYPE_PROPERTIES,
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600396 &size, &image_fmt);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600397 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600398
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600399// typedef struct VkImageCreateInfo_
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600400// {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600401// VkStructureType sType; // Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600402// const void* pNext; // Pointer to next structure.
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600403// VkImageType imageType;
404// VkFormat format;
405// VkExtent3D extent;
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600406// uint32_t mipLevels;
407// uint32_t arraySize;
408// uint32_t samples;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600409// VkImageTiling tiling;
410// VkFlags usage; // VkImageUsageFlags
411// VkFlags flags; // VkImageCreateFlags
412// } VkImageCreateInfo;
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600413
414
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600415 VkImageCreateInfo imageCreateInfo = {};
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600416 imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
Tony Barbour8205d902015-04-16 15:59:00 -0600417 imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600418 imageCreateInfo.format = fmt;
419 imageCreateInfo.arraySize = 1;
420 imageCreateInfo.extent.width = w;
421 imageCreateInfo.extent.height = h;
422 imageCreateInfo.extent.depth = 1;
423 imageCreateInfo.mipLevels = mipCount;
424 imageCreateInfo.samples = 1;
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600425 if (image_fmt.linearTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) {
426 imageCreateInfo.tiling = VK_IMAGE_TILING_LINEAR;
427 }
428 else if (image_fmt.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) {
429 imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
430 }
431 else {
432 FAIL() << "Neither Linear nor Optimal allowed for color attachment";
433 }
Courtney Goeltzenleuchterad870812015-04-15 15:29:59 -0600434 imageCreateInfo.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600435
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600436// VkResult VKAPI vkCreateImage(
437// VkDevice device,
438// const VkImageCreateInfo* pCreateInfo,
439// VkImage* pImage);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600440 err = vkCreateImage(device(), &imageCreateInfo, &image);
441 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600442
Courtney Goeltzenleuchterac3b73a2014-08-14 17:40:57 -0600443 // Verify image resources
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600444// VkResult VKAPI vkGetImageSubresourceInfo(
445// VkImage image,
446// const VkImageSubresource* pSubresource,
447// VkSubresourceInfoType infoType,
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600448// size_t* pDataSize,
449// void* pData);
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600450// typedef struct VkSubresourceLayout_
Courtney Goeltzenleuchterac3b73a2014-08-14 17:40:57 -0600451// {
Tony Barbour8205d902015-04-16 15:59:00 -0600452// VkDeviceSize offset; // Specified in bytes
453// VkDeviceSize size; // Specified in bytes
454// VkDeviceSize rowPitch; // Specified in bytes
455// VkDeviceSize depthPitch; // Specified in bytes
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600456// } VkSubresourceLayout;
Courtney Goeltzenleuchterac3b73a2014-08-14 17:40:57 -0600457
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600458// typedef struct VkImageSubresource_
Courtney Goeltzenleuchterac3b73a2014-08-14 17:40:57 -0600459// {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600460// VkImageAspect aspect;
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600461// uint32_t mipLevel;
462// uint32_t arraySlice;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600463// } VkImageSubresource;
464// typedef enum VkSubresourceInfoType_
Courtney Goeltzenleuchterac3b73a2014-08-14 17:40:57 -0600465// {
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600466// // Info type for vkGetImageSubresourceInfo()
Tony Barbour8205d902015-04-16 15:59:00 -0600467// VK_SUBRESOURCE_INFO_TYPE_LAYOUT = 0x00000000,
Courtney Goeltzenleuchterac3b73a2014-08-14 17:40:57 -0600468
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600469// VK_MAX_ENUM(VkSubresourceInfoType_)
470// } VkSubresourceInfoType;
Courtney Goeltzenleuchterac3b73a2014-08-14 17:40:57 -0600471
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600472 if (image_fmt.linearTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) {
473 VkImageSubresource subresource = {};
474 subresource.aspect = VK_IMAGE_ASPECT_COLOR;
475 subresource.arraySlice = 0;
Courtney Goeltzenleuchterac3b73a2014-08-14 17:40:57 -0600476
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600477 _w = w;
478 _h = h;
479 while ((_w > 0) || (_h > 0))
480 {
481 VkSubresourceLayout layout = {};
482 data_size = sizeof(layout);
483 err = vkGetImageSubresourceInfo(device(), image, &subresource, VK_SUBRESOURCE_INFO_TYPE_LAYOUT,
484 &data_size, &layout);
485 ASSERT_VK_SUCCESS(err);
486 ASSERT_EQ(sizeof(VkSubresourceLayout), data_size) << "Invalid structure (VkSubresourceLayout) size";
Courtney Goeltzenleuchterac3b73a2014-08-14 17:40:57 -0600487
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600488 // TODO: 4 should be replaced with pixel size for given format
489 EXPECT_LE(_w * 4, layout.rowPitch) << "Pitch does not match expected image pitch";
490 _w >>= 1;
491 _h >>= 1;
492
493 subresource.mipLevel++;
494 }
Courtney Goeltzenleuchterac3b73a2014-08-14 17:40:57 -0600495 }
496
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600497 VkMemoryRequirements mem_req;
Tony Barbour8205d902015-04-16 15:59:00 -0600498 VkDeviceMemory image_mem;
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600499
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600500 data_size = sizeof(mem_req);
501 err = vkGetObjectInfo(device(), VK_OBJECT_TYPE_IMAGE, image, VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
502 &data_size, &mem_req);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600503 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600504
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600505 if (mem_req.size) {
506
507 // VkResult VKAPI vkAllocMemory(
508 // VkDevice device,
509 // const VkMemoryAllocInfo* pAllocInfo,
510 // VkDeviceMemory* pMem);
511 VkMemoryAllocInfo mem_info = {};
512
513 mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
514 mem_info.pNext = NULL;
515 mem_info.allocationSize = mem_req.size;
516 mem_info.memProps = VK_MEMORY_PROPERTY_SHAREABLE_BIT;
517 mem_info.memPriority = VK_MEMORY_PRIORITY_NORMAL;
518 err = vkAllocMemory(device(), &mem_info, &image_mem);
519 ASSERT_VK_SUCCESS(err);
520
521 err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, image, image_mem, 0);
522 ASSERT_VK_SUCCESS(err);
523 }
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600524
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600525// typedef struct VkImageViewCreateInfo_
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600526// {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600527// VkStructureType sType; // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600528// const void* pNext; // Pointer to next structure
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600529// VkImage image;
530// VkImageViewType viewType;
531// VkFormat format;
532// VkChannelMapping channels;
533// VkImageSubresourceRange subresourceRange;
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600534// float minLod;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600535// } VkImageViewCreateInfo;
536 VkImageViewCreateInfo viewInfo = {};
537 VkImageView view;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600538 viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600539 viewInfo.image = image;
Tony Barbour8205d902015-04-16 15:59:00 -0600540 viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600541 viewInfo.format = fmt;
542
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600543 viewInfo.channels.r = VK_CHANNEL_SWIZZLE_R;
544 viewInfo.channels.g = VK_CHANNEL_SWIZZLE_G;
545 viewInfo.channels.b = VK_CHANNEL_SWIZZLE_B;
546 viewInfo.channels.a = VK_CHANNEL_SWIZZLE_A;
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600547
548 viewInfo.subresourceRange.baseArraySlice = 0;
549 viewInfo.subresourceRange.arraySize = 1;
550 viewInfo.subresourceRange.baseMipLevel = 0;
551 viewInfo.subresourceRange.mipLevels = 1;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600552 viewInfo.subresourceRange.aspect = VK_IMAGE_ASPECT_COLOR;
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600553
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600554// VkResult VKAPI vkCreateImageView(
555// VkDevice device,
556// const VkImageViewCreateInfo* pCreateInfo,
557// VkImageView* pView);
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600558
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600559 err = vkCreateImageView(device(), &viewInfo, &view);
560 ASSERT_VK_SUCCESS(err) << "vkCreateImageView failed";
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600561
562 // TODO: Test image memory.
563
564 // All done with image memory, clean up
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600565 if (mem_req.size) {
566 ASSERT_VK_SUCCESS(vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, image, VK_NULL_HANDLE, 0));
567 ASSERT_VK_SUCCESS(vkFreeMemory(device(), image_mem));
568 }
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600569
Tony Barbourb689eef2015-06-03 11:40:51 -0600570 ASSERT_VK_SUCCESS(vkDestroyObject(device(), VK_OBJECT_TYPE_IMAGE_VIEW, view));
Mike Stroyan230e6252015-04-17 12:36:38 -0600571 ASSERT_VK_SUCCESS(vkDestroyObject(device(), VK_OBJECT_TYPE_IMAGE, image));
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600572}
573
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600574TEST_F(VkTest, CreateImage) {
Courtney Goeltzenleuchter9c3aad02014-08-13 17:55:12 -0600575 CreateImageTest();
Courtney Goeltzenleuchter6b814b32014-08-12 09:59:36 -0600576}
577
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600578void VkTest::CreateCommandBufferTest()
Courtney Goeltzenleuchter0842df72014-08-20 15:26:55 -0600579{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600580 VkResult err;
581 VkCmdBufferCreateInfo info = {};
582 VkCmdBuffer cmdBuffer;
Courtney Goeltzenleuchter0842df72014-08-20 15:26:55 -0600583
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600584// typedef struct VkCmdBufferCreateInfo_
Courtney Goeltzenleuchter0842df72014-08-20 15:26:55 -0600585// {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600586// VkStructureType sType; // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600587// const void* pNext;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600588// VK_QUEUE_TYPE queueType;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600589// VkFlags flags;
590// } VkCmdBufferCreateInfo;
Courtney Goeltzenleuchter0842df72014-08-20 15:26:55 -0600591
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600592 info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO;
Courtney Goeltzenleuchterf3168062015-03-05 18:09:39 -0700593 info.queueNodeIndex = graphics_queue_node_index;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600594 err = vkCreateCommandBuffer(device(), &info, &cmdBuffer);
595 ASSERT_VK_SUCCESS(err) << "vkCreateCommandBuffer failed";
Courtney Goeltzenleuchter0842df72014-08-20 15:26:55 -0600596
Mike Stroyan230e6252015-04-17 12:36:38 -0600597 ASSERT_VK_SUCCESS(vkDestroyObject(device(), VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer));
Courtney Goeltzenleuchter0842df72014-08-20 15:26:55 -0600598}
599
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600600TEST_F(VkTest, TestCommandBuffer) {
Courtney Goeltzenleuchter0842df72014-08-20 15:26:55 -0600601 CreateCommandBufferTest();
602}
603
Tony-LunarGe4fe3152015-05-15 12:42:49 -0600604void VkTest::CreateShader(VkShader *pshader)
Courtney Goeltzenleuchter0842df72014-08-20 15:26:55 -0600605{
Courtney Goeltzenleuchtera693ed22014-08-19 13:34:28 -0600606 void *code;
607 uint32_t codeSize;
Cody Northropacfb0492015-03-17 15:55:58 -0600608 struct icd_spv_header *pSPV;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600609 VkResult err;
Courtney Goeltzenleuchtera693ed22014-08-19 13:34:28 -0600610
Cody Northropacfb0492015-03-17 15:55:58 -0600611 codeSize = sizeof(struct icd_spv_header) + 100;
Courtney Goeltzenleuchtera693ed22014-08-19 13:34:28 -0600612 code = malloc(codeSize);
613 ASSERT_TRUE(NULL != code) << "malloc failed!";
614
615 memset(code, 0, codeSize);
616
Cody Northropacfb0492015-03-17 15:55:58 -0600617 // Indicate that this is SPV data.
618 pSPV = (struct icd_spv_header *) code;
619 pSPV->magic = ICD_SPV_MAGIC;
620 pSPV->version = ICD_SPV_VERSION;
Courtney Goeltzenleuchtera693ed22014-08-19 13:34:28 -0600621
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600622// typedef struct VkShaderCreateInfo_
Courtney Goeltzenleuchtera693ed22014-08-19 13:34:28 -0600623// {
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600624// VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SHADER_CREATE_INFO
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600625// const void* pNext; // Pointer to next structure
626// size_t codeSize; // Specified in bytes
627// const void* pCode;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600628// VkFlags flags; // Reserved
629// } VkShaderCreateInfo;
Courtney Goeltzenleuchtera693ed22014-08-19 13:34:28 -0600630
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600631 VkShaderCreateInfo createInfo;
632 VkShader shader;
Courtney Goeltzenleuchtera693ed22014-08-19 13:34:28 -0600633
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600634 createInfo.sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO;
Courtney Goeltzenleuchtera693ed22014-08-19 13:34:28 -0600635 createInfo.pNext = NULL;
636 createInfo.pCode = code;
637 createInfo.codeSize = codeSize;
638 createInfo.flags = 0;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600639 err = vkCreateShader(device(), &createInfo, &shader);
640 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchtera693ed22014-08-19 13:34:28 -0600641
Courtney Goeltzenleuchter0842df72014-08-20 15:26:55 -0600642 *pshader = shader;
643}
644
Courtney Goeltzenleuchter6b814b32014-08-12 09:59:36 -0600645int main(int argc, char **argv) {
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600646 ::testing::InitGoogleTest(&argc, argv);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600647 vk_testing::set_error_callback(test_error_callback);
Courtney Goeltzenleuchtered56abc2014-08-12 14:12:22 -0600648 return RUN_ALL_TESTS();
Courtney Goeltzenleuchter7087dde2014-08-11 18:19:35 -0600649}