diff --git a/tests/init.cpp b/tests/init.cpp
index e5b18d8..557c390 100644
--- a/tests/init.cpp
+++ b/tests/init.cpp
@@ -487,17 +487,17 @@
 void VkTest::CreateCommandBufferTest()
 {
     VkResult err;
-    VkCmdBufferCreateInfo info = {};
+    VkCmdBufferAllocInfo info = {};
     VkCmdPool cmdPool;
     VkCmdBuffer cmdBuffer;
 
 //    typedef struct VkCmdBufferCreateInfo_
 //    {
-//        VkStructureType                      sType;      // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO
+//        VkStructureType                      sType;      // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO
 //        const void*                             pNext;
 //        VK_QUEUE_TYPE                          queueType;
 //        VkFlags                               flags;
-//    } VkCmdBufferCreateInfo;
+//    } VkCmdBufferAllocInfo;
 
     VkCmdPoolCreateInfo cmd_pool_info;
     cmd_pool_info.sType = VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO,
@@ -507,12 +507,14 @@
     err = vkCreateCommandPool(device(), &cmd_pool_info, &cmdPool);
     ASSERT_VK_SUCCESS(err) << "vkCreateCommandPool failed";
 
-    info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO;
+    info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO;
     info.cmdPool = cmdPool;
-    err = vkCreateCommandBuffer(device(), &info, &cmdBuffer);
-    ASSERT_VK_SUCCESS(err) << "vkCreateCommandBuffer failed";
+    info.count = 1;
+    info.level = VK_CMD_BUFFER_LEVEL_PRIMARY;
+    err = vkAllocCommandBuffers(device(), &info, &cmdBuffer);
+    ASSERT_VK_SUCCESS(err) << "vkAllocCommandBuffers failed";
 
-    vkDestroyCommandBuffer(device(), cmdBuffer);
+    vkFreeCommandBuffers(device(), cmdPool, 1, &cmdBuffer);
     vkDestroyCommandPool(device(), cmdPool);
 }
 
diff --git a/tests/layer_validation_tests.cpp b/tests/layer_validation_tests.cpp
index 08a6479..c28af1e 100644
--- a/tests/layer_validation_tests.cpp
+++ b/tests/layer_validation_tests.cpp
@@ -852,7 +852,6 @@
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
-        ds_pool_ci.poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT;
         ds_pool_ci.maxSets = 1;
         ds_pool_ci.count = 1;
         ds_pool_ci.pTypeCount = &ds_type_count;
@@ -878,7 +877,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 1, &ds_layout, &descriptorSet);
+    VkDescriptorSetAllocInfo alloc_info = {};
+    alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
+    alloc_info.count = 1;
+    alloc_info.descriptorPool = ds_pool;
+    alloc_info.pSetLayouts = &ds_layout;
+    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineLayoutCreateInfo pipeline_layout_ci = {};
@@ -1266,7 +1270,6 @@
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
-        ds_pool_ci.poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT;
         ds_pool_ci.maxSets = 1;
         ds_pool_ci.count = 1;
         ds_pool_ci.pTypeCount = &ds_type_count;
@@ -1292,7 +1295,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 1, &ds_layout, &descriptorSet);
+    VkDescriptorSetAllocInfo alloc_info = {};
+    alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
+    alloc_info.count = 1;
+    alloc_info.descriptorPool = ds_pool;
+    alloc_info.pSetLayouts = &ds_layout;
+    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
     VkPipelineMultisampleStateCreateInfo pipe_ms_state_ci = {};
         pipe_ms_state_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
@@ -1321,7 +1329,7 @@
     pipe.SetMSAA(&pipe_ms_state_ci);
     pipe.CreateVKPipeline(pipeline_layout, renderPass());
     m_errorMonitor->ClearState();
-    // Calls CreateCommandBuffer
+    // Calls AllocCommandBuffers
     VkCommandBufferObj cmdBuffer(m_device, m_cmdPool);
     VkCmdBufferBeginInfo cmd_buf_info = {};
     memset(&cmd_buf_info, 0, sizeof(VkCmdBufferBeginInfo));
@@ -1361,7 +1369,7 @@
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
-        ds_pool_ci.poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT;
+        ds_pool_ci.flags = 0;
         ds_pool_ci.maxSets = 1;
         ds_pool_ci.count = 1;
         ds_pool_ci.pTypeCount = &ds_type_count;
@@ -1387,7 +1395,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 1, &ds_layout, &descriptorSet);
+    VkDescriptorSetAllocInfo alloc_info = {};
+    alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
+    alloc_info.count = 1;
+    alloc_info.descriptorPool = ds_pool;
+    alloc_info.pSetLayouts = &ds_layout;
+    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after alloc descriptor from pool w/o requested type";
@@ -1416,9 +1429,11 @@
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
-        ds_pool_ci.poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT; // Can't free from ONE_SHOT Pool
         ds_pool_ci.maxSets = 1;
         ds_pool_ci.count = 1;
+        ds_pool_ci.flags = 0;
+        // Not specifying VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT means
+        // app can only call vkResetDescriptorPool on this pool.;
         ds_pool_ci.pTypeCount = &ds_type_count;
 
     VkDescriptorPool ds_pool;
@@ -1442,13 +1457,19 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 1, &ds_layout, &descriptorSet);
+    VkDescriptorSetAllocInfo alloc_info = {};
+    alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
+    alloc_info.count = 1;
+    alloc_info.descriptorPool = ds_pool;
+    alloc_info.pSetLayouts = &ds_layout;
+    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     err = vkFreeDescriptorSets(m_device->device(), ds_pool, 1, &descriptorSet);
     msgFlags = m_errorMonitor->GetState(&msgString);
-    ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after freeing descriptor from ONE_SHOT Pool";
-    if (!strstr(msgString.c_str(),"It is invalid to call vkFreeDescriptorSets() with a pool created with usage type VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT.")) {
+    ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after freeing descriptor from non-free Pool";
+
+    if (!strstr(msgString.c_str(),"It is invalid to call vkFreeDescriptorSets() with a pool created without setting VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT.")) {
         FAIL() << "Error received was not 'It is invalid to call vkFreeDescriptorSets() with a pool created with...' but instead it was '" << msgString.c_str() << "'";
     }
 
@@ -1527,7 +1548,6 @@
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
-        ds_pool_ci.poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT;
         ds_pool_ci.maxSets = 1;
         ds_pool_ci.count = 1;
         ds_pool_ci.pTypeCount = &ds_type_count;
@@ -1552,7 +1572,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 1, &ds_layout, &descriptorSet);
+    VkDescriptorSetAllocInfo alloc_info = {};
+    alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
+    alloc_info.count = 1;
+    alloc_info.descriptorPool = ds_pool;
+    alloc_info.pSetLayouts = &ds_layout;
+    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineLayoutCreateInfo pipeline_layout_ci = {};
@@ -1614,7 +1639,7 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     m_errorMonitor->ClearState();
 
-    // Calls CreateCommandBuffer
+    // Calls AllocCommandBuffers
     VkCommandBufferObj cmdBuffer(m_device, m_cmdPool);
 
     // Force the failure by setting the Renderpass and Framebuffer fields with (fake) data
@@ -1632,7 +1657,7 @@
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error passing a non-NULL Framebuffer and Renderpass to BeginCommandBuffer()";
     if (!strstr(msgString.c_str(),"may not specify framebuffer or renderpass parameters")) {
-        FAIL() << "Error received was not 'vkCreateCommandBuffer():  Primary Command Buffer may not specify framebuffer or renderpass parameters'";
+        FAIL() << "Error received was not 'vkAllocCommandBuffers():  Primary Command Buffer may not specify framebuffer or renderpass parameters'";
     }
 }
 
@@ -1647,14 +1672,14 @@
     ASSERT_NO_FATAL_FAILURE(InitState());
     m_errorMonitor->ClearState();
 
-    VkCmdBufferCreateInfo cmd = {};
-    cmd.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO;
+    VkCmdBufferAllocInfo cmd = {};
+    cmd.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO;
     cmd.pNext = NULL;
     cmd.cmdPool = m_cmdPool;
     cmd.level = VK_CMD_BUFFER_LEVEL_SECONDARY;
-    cmd.flags = 0;
+    cmd.count = 1;
 
-    err = vkCreateCommandBuffer(m_device->device(), &cmd, &draw_cmd);
+    err = vkAllocCommandBuffers(m_device->device(), &cmd, &draw_cmd);
     ASSERT_VK_SUCCESS(err);
 
     // Force the failure by not setting the Renderpass and Framebuffer fields
@@ -1669,9 +1694,9 @@
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error passing NULL Framebuffer/Renderpass to BeginCommandBuffer()";
     if (!strstr(msgString.c_str(),"must specify framebuffer and renderpass parameters")) {
-        FAIL() << "Error received was not 'vkCreateCommandBuffer():  Secondary Command Buffer must specify framebuffer and renderpass parameters'";
+        FAIL() << "Error received was not 'vkAllocCommandBuffers():  Secondary Command Buffer must specify framebuffer and renderpass parameters'";
     }
-    vkDestroyCommandBuffer(m_device->device(), draw_cmd);
+    vkFreeCommandBuffers(m_device->device(), m_cmdPool, 1, &draw_cmd);
 }
 
 TEST_F(VkLayerTest, InvalidPipelineCreateState)
@@ -1692,7 +1717,6 @@
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
-        ds_pool_ci.poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT;
         ds_pool_ci.maxSets = 1;
         ds_pool_ci.count = 1;
         ds_pool_ci.pTypeCount = &ds_type_count;
@@ -1718,7 +1742,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 1, &ds_layout, &descriptorSet);
+    VkDescriptorSetAllocInfo alloc_info = {};
+    alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
+    alloc_info.count = 1;
+    alloc_info.descriptorPool = ds_pool;
+    alloc_info.pSetLayouts = &ds_layout;
+    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineLayoutCreateInfo pipeline_layout_ci = {};
@@ -1794,7 +1823,7 @@
         ds_pool_ci.pTypeCount = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, 1, &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), VK_DESCRIPTOR_POOL_USAGE_NON_FREE, 1, &ds_pool_ci, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -1814,7 +1843,7 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 1, &ds_layout, &descriptorSet);
+    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_NON_FREE, 1, &ds_layout, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineLayoutCreateInfo pipeline_layout_ci = {};
@@ -1914,7 +1943,6 @@
 
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
-        ds_pool_ci.poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT;
         ds_pool_ci.maxSets = 1;
         ds_pool_ci.count = 1;
         ds_pool_ci.pTypeCount = &ds_type_count;
@@ -1938,7 +1966,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 1, &ds_layout, &descriptorSet);
+    VkDescriptorSetAllocInfo alloc_info = {};
+    alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
+    alloc_info.count = 1;
+    alloc_info.descriptorPool = ds_pool;
+    alloc_info.pSetLayouts = &ds_layout;
+    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineLayoutCreateInfo pipeline_layout_ci = {};
@@ -2021,7 +2054,6 @@
 
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
-        ds_pool_ci.poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT;
         ds_pool_ci.maxSets = 1;
         ds_pool_ci.count = 1;
         ds_pool_ci.pTypeCount = &ds_type_count;
@@ -2045,7 +2077,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 1, &ds_layout, &descriptorSet);
+    VkDescriptorSetAllocInfo alloc_info = {};
+    alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
+    alloc_info.count = 1;
+    alloc_info.descriptorPool = ds_pool;
+    alloc_info.pSetLayouts = &ds_layout;
+    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineLayoutCreateInfo pipeline_layout_ci = {};
@@ -2127,7 +2164,6 @@
 
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
-        ds_pool_ci.poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT;
         ds_pool_ci.maxSets = 1;
         ds_pool_ci.count = 1;
         ds_pool_ci.pTypeCount = &ds_type_count;
@@ -2151,7 +2187,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 1, &ds_layout, &descriptorSet);
+    VkDescriptorSetAllocInfo alloc_info = {};
+    alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
+    alloc_info.count = 1;
+    alloc_info.descriptorPool = ds_pool;
+    alloc_info.pSetLayouts = &ds_layout;
+    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineLayoutCreateInfo pipeline_layout_ci = {};
@@ -2283,7 +2324,6 @@
 
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
-        ds_pool_ci.poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT;
         ds_pool_ci.maxSets = 1;
         ds_pool_ci.count = 1;
         ds_pool_ci.pTypeCount = &ds_type_count;
@@ -2307,7 +2347,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 1, &ds_layout, &descriptorSet);
+    VkDescriptorSetAllocInfo alloc_info = {};
+    alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
+    alloc_info.count = 1;
+    alloc_info.descriptorPool = ds_pool;
+    alloc_info.pSetLayouts = &ds_layout;
+    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineLayoutCreateInfo pipeline_layout_ci = {};
@@ -2744,7 +2789,6 @@
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
-        ds_pool_ci.poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT;
         ds_pool_ci.maxSets = 1;
         ds_pool_ci.count = 1;
         ds_pool_ci.pTypeCount = &ds_type_count;
@@ -2769,7 +2813,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 1, &ds_layout, &descriptorSet);
+    VkDescriptorSetAllocInfo alloc_info = {};
+    alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
+    alloc_info.count = 1;
+    alloc_info.descriptorPool = ds_pool;
+    alloc_info.pSetLayouts = &ds_layout;
+    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkSamplerCreateInfo sampler_ci = {};
@@ -2837,7 +2886,6 @@
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
-        ds_pool_ci.poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT;
         ds_pool_ci.maxSets = 1;
         ds_pool_ci.count = 1;
         ds_pool_ci.pTypeCount = &ds_type_count;
@@ -2863,7 +2911,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 1, &ds_layout, &descriptorSet);
+    VkDescriptorSetAllocInfo alloc_info = {};
+    alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
+    alloc_info.count = 1;
+    alloc_info.descriptorPool = ds_pool;
+    alloc_info.pSetLayouts = &ds_layout;
+    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkSamplerCreateInfo sampler_ci = {};
@@ -2932,7 +2985,6 @@
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
-        ds_pool_ci.poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT;
         ds_pool_ci.maxSets = 1;
         ds_pool_ci.count = 1;
         ds_pool_ci.pTypeCount = &ds_type_count;
@@ -2957,7 +3009,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 1, &ds_layout, &descriptorSet);
+    VkDescriptorSetAllocInfo alloc_info = {};
+    alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
+    alloc_info.count = 1;
+    alloc_info.descriptorPool = ds_pool;
+    alloc_info.pSetLayouts = &ds_layout;
+    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkSamplerCreateInfo sampler_ci = {};
@@ -3027,7 +3084,6 @@
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
-        ds_pool_ci.poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT;
         ds_pool_ci.maxSets = 1;
         ds_pool_ci.count = 1;
         ds_pool_ci.pTypeCount = &ds_type_count;
@@ -3052,7 +3108,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 1, &ds_layout, &descriptorSet);
+    VkDescriptorSetAllocInfo alloc_info = {};
+    alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
+    alloc_info.count = 1;
+    alloc_info.descriptorPool = ds_pool;
+    alloc_info.pSetLayouts = &ds_layout;
+    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkSamplerCreateInfo sampler_ci = {};
@@ -3120,7 +3181,6 @@
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
-        ds_pool_ci.poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT;
         ds_pool_ci.maxSets = 1;
         ds_pool_ci.count = 1;
         ds_pool_ci.pTypeCount = &ds_type_count;
@@ -3146,7 +3206,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 1, &ds_layout, &descriptorSet);
+    VkDescriptorSetAllocInfo alloc_info = {};
+    alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
+    alloc_info.count = 1;
+    alloc_info.descriptorPool = ds_pool;
+    alloc_info.pSetLayouts = &ds_layout;
+    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineMultisampleStateCreateInfo pipe_ms_state_ci = {};
@@ -3208,7 +3273,6 @@
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
-        ds_pool_ci.poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT;
         ds_pool_ci.maxSets = 1;
         ds_pool_ci.count = 1;
         ds_pool_ci.pTypeCount = &ds_type_count;
@@ -3234,7 +3298,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 1, &ds_layout, &descriptorSet);
+    VkDescriptorSetAllocInfo alloc_info = {};
+    alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
+    alloc_info.count = 1;
+    alloc_info.descriptorPool = ds_pool;
+    alloc_info.pSetLayouts = &ds_layout;
+    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineMultisampleStateCreateInfo pipe_ms_state_ci = {};
@@ -3309,7 +3378,6 @@
     VkDescriptorPoolCreateInfo ds_pool_ci = {};
         ds_pool_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
         ds_pool_ci.pNext = NULL;
-        ds_pool_ci.poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT;
         ds_pool_ci.maxSets = 1;
         ds_pool_ci.count = 1;
         ds_pool_ci.pTypeCount = &ds_type_count;
@@ -3335,7 +3403,12 @@
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
-    err = vkAllocDescriptorSets(m_device->device(), ds_pool, VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, 1, &ds_layout, &descriptorSet);
+    VkDescriptorSetAllocInfo alloc_info = {};
+    alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
+    alloc_info.count = 1;
+    alloc_info.descriptorPool = ds_pool;
+    alloc_info.pSetLayouts = &ds_layout;
+    err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineMultisampleStateCreateInfo pipe_ms_state_ci = {};
@@ -3421,7 +3494,7 @@
 
     m_errorMonitor->ClearState();
 
-    // Calls CreateCommandBuffer
+    // Calls AllocCommandBuffers
     VkCommandBufferObj cmdBuffer(m_device, m_cmdPool);
 
     // Avoid creating RenderPass
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index 86e0a5b..0effd81 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -500,7 +500,6 @@
     VkDescriptorPoolCreateInfo pool = {};
     pool.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
     pool.count = m_type_counts.size();
-    pool.poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT;
     pool.maxSets = 1;
     pool.pTypeCount = m_type_counts.data();
     init(*m_device, pool);
@@ -534,7 +533,7 @@
     m_pipeline_layout.init(*m_device, pipeline_layout, layouts);
 
     // create VkDescriptorSet
-    m_set = alloc_sets(*m_device, VK_DESCRIPTOR_SET_USAGE_STATIC, m_layout);
+    m_set = alloc_sets(*m_device, m_layout);
 
     // build the update array
     size_t imageSamplerCount = 0;
diff --git a/tests/vktestbinding.cpp b/tests/vktestbinding.cpp
index 01c7f45..7182eab 100644
--- a/tests/vktestbinding.cpp
+++ b/tests/vktestbinding.cpp
@@ -748,24 +748,28 @@
 
 void DescriptorPool::init(const Device &dev, const VkDescriptorPoolCreateInfo &info)
 {
-    setDynamicUsage(info.poolUsage == VK_DESCRIPTOR_POOL_USAGE_DYNAMIC);
-
+    setDynamicUsage(info.flags & VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT);
     NON_DISPATCHABLE_HANDLE_INIT(vkCreateDescriptorPool, dev, &info);
 }
 
 void DescriptorPool::reset()
 {
-    EXPECT(vkResetDescriptorPool(device(), handle()) == VK_SUCCESS);
+    EXPECT(vkResetDescriptorPool(device(), handle(), 0) == VK_SUCCESS);
 }
 
-std::vector<DescriptorSet *> DescriptorPool::alloc_sets(const Device &dev, VkDescriptorSetUsage usage, const std::vector<const DescriptorSetLayout *> &layouts)
+std::vector<DescriptorSet *> DescriptorPool::alloc_sets(const Device &dev, const std::vector<const DescriptorSetLayout *> &layouts)
 {
     const std::vector<VkDescriptorSetLayout> layout_handles = make_handles<VkDescriptorSetLayout>(layouts);
 
     std::vector<VkDescriptorSet> set_handles;
     set_handles.resize(layout_handles.size());
 
-    VkResult err = vkAllocDescriptorSets(device(), handle(), usage, layout_handles.size(), layout_handles.data(), set_handles.data());
+    VkDescriptorSetAllocInfo alloc_info = {};
+    alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO;
+    alloc_info.count = layout_handles.size();
+    alloc_info.descriptorPool = handle();
+    alloc_info.pSetLayouts = layout_handles.data();
+    VkResult err = vkAllocDescriptorSets(device(), &alloc_info, set_handles.data());
     EXPECT(err == VK_SUCCESS);
 
     std::vector<DescriptorSet *> sets;
@@ -777,14 +781,14 @@
     return sets;
 }
 
-std::vector<DescriptorSet *> DescriptorPool::alloc_sets(const Device &dev, VkDescriptorSetUsage usage, const DescriptorSetLayout &layout, uint32_t count)
+std::vector<DescriptorSet *> DescriptorPool::alloc_sets(const Device &dev, const DescriptorSetLayout &layout, uint32_t count)
 {
-    return alloc_sets(dev, usage, std::vector<const DescriptorSetLayout *>(count, &layout));
+    return alloc_sets(dev, std::vector<const DescriptorSetLayout *>(count, &layout));
 }
 
-DescriptorSet *DescriptorPool::alloc_sets(const Device &dev, VkDescriptorSetUsage usage, const DescriptorSetLayout &layout)
+DescriptorSet *DescriptorPool::alloc_sets(const Device &dev, const DescriptorSetLayout &layout)
 {
-    std::vector<DescriptorSet *> set = alloc_sets(dev, usage, layout, 1);
+    std::vector<DescriptorSet *> set = alloc_sets(dev, layout, 1);
     return (set.empty()) ? NULL : set[0];
 }
 
@@ -809,20 +813,23 @@
 
 CmdBuffer::~CmdBuffer()
 {
-    if (initialized())
-        vkDestroyCommandBuffer(dev_handle_, handle());
+    if (initialized()) {
+        VkCmdBuffer cmds[] = { handle() };
+        vkFreeCommandBuffers(dev_handle_, cmd_pool_, 1, cmds);
+    }
 }
 
-void CmdBuffer::init(const Device &dev, const VkCmdBufferCreateInfo &info)
+void CmdBuffer::init(const Device &dev, const VkCmdBufferAllocInfo &info)
 {
     VkCmdBuffer cmd;
 
     // Make sure cmdPool is set
     assert(info.cmdPool);
 
-    if (EXPECT(vkCreateCommandBuffer(dev.handle(), &info, &cmd) == VK_SUCCESS)) {
+    if (EXPECT(vkAllocCommandBuffers(dev.handle(), &info, &cmd) == VK_SUCCESS)) {
         Handle::init(cmd);
         dev_handle_ = dev.handle();
+        cmd_pool_ = info.cmdPool;
     }
 }
 
diff --git a/tests/vktestbinding.h b/tests/vktestbinding.h
index 09d8109..5fdc1aa 100644
--- a/tests/vktestbinding.h
+++ b/tests/vktestbinding.h
@@ -535,9 +535,9 @@
     bool getDynamicUsage() { return dynamic_usage_; }
 
     // vkAllocDescriptorSets()
-    std::vector<DescriptorSet *> alloc_sets(const Device &dev, VkDescriptorSetUsage usage, const std::vector<const DescriptorSetLayout *> &layouts);
-    std::vector<DescriptorSet *> alloc_sets(const Device &dev, VkDescriptorSetUsage usage, const DescriptorSetLayout &layout, uint32_t count);
-    DescriptorSet *alloc_sets(const Device &dev, VkDescriptorSetUsage usage, const DescriptorSetLayout &layout);
+    std::vector<DescriptorSet *> alloc_sets(const Device &dev, const std::vector<const DescriptorSetLayout *> &layouts);
+    std::vector<DescriptorSet *> alloc_sets(const Device &dev, const DescriptorSetLayout &layout, uint32_t count);
+    DescriptorSet *alloc_sets(const Device &dev, const DescriptorSetLayout &layout);
 
 private:
     VkDescriptorPool pool_;
@@ -582,10 +582,10 @@
     ~CmdBuffer();
 
     explicit CmdBuffer() : Handle() {}
-    explicit CmdBuffer(const Device &dev, const VkCmdBufferCreateInfo &info) { init(dev, info); }
+    explicit CmdBuffer(const Device &dev, const VkCmdBufferAllocInfo &info) { init(dev, info); }
 
-    // vkCreateCommandBuffer()
-    void init(const Device &dev, const VkCmdBufferCreateInfo &info);
+    // vkAllocCommandBuffers()
+    void init(const Device &dev, const VkCmdBufferAllocInfo &info);
 
     // vkBeginCommandBuffer()
     void begin(const VkCmdBufferBeginInfo *info);
@@ -597,10 +597,11 @@
     void reset(VkCmdBufferResetFlags flags);
     void reset() { reset(VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT); }
 
-    static VkCmdBufferCreateInfo create_info(VkCmdPool const &pool);
+    static VkCmdBufferAllocInfo create_info(VkCmdPool const &pool);
 
 private:
     VkDevice dev_handle_;
+    VkCmdPool cmd_pool_;
 };
 
 inline VkMemoryAllocInfo DeviceMemory::alloc_info(VkDeviceSize size, uint32_t memory_type_index)
@@ -841,11 +842,12 @@
     return copy;
 }
 
-inline VkCmdBufferCreateInfo CmdBuffer::create_info(VkCmdPool const &pool)
+inline VkCmdBufferAllocInfo CmdBuffer::create_info(VkCmdPool const &pool)
 {
-    VkCmdBufferCreateInfo info = {};
-    info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO;
+    VkCmdBufferAllocInfo info = {};
+    info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO;
     info.cmdPool = pool;
+    info.count = 1;
     return info;
 }