diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 63bcc09..7e69642 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -15,6 +15,7 @@
     xglgpu.cpp
     xgldevice.cpp
     xglimage.cpp
+    tony_objs.cpp
     xglrenderframework.cpp
     xgltestframework.cpp
    )
diff --git a/tests/tony_objs.c b/tests/tony_objs.cpp
similarity index 71%
rename from tests/tony_objs.c
rename to tests/tony_objs.cpp
index f8c8fa9..7f3454d 100644
--- a/tests/tony_objs.c
+++ b/tests/tony_objs.cpp
@@ -1,26 +1,4 @@
-class XglDescriptorSetObj
-{
-public:
-    XglDescriptorSetObj(XglDevice *device);
-    void AttachMemoryView( XGL_MEMORY_VIEW_ATTACH_INFO* memoryView);
-    void AttachSampler( XGL_SAMPLER* sampler);
-    void AttachImageView( XGL_IMAGE_VIEW_ATTACH_INFO* imageView);
-    void BindCommandBuffer(XGL_CMD_BUFFER commandBuffer);
-    XGL_DESCRIPTOR_SLOT_INFO * GetSlotInfo(vector<int>slots, vector<XGL_DESCRIPTOR_SET_SLOT_TYPE>types, vector<XGL_OBJECT>objs );
-
-protected:
-    XGL_DESCRIPTOR_SET_CREATE_INFO       m_descriptorInfo;
-    XGL_DESCRIPTOR_SET                   m_rsrcDescSet;
-    XGL_GPU_MEMORY                       m_descriptor_set_mem;
-    XglDevice                           *m_device;
-    int                                  m_nextSlot;
-    vector<int>                          m_memorySlots;
-    vector<XGL_MEMORY_VIEW_ATTACH_INFO*> m_memoryViews;
-    vector<int>                          m_samplerSlots;
-    vector<XGL_SAMPLER*>                 m_samplers;
-    vector<int>                          m_imageSlots;
-    vector<XGL_IMAGE_VIEW_ATTACH_INFO*>  m_imageViews;
-};
+#include "xglrenderframework.h"
 
 XglDescriptorSetObj::XglDescriptorSetObj(XglDevice *device)
 {
@@ -106,7 +84,7 @@
     XGL_RESULT err;
 
     // Create descriptor set for a uniform resource
-    m_descriptorInfo = {};
+    memset(&m_descriptorInfo,0,sizeof(m_descriptorInfo));
     m_descriptorInfo.sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO;
     m_descriptorInfo.slots = m_nextSlot;
 
@@ -136,19 +114,7 @@
     xglCmdBindDescriptorSet(commandBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, 0, m_rsrcDescSet, 0 );
 }
 
-class XglTextureObj
-{
-public:
-    XglTextureObj(XglDevice *device);
-    XGL_IMAGE                  m_texture;
-    XGL_IMAGE_VIEW_ATTACH_INFO m_textureViewInfo;
-    XGL_GPU_MEMORY             m_textureMem;
 
-protected:
-    XglDevice                 *m_device;
-    XGL_IMAGE_VIEW             m_textureView;
-
-};
 XglTextureObj::XglTextureObj(XglDevice *device):
     m_texture(XGL_NULL_HANDLE),
     m_textureMem(XGL_NULL_HANDLE),
@@ -268,23 +234,14 @@
 
 }
 
-class XglSamplerObj
-{
-public:
-    XglSamplerObj(XglDevice *device);
-    XGL_SAMPLER m_sampler;
 
-protected:
-     XGL_SAMPLER_CREATE_INFO m_samplerCreateInfo = {};
-     XglDevice *m_device;
-
-};
 
 XglSamplerObj::XglSamplerObj(XglDevice *device)
 {
     XGL_RESULT err = XGL_SUCCESS;
 
     m_device = device;
+    memset(&m_samplerCreateInfo,0,sizeof(m_samplerCreateInfo));
     m_samplerCreateInfo.sType = XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
     m_samplerCreateInfo.magFilter = XGL_TEX_FILTER_NEAREST;
     m_samplerCreateInfo.minFilter = XGL_TEX_FILTER_NEAREST;
@@ -303,19 +260,6 @@
 
 }
 
-class XglConstantBufferObj
-{
-public:
-    XglConstantBufferObj(XglDevice *device, int constantCount, int constantSize, const void* data);
-    void SetMemoryState(XGL_CMD_BUFFER cmdBuffer, XGL_MEMORY_STATE newState);
-    XGL_MEMORY_VIEW_ATTACH_INFO     m_constantBufferView;
-    XGL_GPU_MEMORY                  m_constantBufferMem;
-
-protected:
-    XglDevice                      *m_device;
-    int                             m_numVertices;
-    int                             m_stride;
-};
 XglConstantBufferObj::XglConstantBufferObj(XglDevice *device, int constantCount, int constantSize, const void* data)
 {
     XGL_RESULT err = XGL_SUCCESS;
@@ -390,31 +334,6 @@
     ASSERT_XGL_SUCCESS(err);
 }
 
-class XglShaderObj
-{
-public:
-    XglShaderObj(XglDevice *device, const char * shaderText, XGL_PIPELINE_SHADER_STAGE stage );
-    XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* GetStageCreateInfo(XglDescriptorSetObj descriptorSet);
-    void BindShaderEntitySlotToMemory(int slot, XGL_DESCRIPTOR_SET_SLOT_TYPE type, XGL_OBJECT object);
-    void BindShaderEntitySlotToImage(int slot, XGL_DESCRIPTOR_SET_SLOT_TYPE type, XGL_OBJECT object);
-    void BindShaderEntitySlotToSampler(int slot, XGL_OBJECT object);
-
-protected:
-    XGL_PIPELINE_SHADER_STAGE_CREATE_INFO stage_info;
-    XGL_SHADER m_shader;
-    XGL_PIPELINE_SHADER_STAGE m_stage;
-    XglDevice *m_device;
-    vector<int>    m_memSlots;
-    vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> m_memTypes;
-    vector<XGL_OBJECT> m_memObjs;
-    vector<int>    m_samplerSlots;
-    vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> m_samplerTypes;
-    vector<XGL_OBJECT> m_samplerObjs;
-    vector<int>    m_imageSlots;
-    vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> m_imageTypes;
-    vector<XGL_OBJECT> m_imageObjs;
-
-};
 
 XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* XglShaderObj::GetStageCreateInfo(XglDescriptorSetObj descriptorSet)
 {
@@ -541,36 +460,6 @@
     *pshader = shader;
 }
 #endif
-class XglPipelineObj
-{
-public:
-    XglPipelineObj(XglDevice *device);
-    void BindPipelineCommandBuffer(XGL_CMD_BUFFER m_cmdBuffer, XglDescriptorSetObj descriptorSet);
-    void AddShader(XglShaderObj* shaderObj);
-    void AddVertexInputAttribs(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* vi_attrib, int count);
-    void AddVertexInputBindings(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* vi_binding, int count);
-    void AddVertexDataBuffer(XglConstantBufferObj* vertexDataBuffer, int binding);
-
-protected:
-    XGL_PIPELINE pipeline;
-    XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO vi_state;
-    XGL_PIPELINE_IA_STATE_CREATE_INFO ia_state;
-    XGL_PIPELINE_RS_STATE_CREATE_INFO rs_state;
-    XGL_PIPELINE_CB_STATE cb_state;
-    XGL_PIPELINE_DB_STATE_CREATE_INFO db_state;
-    XGL_FORMAT render_target_format;
-    XGL_GPU_MEMORY m_pipe_mem;
-    XglDevice *m_device;
-    XGL_VERTEX_INPUT_BINDING_DESCRIPTION *m_vi_binding;
-    int m_vi_binding_count;
-    XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION *m_vi_attribs;
-    int m_vi_attrib_count;
-    vector<XglShaderObj*> m_shaderObjs;
-    vector<XglConstantBufferObj*> m_vertexBufferObjs;
-    vector<int> m_vertexBufferBindings;
-    int m_vertexBufferCount;
-
-};
 
 XglPipelineObj::XglPipelineObj(XglDevice *device)
 {
@@ -579,46 +468,39 @@
     m_device = device;
     m_vi_attrib_count = m_vi_binding_count = m_vertexBufferCount = 0;
 
-    ia_state = {
-        XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO,  // sType
-        XGL_NULL_HANDLE,                                         // pNext
-        XGL_TOPOLOGY_TRIANGLE_LIST,                        // XGL_PRIMITIVE_TOPOLOGY
-        XGL_FALSE,                                         // disableVertexReuse
-        XGL_PROVOKING_VERTEX_LAST,                         // XGL_PROVOKING_VERTEX_CONVENTION
-        XGL_FALSE,                                         // primitiveRestartEnable
-        0                                                  // primitiveRestartIndex
-    };
+    m_ia_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO;
+    m_ia_state.pNext = XGL_NULL_HANDLE;
+    m_ia_state.topology = XGL_TOPOLOGY_TRIANGLE_LIST;
+    m_ia_state.disableVertexReuse = XGL_FALSE;
+    m_ia_state.provokingVertex = XGL_PROVOKING_VERTEX_LAST;
+    m_ia_state.primitiveRestartEnable = XGL_FALSE;
+    m_ia_state.primitiveRestartIndex = 0;
 
-    rs_state = {
-        XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO,
-        &ia_state,
-        XGL_FALSE,                                          // depthClipEnable
-        XGL_FALSE,                                          // rasterizerDiscardEnable
-        1.0                                                 // pointSize
-    };
+    m_rs_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO;
+    m_rs_state.pNext = &m_ia_state;
+    m_rs_state.depthClipEnable = XGL_FALSE;
+    m_rs_state.rasterizerDiscardEnable = XGL_FALSE;
+    m_rs_state.pointSize = 1.0;
 
-    render_target_format.channelFormat = XGL_CH_FMT_R8G8B8A8;
-    render_target_format.numericFormat = XGL_NUM_FMT_UNORM;
-    cb_state = {
-        XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO,
-        &rs_state,
-        XGL_FALSE,                                          // alphaToCoverageEnable
-        XGL_FALSE,                                          // dualSourceBlendEnable
-        XGL_LOGIC_OP_COPY,                                  // XGL_LOGIC_OP
-        {                                                   // XGL_PIPELINE_CB_ATTACHMENT_STATE
-            {
-                XGL_FALSE,                                  // blendEnable
-                render_target_format,                        // XGL_FORMAT
-                0xF                                         // channelWriteMask
-            }
-        }
-    };
+    m_render_target_format.channelFormat = XGL_CH_FMT_R8G8B8A8;
+    m_render_target_format.numericFormat = XGL_NUM_FMT_UNORM;
 
-   db_state = {
-        XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO,
-        &cb_state,
-        {XGL_CH_FMT_R32, XGL_NUM_FMT_DS}                    // XGL_FORMAT
-    };
+    memset(&m_cb_state,0,sizeof(m_cb_state));
+    m_cb_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO;
+    m_cb_state.pNext = &m_rs_state;
+    m_cb_state.alphaToCoverageEnable = XGL_FALSE;
+    m_cb_state.dualSourceBlendEnable = XGL_FALSE;
+    m_cb_state.logicOp = XGL_LOGIC_OP_COPY;
+
+    m_cb_attachment_state.blendEnable = XGL_FALSE;
+    m_cb_attachment_state.format = m_render_target_format;
+    m_cb_attachment_state.channelWriteMask = 0xF;
+    m_cb_state.attachment[0] = m_cb_attachment_state;
+
+    m_db_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO,
+    m_db_state.pNext = &m_cb_state,
+    m_db_state.format.channelFormat = XGL_CH_FMT_R32;
+    m_db_state.format.numericFormat = XGL_NUM_FMT_DS;
 
 
 };
@@ -650,7 +532,7 @@
 void XglPipelineObj::BindPipelineCommandBuffer(XGL_CMD_BUFFER m_cmdBuffer, XglDescriptorSetObj descriptorSet)
 {
     XGL_RESULT err;
-    XGL_VOID* head_ptr = &db_state;
+    XGL_VOID* head_ptr = &m_db_state;
     XGL_GRAPHICS_PIPELINE_CREATE_INFO info = {};
 
     XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* shaderCreateInfo;
@@ -665,26 +547,24 @@
 
     if (m_vi_attrib_count && m_vi_binding_count)
     {
-        vi_state = {
-            XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO, // sType;
-            head_ptr,                                            // pNext;
-            m_vi_binding_count,                                                    // bindingCount
-            m_vi_binding,                                          // pVertexBindingDescriptions;
-            m_vi_attrib_count,                                                    // attributeCount; // number of attributes
-            m_vi_attribs                                            // pVertexAttributeDescriptions;
-        };
-        head_ptr = &vi_state;
+        m_vi_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO;
+        m_vi_state.pNext = head_ptr;
+        m_vi_state.bindingCount = m_vi_binding_count;
+        m_vi_state.pVertexBindingDescriptions = m_vi_binding;
+        m_vi_state.attributeCount = m_vi_attrib_count;
+        m_vi_state.pVertexAttributeDescriptions = m_vi_attribs;
+        head_ptr = &m_vi_state;
     }
 
     info.sType = XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
     info.pNext = head_ptr;
     info.flags = 0;
 
-    err = xglCreateGraphicsPipeline(m_device->device(), &info, &pipeline);
+    err = xglCreateGraphicsPipeline(m_device->device(), &info, &m_pipeline);
 
-    err = m_device->AllocAndBindGpuMemory(pipeline, "Pipeline", &m_pipe_mem);
+    err = m_device->AllocAndBindGpuMemory(m_pipeline, "Pipeline", &m_pipe_mem);
 
-    xglCmdBindPipeline( m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, pipeline );
+    xglCmdBindPipeline( m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, m_pipeline );
 
 
     for (int i=0; i < m_vertexBufferCount; i++)
@@ -692,22 +572,9 @@
         xglCmdBindVertexData(m_cmdBuffer, m_vertexBufferObjs[i]->m_constantBufferView.mem, m_vertexBufferObjs[i]->m_constantBufferView.offset, m_vertexBufferBindings[i]);
     }
 
-
-    // xglCmdBindVertexData(m_cmdBuffer, meshBuffer.m_constantBufferView.mem, meshBuffer.m_constantBufferView.offset, 0);
 }
 
-class XglMemoryRefManager{
-public:
-    XglMemoryRefManager();
-    void AddMemoryRef(XGL_GPU_MEMORY* memoryRef);
-    XGL_MEMORY_REF* GetMemoryRefList();
-    int GetNumRefs();
 
-protected:
-    int m_numRefs;
-    vector<XGL_GPU_MEMORY*> m_bufferObjs;
-
-};
 XglMemoryRefManager::XglMemoryRefManager() {
 
 }
diff --git a/tests/tony_render_tests.cpp b/tests/tony_render_tests.cpp
index 0787b53..8c691d4 100644
--- a/tests/tony_render_tests.cpp
+++ b/tests/tony_render_tests.cpp
@@ -72,7 +72,6 @@
 #include <glm/gtc/matrix_transform.hpp>
 
 #include "xglrenderframework.h"
-#include "tony_objs.c"
 
 #undef ASSERT_NO_FATAL_FAILURE
 #define ASSERT_NO_FATAL_FAILURE(x) x
@@ -181,7 +180,6 @@
 class XglRenderTest : public XglRenderFramework
 {
 public:
-    void UploadMesh( XGL_UINT32 numVertices, XGL_GPU_SIZE vbStride, const void* vertices );
     void InitTexture();
     void InitSampler();
     void DrawTriangleTest(const char *vertShaderText, const char *fragShaderText);
@@ -212,26 +210,6 @@
     XGL_DEPTH_STENCIL_VIEW      m_depthStencilView;
     XglMemoryRefManager         m_memoryRefManager;
 
-//    XGL_APPLICATION_INFO app_info;
-//    XGL_PHYSICAL_GPU objs[MAX_GPUS];
-//    XGL_UINT gpu_count;
-//    XGL_GPU_MEMORY      m_descriptor_set_mem;
-//    XGL_GPU_MEMORY      m_pipe_mem;
-//    XglDevice *m_device;
-//    XGL_CMD_BUFFER m_cmdBuffer;
-//    XGL_UINT32 m_numVertices;
-//    XGL_MEMORY_VIEW_ATTACH_INFO m_vtxBufferView;
-//    XGL_MEMORY_VIEW_ATTACH_INFO m_constantBufferView;
-//    XGL_GPU_MEMORY m_vtxBufferMem;
-//    XGL_GPU_MEMORY m_constantBufferMem;
-//    XGL_UINT32                      m_numMemRefs;
-//    XGL_MEMORY_REF                  m_memRefs[5];
-//    XGL_RASTER_STATE_OBJECT         m_stateRaster;
-//    XGL_COLOR_BLEND_STATE_OBJECT    m_colorBlend;
-//    XGL_VIEWPORT_STATE_OBJECT       m_stateViewport;
-//    XGL_DEPTH_STENCIL_STATE_OBJECT  m_stateDepthStencil;
-//    XGL_MSAA_STATE_OBJECT           m_stateMsaa;
-//    XGL_DESCRIPTOR_SET              m_rsrcDescSet;
 
     virtual void SetUp() {
 
@@ -255,26 +233,6 @@
     }
 };
 
-// this function will create the vertex buffer and fill it with the mesh data
-void XglRenderTest::UploadMesh( XGL_UINT32 numVertices, XGL_GPU_SIZE vbStride,
-                              const void* vertices )
-{
-    XGL_UINT8 *pData;
-    XGL_RESULT err = XGL_SUCCESS;
-
-    assert( numVertices * vbStride > 0 );
-    m_numVertices = numVertices;
-
-    err = xglMapMemory(m_vtxBufferMem, 0, (XGL_VOID **) &pData);
-    ASSERT_XGL_SUCCESS(err);
-
-    memcpy(pData, vertices, numVertices * vbStride);
-
-    err = xglUnmapMemory(m_vtxBufferMem);
-    ASSERT_XGL_SUCCESS(err);
-}
-
-
 
 void XglRenderTest::DrawRotatedTriangleTest()
 {
@@ -1014,7 +972,6 @@
 
     XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX );
     XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT);
-    // vs.BindShaderEntitySlotToMemory(0, XGL_SLOT_VERTEX_INPUT, (XGL_OBJECT) &constantBuffer.m_constantBufferView);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
@@ -1042,7 +999,7 @@
     pipelineobj.AddVertexInputBindings(&vi_binding,1);
     pipelineobj.AddVertexDataBuffer(&meshBuffer,0);
 
-    GenericDrawTriangleTest(pipelineobj, descriptorSet, 12);
+    GenericDrawTriangleTest(pipelineobj, descriptorSet, 2);
     QueueCommandBuffer(NULL, 0);
 }
 
@@ -1102,6 +1059,128 @@
     RotateTriangleVSUniform(Projection, View, Model, MVPBuffer);
 }
 
+TEST_F(XglRenderTest, MixTriangle)
+{
+    // This tests location applied to varyings. Notice that we have switched foo
+    // and bar in the FS. The triangle should be blended with red, green and blue
+    // corners.
+    static const char *vertShaderText =
+            "#version 140\n"
+            "#extension GL_ARB_separate_shader_objects : enable\n"
+            "#extension GL_ARB_shading_language_420pack : enable\n"
+            "layout (location=0) out vec4 bar;\n"
+            "layout (location=1) out vec4 foo;\n"
+            "layout (location=2) out float scale;\n"
+            "vec2 vertices[3];\n"
+            "void main() {\n"
+            "      vertices[0] = vec2(-1.0, -1.0);\n"
+            "      vertices[1] = vec2( 1.0, -1.0);\n"
+            "      vertices[2] = vec2( 0.0,  1.0);\n"
+            "vec4 colors[3];\n"
+            "      colors[0] = vec4(1.0, 0.0, 0.0, 1.0);\n"
+            "      colors[1] = vec4(0.0, 1.0, 0.0, 1.0);\n"
+            "      colors[2] = vec4(0.0, 0.0, 1.0, 1.0);\n"
+            "   foo = colors[gl_VertexID % 3];\n"
+            "   bar = vec4(1.0, 1.0, 1.0, 1.0);\n"
+            "   scale = 1.0;\n"
+            "   gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
+            "}\n";
+
+    static const char *fragShaderText =
+           "#version 140\n"
+           "#extension GL_ARB_separate_shader_objects : enable\n"
+           "#extension GL_ARB_shading_language_420pack : enable\n"
+           "layout (location = 1) in vec4 bar;\n"
+           "layout (location = 0) in vec4 foo;\n"
+           "layout (location = 2) in float scale;\n"
+           "void main() {\n"
+           "   gl_FragColor = bar * scale + foo * (1.0-scale);\n"
+           "}\n";
+
+    ASSERT_NO_FATAL_FAILURE(InitState());
+    ASSERT_NO_FATAL_FAILURE(InitViewport());
+
+    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX );
+    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT);
+
+    XglPipelineObj pipelineobj(m_device);
+    pipelineobj.AddShader(&vs);
+    pipelineobj.AddShader(&ps);
+
+    XglDescriptorSetObj descriptorSet(m_device);
+
+    GenericDrawTriangleTest(pipelineobj, descriptorSet, 1);
+    QueueCommandBuffer(NULL, 0);
+}
+
+TEST_F(XglRenderTest, TriVertFetchAndVertID)
+{
+    // This tests that attributes work in the presence of gl_VertexID
+
+    static const char *vertShaderText =
+            "#version 140\n"
+            "#extension GL_ARB_separate_shader_objects : enable\n"
+            "#extension GL_ARB_shading_language_420pack : enable\n"
+            //XYZ1( -1, -1, -1 )
+            "layout (location = 0) in vec4 pos;\n"
+            //XYZ1( 0.f, 0.f, 0.f )
+            "layout (location = 1) in vec4 inColor;\n"
+            "layout (location = 0) out vec4 outColor;\n"
+            "void main() {\n"
+            "   outColor = inColor;\n"
+            "   vec4 vertices[3];"
+            "      vertices[gl_VertexID % 3] = pos;\n"
+            "   gl_Position = vertices[(gl_VertexID + 3) % 3];\n"
+            "}\n";
+
+
+    static const char *fragShaderText =
+            "#version 140\n"
+            "#extension GL_ARB_separate_shader_objects : enable\n"
+            "#extension GL_ARB_shading_language_420pack : enable\n"
+            "layout (location = 0) in vec4 color;\n"
+            "void main() {\n"
+            "   gl_FragColor = color;\n"
+            "}\n";
+
+    ASSERT_NO_FATAL_FAILURE(InitState());
+    ASSERT_NO_FATAL_FAILURE(InitViewport());
+
+    XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
+    meshBuffer.SetMemoryState(m_cmdBuffer,XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+
+    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX );
+    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT);
+
+    XglPipelineObj pipelineobj(m_device);
+    pipelineobj.AddShader(&vs);
+    pipelineobj.AddShader(&ps);
+
+    XglDescriptorSetObj descriptorSet(m_device);
+    descriptorSet.AttachMemoryView(&meshBuffer.m_constantBufferView);
+
+    XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
+         sizeof(g_vbData[0]),              // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
+         XGL_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate;       // Rate at which binding is incremented
+    };
+
+    XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2];
+    vi_attribs[0].binding = 0;                       // index into vertexBindingDescriptions
+    vi_attribs[0].format.channelFormat = XGL_CH_FMT_R32G32B32A32;            // format of source data
+    vi_attribs[0].format.numericFormat = XGL_NUM_FMT_FLOAT;
+    vi_attribs[0].offsetInBytes = 0;                 // Offset of first element in bytes from base of vertex
+    vi_attribs[1].binding = 0;                       // index into vertexBindingDescriptions
+    vi_attribs[1].format.channelFormat = XGL_CH_FMT_R32G32B32A32;            // format of source data
+    vi_attribs[1].format.numericFormat = XGL_NUM_FMT_FLOAT;
+    vi_attribs[1].offsetInBytes = 16;                 // Offset of first element in bytes from base of vertex
+
+    pipelineobj.AddVertexInputAttribs(vi_attribs,2);
+    pipelineobj.AddVertexInputBindings(&vi_binding,1);
+    pipelineobj.AddVertexDataBuffer(&meshBuffer,0);
+
+    GenericDrawTriangleTest(pipelineobj, descriptorSet, 2);
+    QueueCommandBuffer(NULL, 0);
+}
 TEST_F(XglRenderTest, CubeWithVertexFetchAndMVP)
 {
     static const char *vertShaderText =
@@ -1142,10 +1221,6 @@
     XglConstantBufferObj meshBuffer(m_device,sizeof(g_vb_solid_face_colors_Data)/sizeof(g_vb_solid_face_colors_Data[0]),
             sizeof(g_vb_solid_face_colors_Data[0]), g_vb_solid_face_colors_Data);
 
-    // What part of thisv do I still need to do?  See 144b1763e9b300f62b45077d21dd20ca3a2f838b
-    // meshBuffer.SetMemoryState(m_cmdBuffer,XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
-
-
     const int buf_size = sizeof(MVP) / sizeof(XGL_FLOAT);
 
     XglConstantBufferObj MVPBuffer(m_device, buf_size, sizeof(MVP[0]), (const void*) &MVP[0][0]);
@@ -1245,7 +1320,131 @@
     QueueCommandBuffer(NULL, 0);
 
 }
+TEST_F(XglRenderTest, TexturedTriangle)
+{
+    // The expected result from this test is a red and green checkered triangle
+    static const char *vertShaderText =
+            "#version 140\n"
+            "#extension GL_ARB_separate_shader_objects : enable\n"
+            "#extension GL_ARB_shading_language_420pack : enable\n"
+            "layout (location = 0) out vec2 samplePos;\n"
+            "void main() {\n"
+            "   vec2 vertices[3];"
+            "      vertices[0] = vec2(-0.5, -0.5);\n"
+            "      vertices[1] = vec2( 0.5, -0.5);\n"
+            "      vertices[2] = vec2( 0.5,  0.5);\n"
+            "   vec2 positions[3];"
+            "      positions[0] = vec2( 0.0, 0.0);\n"
+            "      positions[1] = vec2( 1.0, 0.0);\n"
+            "      positions[2] = vec2( 1.0, 1.0);\n"
+            "   samplePos = positions[gl_VertexID % 3];\n"
+            "   gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
+            "}\n";
 
+    static const char *fragShaderText =
+            "#version 140\n"
+            "#extension GL_ARB_separate_shader_objects : enable\n"
+            "#extension GL_ARB_shading_language_420pack : enable\n"
+            "layout (location = 0) in vec2 samplePos;\n"
+            "layout (binding = 0) uniform sampler2D surface;\n"
+            "layout (location=0) out vec4 outColor;\n"
+            "void main() {\n"
+            "   vec4 texColor = textureLod(surface, samplePos, 0.0);\n"
+            "   outColor = texColor;\n"
+            "}\n";
+
+    ASSERT_NO_FATAL_FAILURE(InitState());
+    ASSERT_NO_FATAL_FAILURE(InitViewport());
+
+    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX );
+    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT);
+    XglSamplerObj sampler(m_device);
+    XglTextureObj texture(m_device);
+
+    ps.BindShaderEntitySlotToImage(0, XGL_SLOT_SHADER_RESOURCE, (XGL_OBJECT) &texture.m_textureViewInfo);
+    ps.BindShaderEntitySlotToSampler(0, (XGL_OBJECT) &sampler.m_sampler);
+
+    XglPipelineObj pipelineobj(m_device);
+    pipelineobj.AddShader(&vs);
+    pipelineobj.AddShader(&ps);
+
+    XglDescriptorSetObj descriptorSet(m_device);
+    descriptorSet.AttachImageView(&texture.m_textureViewInfo);
+    descriptorSet.AttachSampler(&sampler.m_sampler);
+
+    m_memoryRefManager.AddMemoryRef(&texture.m_textureMem);
+
+    GenericDrawTriangleTest(pipelineobj, descriptorSet, 1);
+    QueueCommandBuffer(NULL, 0);
+}
+TEST_F(XglRenderTest, TexturedTriangleClip)
+{
+    // The expected result from this test is a red and green checkered triangle
+    static const char *vertShaderText =
+            "#version 330\n"
+            "#extension GL_ARB_separate_shader_objects : enable\n"
+            "#extension GL_ARB_shading_language_420pack : enable\n"
+            "layout (location = 0) out vec2 samplePos;\n"
+            "out gl_PerVertex {\n"
+            "    vec4 gl_Position;\n"
+            "    float gl_ClipDistance[1];\n"
+            "};\n"
+            "void main() {\n"
+            "   vec2 vertices[3];"
+            "      vertices[0] = vec2(-0.5, -0.5);\n"
+            "      vertices[1] = vec2( 0.5, -0.5);\n"
+            "      vertices[2] = vec2( 0.5,  0.5);\n"
+            "   vec2 positions[3];"
+            "      positions[0] = vec2( 0.0, 0.0);\n"
+            "      positions[1] = vec2( 1.0, 0.0);\n"
+            "      positions[2] = vec2( 1.0, 1.0);\n"
+            "   float dists[3];\n"
+            "      dists[0] = 1.0;\n"
+            "      dists[1] = 1.0;\n"
+            "      dists[2] = -1.0;\n"
+            "   gl_ClipDistance[0] = dists[gl_VertexID % 3];\n"
+            "   samplePos = positions[gl_VertexID % 3];\n"
+            "   gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
+            "}\n";
+
+    static const char *fragShaderText =
+            "#version 140\n"
+            "#extension GL_ARB_separate_shader_objects : enable\n"
+            "#extension GL_ARB_shading_language_420pack : enable\n"
+            "layout (location = 0) in vec2 samplePos;\n"
+            "layout (binding = 0) uniform sampler2D surface;\n"
+            "layout (location=0) out vec4 outColor;\n"
+            "void main() {\n"
+            //"   vec4 texColor = textureLod(surface, samplePos, 0.0 + gl_ClipDistance[0]);\n"
+            "   vec4 texColor = textureLod(surface, samplePos, 0.0);\n"
+            "   outColor = texColor;\n"
+            "}\n";
+
+
+    ASSERT_NO_FATAL_FAILURE(InitState());
+    ASSERT_NO_FATAL_FAILURE(InitViewport());
+
+    XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX );
+    XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT);
+    XglSamplerObj sampler(m_device);
+    XglTextureObj texture(m_device);
+
+    ps.BindShaderEntitySlotToImage(0, XGL_SLOT_SHADER_RESOURCE, (XGL_OBJECT) &texture.m_textureViewInfo);
+    ps.BindShaderEntitySlotToSampler(0, (XGL_OBJECT) &sampler.m_sampler);
+
+    XglPipelineObj pipelineobj(m_device);
+    pipelineobj.AddShader(&vs);
+    pipelineobj.AddShader(&ps);
+
+    XglDescriptorSetObj descriptorSet(m_device);
+    descriptorSet.AttachImageView(&texture.m_textureViewInfo);
+    descriptorSet.AttachSampler(&sampler.m_sampler);
+
+    m_memoryRefManager.AddMemoryRef(&texture.m_textureMem);
+
+    GenericDrawTriangleTest(pipelineobj, descriptorSet, 1);
+    QueueCommandBuffer(NULL, 0);
+}
 TEST_F(XglRenderTest, FSTriangle)
 {
     // The expected result from this test is a red and green checkered triangle
diff --git a/tests/xglrenderframework.cpp b/tests/xglrenderframework.cpp
index 695da92..688a41b 100644
--- a/tests/xglrenderframework.cpp
+++ b/tests/xglrenderframework.cpp
@@ -464,12 +464,12 @@
     xglCmdBindStateObject( m_cmdBuffer, XGL_STATE_BIND_MSAA, m_stateMsaa );
 
     // bind pipeline and WVP (dynamic memory view)
-    // xglCmdBindPipeline( m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, *pipeline );
+    xglCmdBindPipeline( m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, *pipeline );
 
     // bind pipeline and WVP (dynamic memory view)
-    // xglCmdBindDescriptorSet(m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, 0, m_rsrcDescSet, 0 );
+    xglCmdBindDescriptorSet(m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, 0, m_rsrcDescSet, 0 );
 
-    // xglCmdBindVertexData(m_cmdBuffer, m_vtxBufferView.mem, m_vtxBufferView.offset, 0);
+    xglCmdBindVertexData(m_cmdBuffer, m_vtxBufferView.mem, m_vtxBufferView.offset, 0);
 }
 
 void XglRenderFramework::GenerateClearAndPrepareBufferCmds()
diff --git a/tests/xglrenderframework.h b/tests/xglrenderframework.h
index 0b6277b..da1e204 100644
--- a/tests/xglrenderframework.h
+++ b/tests/xglrenderframework.h
@@ -120,4 +120,138 @@
     }
 };
 
+class XglDescriptorSetObj
+{
+public:
+    XglDescriptorSetObj(XglDevice *device);
+    void AttachMemoryView( XGL_MEMORY_VIEW_ATTACH_INFO* memoryView);
+    void AttachSampler( XGL_SAMPLER* sampler);
+    void AttachImageView( XGL_IMAGE_VIEW_ATTACH_INFO* imageView);
+    void BindCommandBuffer(XGL_CMD_BUFFER commandBuffer);
+    XGL_DESCRIPTOR_SLOT_INFO * GetSlotInfo(vector<int>slots, vector<XGL_DESCRIPTOR_SET_SLOT_TYPE>types, vector<XGL_OBJECT>objs );
+
+protected:
+    XGL_DESCRIPTOR_SET_CREATE_INFO       m_descriptorInfo;
+    XGL_DESCRIPTOR_SET                   m_rsrcDescSet;
+    XGL_GPU_MEMORY                       m_descriptor_set_mem;
+    XglDevice                           *m_device;
+    int                                  m_nextSlot;
+    vector<int>                          m_memorySlots;
+    vector<XGL_MEMORY_VIEW_ATTACH_INFO*> m_memoryViews;
+    vector<int>                          m_samplerSlots;
+    vector<XGL_SAMPLER*>                 m_samplers;
+    vector<int>                          m_imageSlots;
+    vector<XGL_IMAGE_VIEW_ATTACH_INFO*>  m_imageViews;
+};
+
+class XglTextureObj
+{
+public:
+    XglTextureObj(XglDevice *device);
+    XGL_IMAGE                  m_texture;
+    XGL_IMAGE_VIEW_ATTACH_INFO m_textureViewInfo;
+    XGL_GPU_MEMORY             m_textureMem;
+
+protected:
+    XglDevice                 *m_device;
+    XGL_IMAGE_VIEW             m_textureView;
+
+};
+
+class XglSamplerObj
+{
+public:
+    XglSamplerObj(XglDevice *device);
+    XGL_SAMPLER m_sampler;
+
+protected:
+     XGL_SAMPLER_CREATE_INFO m_samplerCreateInfo;
+     XglDevice *m_device;
+
+};
+
+class XglConstantBufferObj
+{
+public:
+    XglConstantBufferObj(XglDevice *device, int constantCount, int constantSize, const void* data);
+    void SetMemoryState(XGL_CMD_BUFFER cmdBuffer, XGL_MEMORY_STATE newState);
+    XGL_MEMORY_VIEW_ATTACH_INFO     m_constantBufferView;
+    XGL_GPU_MEMORY                  m_constantBufferMem;
+
+protected:
+    XglDevice                      *m_device;
+    int                             m_numVertices;
+    int                             m_stride;
+};
+class XglShaderObj
+{
+public:
+    XglShaderObj(XglDevice *device, const char * shaderText, XGL_PIPELINE_SHADER_STAGE stage );
+    XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* GetStageCreateInfo(XglDescriptorSetObj descriptorSet);
+    void BindShaderEntitySlotToMemory(int slot, XGL_DESCRIPTOR_SET_SLOT_TYPE type, XGL_OBJECT object);
+    void BindShaderEntitySlotToImage(int slot, XGL_DESCRIPTOR_SET_SLOT_TYPE type, XGL_OBJECT object);
+    void BindShaderEntitySlotToSampler(int slot, XGL_OBJECT object);
+
+protected:
+    XGL_PIPELINE_SHADER_STAGE_CREATE_INFO stage_info;
+    XGL_SHADER m_shader;
+    XGL_PIPELINE_SHADER_STAGE m_stage;
+    XglDevice *m_device;
+    vector<int>    m_memSlots;
+    vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> m_memTypes;
+    vector<XGL_OBJECT> m_memObjs;
+    vector<int>    m_samplerSlots;
+    vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> m_samplerTypes;
+    vector<XGL_OBJECT> m_samplerObjs;
+    vector<int>    m_imageSlots;
+    vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> m_imageTypes;
+    vector<XGL_OBJECT> m_imageObjs;
+
+};
+
+class XglPipelineObj
+{
+public:
+    XglPipelineObj(XglDevice *device);
+    void BindPipelineCommandBuffer(XGL_CMD_BUFFER m_cmdBuffer, XglDescriptorSetObj descriptorSet);
+    void AddShader(XglShaderObj* shaderObj);
+    void AddVertexInputAttribs(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* vi_attrib, int count);
+    void AddVertexInputBindings(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* vi_binding, int count);
+    void AddVertexDataBuffer(XglConstantBufferObj* vertexDataBuffer, int binding);
+
+protected:
+    XGL_PIPELINE m_pipeline;
+    XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO m_vi_state;
+    XGL_PIPELINE_IA_STATE_CREATE_INFO m_ia_state;
+    XGL_PIPELINE_RS_STATE_CREATE_INFO m_rs_state;
+    XGL_PIPELINE_CB_STATE m_cb_state;
+    XGL_PIPELINE_DB_STATE_CREATE_INFO m_db_state;
+    XGL_FORMAT m_render_target_format;
+    XGL_PIPELINE_CB_ATTACHMENT_STATE m_cb_attachment_state;
+    XGL_GPU_MEMORY m_pipe_mem;
+    XglDevice *m_device;
+    XGL_VERTEX_INPUT_BINDING_DESCRIPTION *m_vi_binding;
+    int m_vi_binding_count;
+    XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION *m_vi_attribs;
+    int m_vi_attrib_count;
+    vector<XglShaderObj*> m_shaderObjs;
+    vector<XglConstantBufferObj*> m_vertexBufferObjs;
+    vector<int> m_vertexBufferBindings;
+    int m_vertexBufferCount;
+
+};
+class XglMemoryRefManager{
+public:
+    XglMemoryRefManager();
+    void AddMemoryRef(XGL_GPU_MEMORY* memoryRef);
+    XGL_MEMORY_REF* GetMemoryRefList();
+    int GetNumRefs();
+
+protected:
+    int m_numRefs;
+    vector<XGL_GPU_MEMORY*> m_bufferObjs;
+
+};
+
+
 #endif // XGLRENDERFRAMEWORK_H