diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1697736..07deeeb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -46,7 +46,7 @@
     set(PYTHON_CMD "py")
 endif()
 
-option(BUILD_TESTS "Build tests" OFF)
+option(BUILD_TESTS "Build tests" ON)
 
 # loader: Generic VULKAN ICD loader
 # icd: Device dependent (DD) VULKAN components
diff --git a/tests/blit_tests.cpp b/tests/blit_tests.cpp
index fc511d8..d7d0762 100644
--- a/tests/blit_tests.cpp
+++ b/tests/blit_tests.cpp
@@ -748,11 +748,8 @@
     vk_testing::Buffer bufs[3];
     VkEventCreateInfo event_info;
     VkEvent event;
-    VkMemoryRequirements mem_req;
     VkResult err;
     VkMemoryPropertyFlags reqs = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
-    VkMemoryAllocInfo mem_info;
-    VkDeviceMemory event_mem;
 
     //        typedef struct VkEventCreateInfo_
     //        {
@@ -766,26 +763,6 @@
     err = vkCreateEvent(dev_.handle(), &event_info, &event);
     ASSERT_VK_SUCCESS(err);
 
-    err = vkGetObjectMemoryRequirements(dev_.handle(), VK_OBJECT_TYPE_EVENT, event, &mem_req);
-    ASSERT_VK_SUCCESS(err);
-
-    if (mem_req.size) {
-
-        memset(&mem_info, 0, sizeof(mem_info));
-        mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
-        mem_info.allocationSize = mem_req.size;
-        mem_info.memoryTypeIndex = 0;
-
-        err = dev_.phy().set_memory_type(mem_req.memoryTypeBits, &mem_info, 0);
-        ASSERT_VK_SUCCESS(err);
-
-        err = vkAllocMemory(dev_.handle(), &mem_info, &event_mem);
-        ASSERT_VK_SUCCESS(err);
-
-        err = vkBindObjectMemory(dev_.handle(), VK_OBJECT_TYPE_EVENT, event, event_mem, 0);
-        ASSERT_VK_SUCCESS(err);
-    }
-
     err = vkResetEvent(dev_.handle(), event);
     ASSERT_VK_SUCCESS(err);
 
@@ -840,14 +817,9 @@
     EXPECT_EQ(0x11111111, data[0]);
     bufs[2].memory().unmap();
 
-    err = vkDestroyObject(dev_.handle(), VK_OBJECT_TYPE_EVENT, event);
+    err = vkDestroyEvent(dev_.handle(), event);
     ASSERT_VK_SUCCESS(err);
 
-    if (mem_req.size) {
-        // All done with event memory, clean up
-        err = vkFreeMemory(dev_.handle(), event_mem);
-        ASSERT_VK_SUCCESS(err);
-    }
 }
 
 class VkCmdBlitImageTest : public VkCmdBlitTest {
diff --git a/tests/image_tests.cpp b/tests/image_tests.cpp
index 6193dca..0504d96 100644
--- a/tests/image_tests.cpp
+++ b/tests/image_tests.cpp
@@ -218,7 +218,7 @@
     mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
     mem_info.pNext = NULL;
 
-    err = vkGetObjectMemoryRequirements(device(), VK_OBJECT_TYPE_IMAGE, m_image, &mem_req);
+    err = vkGetImageMemoryRequirements(device(), m_image, &mem_req);
     ASSERT_VK_SUCCESS(err);
 
     ASSERT_NE(0, mem_req.size) << "vkGetObjectMemoryRequirements (Image): Failed - expect images to require memory";
@@ -233,7 +233,7 @@
     ASSERT_VK_SUCCESS(err);
 
     /* bind memory */
-    err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, m_image, m_image_mem, 0);
+    err = vkBindImageMemory(device(), m_image, m_image_mem, 0);
     ASSERT_VK_SUCCESS(err);
 }
 
@@ -244,7 +244,7 @@
     err = vkFreeMemory(device(), m_image_mem);
     ASSERT_VK_SUCCESS(err);
 
-    ASSERT_VK_SUCCESS(vkDestroyObject(device(), VK_OBJECT_TYPE_IMAGE, m_image));
+    ASSERT_VK_SUCCESS(vkDestroyImage(device(), m_image));
 }
 
 void VkImageTest::CreateImageView(VkImageViewCreateInfo *pCreateInfo,
@@ -256,7 +256,7 @@
 
 void VkImageTest::DestroyImageView(VkImageView imageView)
 {
-    ASSERT_VK_SUCCESS(vkDestroyObject(device(), VK_OBJECT_TYPE_IMAGE_VIEW, imageView));
+    ASSERT_VK_SUCCESS(vkDestroyImageView(device(), imageView));
 }
 
 TEST_F(VkImageTest, CreateImageViewTest) {
diff --git a/tests/init.cpp b/tests/init.cpp
index 4c1881e..d298fc1 100644
--- a/tests/init.cpp
+++ b/tests/init.cpp
@@ -169,8 +169,6 @@
 TEST_F(VkTest, Event) {
     VkEventCreateInfo event_info;
     VkEvent event;
-    VkMemoryRequirements mem_req;
-    VkDeviceMemory event_mem;
     VkResult err;
 
     //        typedef struct VkEventCreateInfo_
@@ -185,31 +183,6 @@
     err = vkCreateEvent(device(), &event_info, &event);
     ASSERT_VK_SUCCESS(err);
 
-    err = vkGetObjectMemoryRequirements(device(), VK_OBJECT_TYPE_EVENT, event, &mem_req);
-    ASSERT_VK_SUCCESS(err);
-
-    if (mem_req.size) {
-
-        //        VkResult VKAPI vkAllocMemory(
-        //            VkDevice                                  device,
-        //            const VkMemoryAllocInfo*                pAllocInfo,
-        //            VkDeviceMemory*                             pMem);
-        VkMemoryAllocInfo mem_info;
-
-        memset(&mem_info, 0, sizeof(mem_info));
-        mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
-        mem_info.allocationSize = mem_req.size;
-        mem_info.memoryTypeIndex = 0;
-
-        err = m_device->phy().set_memory_type(mem_req.memoryTypeBits, &mem_info, 0);
-        ASSERT_VK_SUCCESS(err);
-
-        err = vkAllocMemory(device(), &mem_info, &event_mem);
-        ASSERT_VK_SUCCESS(err);
-
-        err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_EVENT, event, event_mem, 0);
-        ASSERT_VK_SUCCESS(err);
-    }
     err = vkResetEvent(device(), event);
     ASSERT_VK_SUCCESS(err);
 
@@ -225,13 +198,8 @@
     // TODO: Test actual synchronization with command buffer event.
 
     // All done with event memory, clean up
-    err = vkDestroyObject(device(), VK_OBJECT_TYPE_EVENT, event);
+    err = vkDestroyEvent(device(), event);
     ASSERT_VK_SUCCESS(err);
-
-    if (mem_req.size) {
-        err = vkFreeMemory(device(), event_mem);
-        ASSERT_VK_SUCCESS(err);
-    }
 }
 
 #define MAX_QUERY_SLOTS 10
@@ -239,10 +207,8 @@
 TEST_F(VkTest, Query) {
     VkQueryPoolCreateInfo query_info;
     VkQueryPool query_pool;
-    VkMemoryRequirements mem_req;
     size_t query_result_size;
     uint32_t *query_result_data;
-    VkDeviceMemory query_mem;
     VkResult err;
 
     //        typedef enum VkQueryType_
@@ -277,32 +243,6 @@
     err = vkCreateQueryPool(device(), &query_info, &query_pool);
     ASSERT_VK_SUCCESS(err);
 
-    err = vkGetObjectMemoryRequirements(device(), VK_OBJECT_TYPE_QUERY_POOL, query_pool, &mem_req);
-    ASSERT_VK_SUCCESS(err);
-
-    if (mem_req.size) {
-
-        //        VkResult VKAPI vkAllocMemory(
-        //            VkDevice                                  device,
-        //            const VkMemoryAllocInfo*                pAllocInfo,
-        //            VkDeviceMemory*                             pMem);
-        VkMemoryAllocInfo mem_info;
-
-        memset(&mem_info, 0, sizeof(mem_info));
-        mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
-        // TODO: Is a simple multiple all that's needed here?
-        mem_info.allocationSize = mem_req.size * MAX_QUERY_SLOTS;
-        mem_info.memoryTypeIndex = 0;
-
-        err = m_device->phy().set_memory_type(mem_req.memoryTypeBits, &mem_info, 0);
-        ASSERT_VK_SUCCESS(err);
-
-        err = vkAllocMemory(device(), &mem_info, &query_mem);
-        ASSERT_VK_SUCCESS(err);
-
-        err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_QUERY_POOL, query_pool, query_mem, 0);
-        ASSERT_VK_SUCCESS(err);
-    }
     // TODO: Test actual synchronization with command buffer event.
     // TODO: Create command buffer
     // TODO: vkCmdResetQueryPool
@@ -324,14 +264,8 @@
 
     }
 
-    err = vkDestroyObject(device(), VK_OBJECT_TYPE_QUERY_POOL, query_pool);
+    err = vkDestroyQueryPool(device(), query_pool);
     ASSERT_VK_SUCCESS(err);
-
-    if (mem_req.size) {
-        // All done with QueryPool memory, clean up
-        err = vkFreeMemory(device(), query_mem);
-        ASSERT_VK_SUCCESS(err);
-    }
 }
 
 void getQueue(vk_testing::Device *device, uint32_t queue_node_index, const char *qname)
@@ -474,7 +408,7 @@
     VkMemoryRequirements mem_req;
     VkDeviceMemory image_mem;
 
-    err = vkGetObjectMemoryRequirements(device(), VK_OBJECT_TYPE_IMAGE, image, &mem_req);
+    err = vkGetImageMemoryRequirements(device(), image, &mem_req);
     ASSERT_VK_SUCCESS(err);
 
     if (mem_req.size) {
@@ -496,7 +430,7 @@
         err = vkAllocMemory(device(), &mem_info, &image_mem);
         ASSERT_VK_SUCCESS(err);
 
-        err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, image, image_mem, 0);
+        err = vkBindImageMemory(device(), image, image_mem, 0);
         ASSERT_VK_SUCCESS(err);
     }
 
@@ -540,8 +474,8 @@
     // TODO: Test image memory.
 
     // All done with image memory, clean up
-    ASSERT_VK_SUCCESS(vkDestroyObject(device(), VK_OBJECT_TYPE_IMAGE_VIEW, view));
-    ASSERT_VK_SUCCESS(vkDestroyObject(device(), VK_OBJECT_TYPE_IMAGE, image));
+    ASSERT_VK_SUCCESS(vkDestroyImageView(device(), view));
+    ASSERT_VK_SUCCESS(vkDestroyImage(device(), image));
 
     if (mem_req.size) {
         ASSERT_VK_SUCCESS(vkFreeMemory(device(), image_mem));
@@ -571,7 +505,7 @@
     err = vkCreateCommandBuffer(device(), &info, &cmdBuffer);
     ASSERT_VK_SUCCESS(err) << "vkCreateCommandBuffer failed";
 
-    ASSERT_VK_SUCCESS(vkDestroyObject(device(), VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer));
+    ASSERT_VK_SUCCESS(vkDestroyCommandBuffer(device(), cmdBuffer));
 }
 
 TEST_F(VkTest, TestCommandBuffer) {
@@ -617,7 +551,7 @@
     err = vkCreateShader(device(), &createInfo, &shader);
     ASSERT_VK_SUCCESS(err);
 
-    err = vkDestroyObject(device(), VK_OBJECT_TYPE_SHADER_MODULE, module);
+    err = vkDestroyShaderModule(device(), module);
     ASSERT_VK_SUCCESS(err);
 
     *pshader = shader;
diff --git a/tests/layer_validation_tests.cpp b/tests/layer_validation_tests.cpp
index b37511d..14d4a51 100644
--- a/tests/layer_validation_tests.cpp
+++ b/tests/layer_validation_tests.cpp
@@ -61,9 +61,9 @@
         "}\n";
 
 static void myDbgFunc(
-    VkFlags                    msgFlags,
-    VkObjectType                        objType,
-    VkObject                            srcObject,
+    VkFlags                             msgFlags,
+    VkDbgObjectType                     objType,
+    uint64_t                            srcObject,
     size_t                              location,
     int32_t                             msgCode,
     const char*                         pLayerPrefix,
@@ -121,8 +121,8 @@
 
 static void myDbgFunc(
     VkFlags                    msgFlags,
-    VkObjectType               objType,
-    VkObject                   srcObject,
+    VkDbgObjectType            objType,
+    uint64_t                   srcObject,
     size_t                     location,
     int32_t                    msgCode,
     const char*                pLayerPrefix,
@@ -298,16 +298,16 @@
 
     cmdBuffer->PrepareAttachments();
     if ((failMask & BsoFailRaster) != BsoFailRaster) {
-        cmdBuffer->BindStateObject(VK_STATE_BIND_POINT_RASTER, m_stateRaster);
+        cmdBuffer->BindDynamicRasterState(m_stateRaster);
     }
     if ((failMask & BsoFailViewport) != BsoFailViewport) {
-        cmdBuffer->BindStateObject(VK_STATE_BIND_POINT_VIEWPORT, m_stateViewport);
+        cmdBuffer->BindDynamicViewportState(m_stateViewport);
     }
     if ((failMask & BsoFailColorBlend) != BsoFailColorBlend) {
-        cmdBuffer->BindStateObject(VK_STATE_BIND_POINT_COLOR_BLEND, m_colorBlend);
+        cmdBuffer->BindDynamicColorBlendState(m_colorBlend);
     }
     if ((failMask & BsoFailDepthStencil) != BsoFailDepthStencil) {
-        cmdBuffer->BindStateObject(VK_STATE_BIND_POINT_DEPTH_STENCIL, m_stateDepthStencil);
+        cmdBuffer->BindDynamicDepthStencilState(m_stateDepthStencil);
     }
     // Make sure depthWriteEnable is set so that DepthStencil fail test will work correctly
     VkStencilOpState stencil = {
@@ -461,8 +461,7 @@
     err = vkCreateImage(m_device->device(), &image_create_info, &image);
     ASSERT_VK_SUCCESS(err);
 
-    err = vkGetObjectMemoryRequirements(m_device->device(),
-                          VK_OBJECT_TYPE_IMAGE,
+    err = vkGetImageMemoryRequirements(m_device->device(),
                           image,
                           &mem_reqs);
     ASSERT_VK_SUCCESS(err);
@@ -474,7 +473,7 @@
     ASSERT_VK_SUCCESS(err);
 
     // Try to bind free memory that has been freed
-    err = vkBindObjectMemory(m_device->device(), VK_OBJECT_TYPE_IMAGE, image, mem, 0);
+    err = vkBindImageMemory(m_device->device(), image, mem, 0);
     ASSERT_VK_SUCCESS(err);
 
     // Map memory as if to initialize the image
@@ -529,8 +528,7 @@
     err = vkCreateImage(m_device->device(), &image_create_info, &image);
     ASSERT_VK_SUCCESS(err);
 
-    err = vkGetObjectMemoryRequirements(m_device->device(),
-                          VK_OBJECT_TYPE_IMAGE,
+    err = vkGetImageMemoryRequirements(m_device->device(),
                           image,
                           &mem_reqs);
     ASSERT_VK_SUCCESS(err);
@@ -549,7 +547,7 @@
     ASSERT_VK_SUCCESS(err);
 
     // Try to bind free memory that has been freed
-    err = vkBindObjectMemory(m_device->device(), VK_OBJECT_TYPE_IMAGE, image, mem, 0);
+    err = vkBindImageMemory(m_device->device(), image, mem, 0);
     ASSERT_VK_SUCCESS(err);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
@@ -600,8 +598,7 @@
     err = vkCreateImage(m_device->device(), &image_create_info, &image);
     ASSERT_VK_SUCCESS(err);
 
-    err = vkGetObjectMemoryRequirements(m_device->device(),
-                          VK_OBJECT_TYPE_IMAGE,
+    err = vkGetImageMemoryRequirements(m_device->device(),
                           image,
                           &mem_reqs);
     ASSERT_VK_SUCCESS(err);
@@ -616,7 +613,7 @@
     ASSERT_VK_SUCCESS(err);
 
     // Bind memory to Image object
-    err = vkBindObjectMemory(m_device->device(), VK_OBJECT_TYPE_IMAGE, image, mem, 0);
+    err = vkBindImageMemory(m_device->device(), image, mem, 0);
     ASSERT_VK_SUCCESS(err);
 
     // Introduce validation failure, free memory while still bound to object
@@ -672,8 +669,7 @@
     err = vkCreateImage(m_device->device(), &image_create_info, &image);
     ASSERT_VK_SUCCESS(err);
 
-    err = vkGetObjectMemoryRequirements(m_device->device(),
-                          VK_OBJECT_TYPE_IMAGE,
+    err = vkGetImageMemoryRequirements(m_device->device(),
                           image,
                           &mem_reqs);
     ASSERT_VK_SUCCESS(err);
@@ -689,11 +685,11 @@
     ASSERT_VK_SUCCESS(err);
 
     // Bind first memory object to Image object
-    err = vkBindObjectMemory(m_device->device(), VK_OBJECT_TYPE_IMAGE, image, mem1, 0);
+    err = vkBindImageMemory(m_device->device(), image, mem1, 0);
     ASSERT_VK_SUCCESS(err);
 
     // Introduce validation failure, try to bind a different memory object to the same image object
-    err = vkBindObjectMemory(m_device->device(), VK_OBJECT_TYPE_IMAGE, image, mem2, 0);
+    err = vkBindImageMemory(m_device->device(), image, mem2, 0);
     ASSERT_VK_SUCCESS(err);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
@@ -744,8 +740,7 @@
     err = vkCreateImage(m_device->device(), &image_create_info, &image);
     ASSERT_VK_SUCCESS(err);
 
-    err = vkGetObjectMemoryRequirements(m_device->device(),
-                          VK_OBJECT_TYPE_IMAGE,
+    err = vkGetImageMemoryRequirements(m_device->device(),
                           image,
                           &mem_reqs);
     ASSERT_VK_SUCCESS(err);
@@ -759,11 +754,11 @@
     ASSERT_VK_SUCCESS(err);
 
     // Introduce validation failure, destroy Image object before binding
-    vkDestroyObject(m_device->device(), VK_OBJECT_TYPE_IMAGE, image);
+    vkDestroyImage(m_device->device(), image);
     ASSERT_VK_SUCCESS(err);
 
     // Now Try to bind memory to this destroyted object
-    err = vkBindObjectMemory(m_device->device(), VK_OBJECT_TYPE_IMAGE, image, mem, 0);
+    err = vkBindImageMemory(m_device->device(), image, mem, 0);
     ASSERT_VK_SUCCESS(err);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
@@ -2288,7 +2283,6 @@
 
     VkEventCreateInfo event_info;
     VkEvent event;
-    VkMemoryRequirements mem_req;
     VkResult err;
 
     memset(&event_info, 0, sizeof(event_info));
@@ -2297,26 +2291,6 @@
     err = vkCreateEvent(device(), &event_info, &event);
     ASSERT_VK_SUCCESS(err);
 
-    err = vkGetObjectMemoryRequirements(device(), VK_OBJECT_TYPE_EVENT, event, &mem_req);
-    ASSERT_VK_SUCCESS(err);
-
-    VkMemoryAllocInfo mem_info;
-    VkDeviceMemory event_mem;
-
-    memset(&mem_info, 0, sizeof(mem_info));
-    mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
-    mem_info.allocationSize = mem_req.size;
-    mem_info.memoryTypeIndex = 0;
-
-    err = m_device->phy().set_memory_type(mem_req.memoryTypeBits, &mem_info, 0);
-    ASSERT_VK_SUCCESS(err);
-
-    err = vkAllocMemory(device(), &mem_info, &event_mem);
-    ASSERT_VK_SUCCESS(err);
-
-    err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_EVENT, event, event_mem, 0);
-    ASSERT_VK_SUCCESS(err);
-
     err = vkResetEvent(device(), event);
     ASSERT_VK_SUCCESS(err);
 
diff --git a/tests/render_tests.cpp b/tests/render_tests.cpp
index 1bb54ab..7d0749d 100644
--- a/tests/render_tests.cpp
+++ b/tests/render_tests.cpp
@@ -344,10 +344,10 @@
     }
 
     cmdBuffer->PrepareAttachments();
-    cmdBuffer->BindStateObject(VK_STATE_BIND_POINT_RASTER, m_stateRaster);
-    cmdBuffer->BindStateObject(VK_STATE_BIND_POINT_VIEWPORT, m_stateViewport);
-    cmdBuffer->BindStateObject(VK_STATE_BIND_POINT_COLOR_BLEND, m_colorBlend);
-    cmdBuffer->BindStateObject(VK_STATE_BIND_POINT_DEPTH_STENCIL, m_stateDepthStencil);
+    cmdBuffer->BindDynamicRasterState(m_stateRaster);
+    cmdBuffer->BindDynamicViewportState(m_stateViewport);
+    cmdBuffer->BindDynamicColorBlendState(m_colorBlend);
+    cmdBuffer->BindDynamicDepthStencilState(m_stateDepthStencil);
     descriptorSet.CreateVKDescriptorSet(cmdBuffer);
     pipelineobj.CreateVKPipeline(descriptorSet, renderPass());
     cmdBuffer->BindPipeline(pipelineobj);
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index cd8ec6b..4b45f10 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -146,22 +146,22 @@
 
 void VkRenderFramework::ShutdownFramework()
 {
-    if (m_colorBlend) vkDestroyObject(device(), VK_OBJECT_TYPE_DYNAMIC_CB_STATE, m_colorBlend);
-    if (m_stateDepthStencil) vkDestroyObject(device(), VK_OBJECT_TYPE_DYNAMIC_DS_STATE, m_stateDepthStencil);
-    if (m_stateRaster) vkDestroyObject(device(), VK_OBJECT_TYPE_DYNAMIC_RS_STATE, m_stateRaster);
-    if (m_cmdBuffer) vkDestroyObject(device(), VK_OBJECT_TYPE_COMMAND_BUFFER, m_cmdBuffer);
-    if (m_framebuffer) vkDestroyObject(device(), VK_OBJECT_TYPE_FRAMEBUFFER, m_framebuffer);
-    if (m_renderPass) vkDestroyObject(device(), VK_OBJECT_TYPE_RENDER_PASS, m_renderPass);
+    if (m_colorBlend) vkDestroyDynamicColorBlendState(device(), m_colorBlend);
+    if (m_stateDepthStencil) vkDestroyDynamicDepthStencilState(device(), m_stateDepthStencil);
+    if (m_stateRaster) vkDestroyDynamicRasterState(device(), m_stateRaster);
+    if (m_cmdBuffer) vkDestroyCommandBuffer(device(), m_cmdBuffer);
+    if (m_framebuffer) vkDestroyFramebuffer(device(), m_framebuffer);
+    if (m_renderPass) vkDestroyRenderPass(device(), m_renderPass);
 
     if (m_globalMsgCallback) m_dbgDestroyMsgCallback(this->inst, m_globalMsgCallback);
     if (m_devMsgCallback) m_dbgDestroyMsgCallback(this->inst, m_devMsgCallback);
 
     if (m_stateViewport) {
-        vkDestroyObject(device(), VK_OBJECT_TYPE_DYNAMIC_VP_STATE, m_stateViewport);
+        vkDestroyDynamicViewportState(device(), m_stateViewport);
     }
     while (!m_renderTargets.empty()) {
-        vkDestroyObject(device(), VK_OBJECT_TYPE_ATTACHMENT_VIEW, m_renderTargets.back()->targetView());
-        vkDestroyObject(device(), VK_OBJECT_TYPE_IMAGE, m_renderTargets.back()->image());
+        vkDestroyAttachmentView(device(), m_renderTargets.back()->targetView());
+        vkDestroyImage(device(), m_renderTargets.back()->image());
         vkFreeMemory(device(), m_renderTargets.back()->memory());
         m_renderTargets.pop_back();
     }
@@ -180,14 +180,14 @@
     m_render_target_fmt = VK_FORMAT_B8G8R8A8_UNORM;
 
     // create a raster state (solid, back-face culling)
-    VkDynamicRsStateCreateInfo raster = {};
-    raster.sType = VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO;
+    VkDynamicRasterStateCreateInfo raster = {};
+    raster.sType = VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO;
 
     err = vkCreateDynamicRasterState( device(), &raster, &m_stateRaster );
     ASSERT_VK_SUCCESS(err);
 
-    VkDynamicCbStateCreateInfo blend = {};
-    blend.sType = VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO;
+    VkDynamicColorBlendStateCreateInfo blend = {};
+    blend.sType = VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO;
     blend.blendConst[0] = 1.0f;
     blend.blendConst[1] = 1.0f;
     blend.blendConst[2] = 1.0f;
@@ -195,8 +195,8 @@
     err = vkCreateDynamicColorBlendState(device(), &blend, &m_colorBlend);
     ASSERT_VK_SUCCESS( err );
 
-    VkDynamicDsStateCreateInfo depthStencil = {};
-    depthStencil.sType = VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO;
+    VkDynamicDepthStencilStateCreateInfo depthStencil = {};
+    depthStencil.sType = VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO;
     depthStencil.minDepthBounds = 0.f;
     depthStencil.maxDepthBounds = 1.f;
     depthStencil.stencilFrontRef = 0;
@@ -223,8 +223,8 @@
     VkViewport viewport;
     VkRect2D scissor;
 
-    VkDynamicVpStateCreateInfo viewportCreate = {};
-    viewportCreate.sType = VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO;
+    VkDynamicViewportStateCreateInfo viewportCreate = {};
+    viewportCreate.sType = VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO;
     viewportCreate.viewportAndScissorCount         = 1;
     viewport.originX  = 0;
     viewport.originY  = 0;
@@ -1403,9 +1403,24 @@
     vkCmdEndRenderPass(handle());
 }
 
-void VkCommandBufferObj::BindStateObject(VkStateBindPoint stateBindPoint, VkDynamicStateObject stateObject)
+void VkCommandBufferObj::BindDynamicViewportState(VkDynamicViewportState viewportState)
 {
-    vkCmdBindDynamicStateObject( handle(), stateBindPoint, stateObject);
+    vkCmdBindDynamicViewportState( handle(), viewportState);
+}
+
+void VkCommandBufferObj::BindDynamicRasterState(VkDynamicRasterState rasterState)
+{
+    vkCmdBindDynamicRasterState( handle(), rasterState);
+}
+
+void VkCommandBufferObj::BindDynamicColorBlendState(VkDynamicColorBlendState colorBlendState)
+{
+    vkCmdBindDynamicColorBlendState( handle(), colorBlendState);
+}
+
+void VkCommandBufferObj::BindDynamicDepthStencilState(VkDynamicDepthStencilState depthStencilState)
+{
+    vkCmdBindDynamicDepthStencilState( handle(), depthStencilState);
 }
 
 void VkCommandBufferObj::AddRenderTarget(VkImageObj *renderTarget)
@@ -1425,7 +1440,8 @@
 
 void VkCommandBufferObj::QueueCommandBuffer()
 {
-    QueueCommandBuffer(NULL);
+    VkFence nullFence = { VK_NULL_HANDLE };
+    QueueCommandBuffer(nullFence);
 }
 
 void VkCommandBufferObj::QueueCommandBuffer(VkFence fence)
diff --git a/tests/vkrenderframework.h b/tests/vkrenderframework.h
index fc27779..bdf508e 100644
--- a/tests/vkrenderframework.h
+++ b/tests/vkrenderframework.h
@@ -106,19 +106,12 @@
     VkCmdBuffer                         m_cmdBuffer;
     VkRenderPass                        m_renderPass;
     VkFramebuffer                       m_framebuffer;
-<<<<<<< HEAD
     std::vector<VkClearValue>           m_renderPassClearValues;
     VkRenderPassBeginInfo               m_renderPassBeginInfo;
-    VkDynamicRsState                    m_stateRaster;
-    VkDynamicCbState                    m_colorBlend;
-    VkDynamicVpState                    m_stateViewport;
-    VkDynamicDsState                    m_stateDepthStencil;
-=======
     VkDynamicRasterState                m_stateRaster;
     VkDynamicColorBlendState            m_colorBlend;
     VkDynamicViewportState              m_stateViewport;
     VkDynamicDepthStencilState          m_stateDepthStencil;
->>>>>>> Bug 14084 - Improve type safety and remove polymorphism
     vector<VkImageObj*>                 m_renderTargets;
     float                               m_width, m_height;
     VkFormat                            m_render_target_fmt;
@@ -177,8 +170,11 @@
     void BindDescriptorSet(VkDescriptorSetObj &descriptorSet);
     void BindVertexBuffer(VkConstantBufferObj *vertexBuffer, VkDeviceSize offset, uint32_t binding);
     void BindIndexBuffer(VkIndexBufferObj *indexBuffer, uint32_t offset);
-    void BindStateObject(VkStateBindPoint stateBindPoint, VkDynamicStateObject stateObject);
     void BeginRenderPass(const VkRenderPassBeginInfo &info);
+    void BindDynamicViewportState(VkDynamicViewportState viewportState);
+    void BindDynamicRasterState(VkDynamicRasterState rasterState);
+    void BindDynamicColorBlendState(VkDynamicColorBlendState colorBlendState);
+    void BindDynamicDepthStencilState(VkDynamicDepthStencilState depthStencilState);
     void EndRenderPass();
     void Draw(uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount);
     void DrawIndexed(uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount);
diff --git a/tests/vktestbinding.cpp b/tests/vktestbinding.cpp
index 70483e7..2f21733 100644
--- a/tests/vktestbinding.cpp
+++ b/tests/vktestbinding.cpp
@@ -23,6 +23,7 @@
 #include <iostream>
 #include <string.h> // memset(), memcmp()
 #include <assert.h>
+#include <stdarg.h>
 #include "vktestbinding.h"
 
 namespace {
@@ -34,11 +35,11 @@
             NonDispHandle::init(dev.handle(), handle);                              \
     } while (0)
 
-#define NON_DISPATCHABLE_HANDLE_DTOR(cls, destroy_func, ...)                        \
+#define NON_DISPATCHABLE_HANDLE_DTOR(cls, destroy_func)                        \
     cls::~cls()                                                                     \
     {                                                                               \
         if (initialized())                                                          \
-            EXPECT(destroy_func(device(), __VA_ARGS__, handle()) == VK_SUCCESS);    \
+            EXPECT(destroy_func(device(), handle()) == VK_SUCCESS);    \
     }
 
 #define STRINGIFY(x) #x
@@ -468,21 +469,21 @@
     EXPECT(vkUnmapMemory(device(), handle()) == VK_SUCCESS);
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(Fence, vkDestroyObject, VK_OBJECT_TYPE_FENCE)
+NON_DISPATCHABLE_HANDLE_DTOR(Fence, vkDestroyFence)
 
 void Fence::init(const Device &dev, const VkFenceCreateInfo &info)
 {
     NON_DISPATCHABLE_HANDLE_INIT(vkCreateFence, dev, &info);
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(Semaphore, vkDestroyObject, VK_OBJECT_TYPE_SEMAPHORE)
+NON_DISPATCHABLE_HANDLE_DTOR(Semaphore, vkDestroySemaphore)
 
 void Semaphore::init(const Device &dev, const VkSemaphoreCreateInfo &info)
 {
     NON_DISPATCHABLE_HANDLE_INIT(vkCreateSemaphore, dev, &info);
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(Event, vkDestroyObject, VK_OBJECT_TYPE_EVENT)
+NON_DISPATCHABLE_HANDLE_DTOR(Event, vkDestroyEvent)
 
 void Event::init(const Device &dev, const VkEventCreateInfo &info)
 {
@@ -499,7 +500,7 @@
     EXPECT(vkResetEvent(device(), handle()) == VK_SUCCESS);
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(QueryPool, vkDestroyObject, VK_OBJECT_TYPE_QUERY_POOL)
+NON_DISPATCHABLE_HANDLE_DTOR(QueryPool, vkDestroyQueryPool)
 
 void QueryPool::init(const Device &dev, const VkQueryPoolCreateInfo &info)
 {
@@ -520,7 +521,7 @@
     return err;
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(Buffer, vkDestroyObject, VK_OBJECT_TYPE_BUFFER)
+NON_DISPATCHABLE_HANDLE_DTOR(Buffer, vkDestroyBuffer)
 
 void Buffer::init(const Device &dev, const VkBufferCreateInfo &info, VkMemoryPropertyFlags mem_props)
 {
@@ -540,24 +541,24 @@
 {
     VkMemoryRequirements reqs;
 
-    EXPECT(vkGetObjectMemoryRequirements(device(), VK_OBJECT_TYPE_BUFFER, handle(), &reqs) == VK_SUCCESS);
+    EXPECT(vkGetBufferMemoryRequirements(device(), handle(), &reqs) == VK_SUCCESS);
 
     return reqs;
 }
 
 void Buffer::bind_memory(const DeviceMemory &mem, VkDeviceSize mem_offset)
 {
-    EXPECT(vkBindObjectMemory(device(), VK_OBJECT_TYPE_BUFFER, handle(), mem.handle(), mem_offset) == VK_SUCCESS);
+    EXPECT(vkBindBufferMemory(device(), handle(), mem.handle(), mem_offset) == VK_SUCCESS);
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(BufferView, vkDestroyObject, VK_OBJECT_TYPE_BUFFER_VIEW)
+NON_DISPATCHABLE_HANDLE_DTOR(BufferView, vkDestroyBufferView)
 
 void BufferView::init(const Device &dev, const VkBufferViewCreateInfo &info)
 {
     NON_DISPATCHABLE_HANDLE_INIT(vkCreateBufferView, dev, &info);
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(Image, vkDestroyObject, VK_OBJECT_TYPE_IMAGE)
+NON_DISPATCHABLE_HANDLE_DTOR(Image, vkDestroyImage)
 
 void Image::init(const Device &dev, const VkImageCreateInfo &info, VkMemoryPropertyFlags mem_props)
 {
@@ -589,14 +590,14 @@
 {
     VkMemoryRequirements reqs;
 
-    EXPECT(vkGetObjectMemoryRequirements(device(), VK_OBJECT_TYPE_IMAGE, handle(), &reqs) == VK_SUCCESS);
+    EXPECT(vkGetImageMemoryRequirements(device(), handle(), &reqs) == VK_SUCCESS);
 
     return reqs;
 }
 
 void Image::bind_memory(const DeviceMemory &mem, VkDeviceSize mem_offset)
 {
-    EXPECT(vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, handle(), mem.handle(), mem_offset) == VK_SUCCESS);
+    EXPECT(vkBindImageMemory(device(), handle(), mem.handle(), mem_offset) == VK_SUCCESS);
 }
 
 VkSubresourceLayout Image::subresource_layout(const VkImageSubresource &subres) const
@@ -617,21 +618,21 @@
                                     VK_IMAGE_USAGE_DEPTH_STENCIL_BIT)));
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(ImageView, vkDestroyObject, VK_OBJECT_TYPE_IMAGE_VIEW)
+NON_DISPATCHABLE_HANDLE_DTOR(ImageView, vkDestroyImageView)
 
 void ImageView::init(const Device &dev, const VkImageViewCreateInfo &info)
 {
     NON_DISPATCHABLE_HANDLE_INIT(vkCreateImageView, dev, &info);
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(AttachmentView, vkDestroyObject, VK_OBJECT_TYPE_ATTACHMENT_VIEW)
+NON_DISPATCHABLE_HANDLE_DTOR(AttachmentView, vkDestroyAttachmentView)
 
 void AttachmentView::init(const Device &dev, const VkAttachmentViewCreateInfo &info)
 {
     NON_DISPATCHABLE_HANDLE_INIT(vkCreateAttachmentView, dev, &info);
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(ShaderModule, vkDestroyObject, VK_OBJECT_TYPE_SHADER_MODULE)
+NON_DISPATCHABLE_HANDLE_DTOR(ShaderModule, vkDestroyShaderModule)
 
 void ShaderModule::init(const Device &dev, const VkShaderModuleCreateInfo &info)
 {
@@ -649,7 +650,7 @@
     return err;
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(Shader, vkDestroyObject, VK_OBJECT_TYPE_SHADER)
+NON_DISPATCHABLE_HANDLE_DTOR(Shader, vkDestroyShader)
 
 void Shader::init(const Device &dev, const VkShaderCreateInfo &info)
 {
@@ -667,7 +668,7 @@
     return err;
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(Pipeline, vkDestroyObject, VK_OBJECT_TYPE_PIPELINE)
+NON_DISPATCHABLE_HANDLE_DTOR(Pipeline, vkDestroyPipeline)
 
 void Pipeline::init(const Device &dev, const VkGraphicsPipelineCreateInfo &info)
 {
@@ -715,7 +716,7 @@
     }
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(PipelineLayout, vkDestroyObject, VK_OBJECT_TYPE_PIPELINE_LAYOUT)
+NON_DISPATCHABLE_HANDLE_DTOR(PipelineLayout, vkDestroyPipelineLayout)
 
 void PipelineLayout::init(const Device &dev, VkPipelineLayoutCreateInfo &info, const std::vector<const DescriptorSetLayout *> &layouts)
 {
@@ -725,21 +726,21 @@
     NON_DISPATCHABLE_HANDLE_INIT(vkCreatePipelineLayout, dev, &info);
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(Sampler, vkDestroyObject, VK_OBJECT_TYPE_SAMPLER)
+NON_DISPATCHABLE_HANDLE_DTOR(Sampler, vkDestroySampler)
 
 void Sampler::init(const Device &dev, const VkSamplerCreateInfo &info)
 {
     NON_DISPATCHABLE_HANDLE_INIT(vkCreateSampler, dev, &info);
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(DescriptorSetLayout, vkDestroyObject, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT)
+NON_DISPATCHABLE_HANDLE_DTOR(DescriptorSetLayout, vkDestroyDescriptorSetLayout)
 
 void DescriptorSetLayout::init(const Device &dev, const VkDescriptorSetLayoutCreateInfo &info)
 {
     NON_DISPATCHABLE_HANDLE_INIT(vkCreateDescriptorSetLayout, dev, &info);
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(DescriptorPool, vkDestroyObject, VK_OBJECT_TYPE_DESCRIPTOR_POOL)
+NON_DISPATCHABLE_HANDLE_DTOR(DescriptorPool, vkDestroyDescriptorPool)
 
 void DescriptorPool::init(const Device &dev, VkDescriptorPoolUsage usage,
                           uint32_t max_sets, const VkDescriptorPoolCreateInfo &info)
@@ -769,7 +770,7 @@
     sets.reserve(set_count);
     for (std::vector<VkDescriptorSet>::const_iterator it = set_handles.begin(); it != set_handles.end(); it++) {
         // do descriptor sets need memories bound?
-        DescriptorSet *descriptorSet = new DescriptorSet(dev, *it);
+        DescriptorSet *descriptorSet = new DescriptorSet(dev, handle(), *it);
         sets.push_back(descriptorSet);
     }
     return sets;
@@ -786,30 +787,36 @@
     return (set.empty()) ? NULL : set[0];
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(DescriptorSet, vkDestroyObject, VK_OBJECT_TYPE_DESCRIPTOR_SET)
+DescriptorSet::~DescriptorSet()
+{
+    if (initialized()) {
+        VkDescriptorSet sets[1] = { handle() };
+        EXPECT(vkFreeDescriptorSets(device(), pool_, 1, sets) == VK_SUCCESS);
+    }
+}
 
-NON_DISPATCHABLE_HANDLE_DTOR(DynamicViewportState, vkDestroyObject, VK_OBJECT_TYPE_DYNAMIC_VP_STATE)
+NON_DISPATCHABLE_HANDLE_DTOR(DynamicViewportState, vkDestroyDynamicViewportState)
 
 void DynamicViewportState::init(const Device &dev, const VkDynamicViewportStateCreateInfo &info)
 {
     NON_DISPATCHABLE_HANDLE_INIT(vkCreateDynamicViewportState, dev, &info);
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(DynamicRasterState, vkDestroyObject, VK_OBJECT_TYPE_DYNAMIC_RS_STATE)
+NON_DISPATCHABLE_HANDLE_DTOR(DynamicRasterState, vkDestroyDynamicRasterState)
 
 void DynamicRasterState::init(const Device &dev, const VkDynamicRasterStateCreateInfo &info)
 {
     NON_DISPATCHABLE_HANDLE_INIT(vkCreateDynamicRasterState, dev, &info);
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(DynamicColorBlendState, vkDestroyObject, VK_OBJECT_TYPE_DYNAMIC_CB_STATE)
+NON_DISPATCHABLE_HANDLE_DTOR(DynamicColorBlendState, vkDestroyDynamicColorBlendState)
 
-void DynamicColorBlendState::init(const Device &dev, const VkDynamicCbStateCreateInfo &info)
+void DynamicColorBlendState::init(const Device &dev, const VkDynamicColorBlendStateCreateInfo &info)
 {
     NON_DISPATCHABLE_HANDLE_INIT(vkCreateDynamicColorBlendState, dev, &info);
 }
 
-NON_DISPATCHABLE_HANDLE_DTOR(DynamicDepthStencilState, vkDestroyObject, VK_OBJECT_TYPE_DYNAMIC_DS_STATE)
+NON_DISPATCHABLE_HANDLE_DTOR(DynamicDepthStencilState, vkDestroyDynamicDepthStencilState)
 
 void DynamicDepthStencilState::init(const Device &dev, const VkDynamicDepthStencilStateCreateInfo &info)
 {
@@ -819,7 +826,7 @@
 CmdBuffer::~CmdBuffer()
 {
     if (initialized())
-        EXPECT(vkDestroyObject(dev_handle_, VK_OBJECT_TYPE_COMMAND_BUFFER, handle()) == VK_SUCCESS);
+        EXPECT(vkDestroyCommandBuffer(dev_handle_, handle()) == VK_SUCCESS);
 }
 
 void CmdBuffer::init(const Device &dev, const VkCmdBufferCreateInfo &info)
diff --git a/tests/vktestbinding.h b/tests/vktestbinding.h
index 8480890..2a30ea9 100644
--- a/tests/vktestbinding.h
+++ b/tests/vktestbinding.h
@@ -539,7 +539,10 @@
     ~DescriptorSet();
 
     explicit DescriptorSet() : NonDispHandle() {}
-    explicit DescriptorSet(const Device &dev, VkDescriptorSet set) : NonDispHandle(dev.handle(), set) {}
+    explicit DescriptorSet(const Device &dev, VkDescriptorPool pool, VkDescriptorSet set) : NonDispHandle(dev.handle(), set) { pool_ = pool;}
+
+private:
+    VkDescriptorPool pool_;
 };
 
 class DynamicViewportState : public internal::NonDispHandle<VkDynamicViewportState> {
diff --git a/tests/vktestframework.cpp b/tests/vktestframework.cpp
index 1b8315b..3edc058 100644
--- a/tests/vktestframework.cpp
+++ b/tests/vktestframework.cpp
@@ -482,7 +482,8 @@
     VkCmdBuffer cmdBufs[1];
     cmdBufs[0] = m_cmdbuf.handle();
 
-    vkQueueSubmit(m_queue.handle(), 1, cmdBufs, NULL);
+    VkFence nullFence = { VK_NULL_HANDLE };
+    vkQueueSubmit(m_queue.handle(), 1, cmdBufs, nullFence);
     m_queue.wait();
 
     VkPresentInfoWSI present = {};