updated test files to match dali-core : buffer impl 22/253122/3
authorDavid Steele <david.steele@samsung.com>
Thu, 4 Feb 2021 16:47:59 +0000 (16:47 +0000)
committerDavid Steele <david.steele@samsung.com>
Tue, 9 Feb 2021 13:39:40 +0000 (13:39 +0000)
Change-Id: I5b06533a8b92c2f3eb45ed0a708767eccaace780

automated-tests/src/dali-scene-loader-internal/CMakeLists.txt
automated-tests/src/dali-scene-loader/CMakeLists.txt
automated-tests/src/dali-toolkit-internal/CMakeLists.txt
automated-tests/src/dali-toolkit-styling/CMakeLists.txt
automated-tests/src/dali-toolkit-third-party/CMakeLists.txt
automated-tests/src/dali-toolkit/CMakeLists.txt
automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.h
automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.cpp [new file with mode: 0644]
automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.h
automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-controller.cpp

index 22a05cc..086a750 100755 (executable)
@@ -43,6 +43,7 @@ SET(TEST_HARNESS_SOURCES
   ${TEST_HARNESS_DIR}/test-gesture-generator.cpp
   ${TEST_HARNESS_DIR}/test-gl-abstraction.cpp
   ${TEST_HARNESS_DIR}/test-gl-sync-abstraction.cpp
   ${TEST_HARNESS_DIR}/test-gesture-generator.cpp
   ${TEST_HARNESS_DIR}/test-gl-abstraction.cpp
   ${TEST_HARNESS_DIR}/test-gl-sync-abstraction.cpp
+  ${TEST_HARNESS_DIR}/test-graphics-buffer.cpp
   ${TEST_HARNESS_DIR}/test-graphics-command-buffer.cpp
   ${TEST_HARNESS_DIR}/test-graphics-controller.cpp
   ${TEST_HARNESS_DIR}/test-graphics-texture.cpp
   ${TEST_HARNESS_DIR}/test-graphics-command-buffer.cpp
   ${TEST_HARNESS_DIR}/test-graphics-controller.cpp
   ${TEST_HARNESS_DIR}/test-graphics-texture.cpp
index e73dc15..0c17d41 100755 (executable)
@@ -57,6 +57,7 @@ SET(TEST_HARNESS_SOURCES
   ${TEST_HARNESS_DIR}/test-gesture-generator.cpp
   ${TEST_HARNESS_DIR}/test-gl-abstraction.cpp
   ${TEST_HARNESS_DIR}/test-gl-sync-abstraction.cpp
   ${TEST_HARNESS_DIR}/test-gesture-generator.cpp
   ${TEST_HARNESS_DIR}/test-gl-abstraction.cpp
   ${TEST_HARNESS_DIR}/test-gl-sync-abstraction.cpp
+  ${TEST_HARNESS_DIR}/test-graphics-buffer.cpp
   ${TEST_HARNESS_DIR}/test-graphics-command-buffer.cpp
   ${TEST_HARNESS_DIR}/test-graphics-controller.cpp
   ${TEST_HARNESS_DIR}/test-graphics-texture.cpp
   ${TEST_HARNESS_DIR}/test-graphics-command-buffer.cpp
   ${TEST_HARNESS_DIR}/test-graphics-controller.cpp
   ${TEST_HARNESS_DIR}/test-graphics-texture.cpp
index 14ec132..e75b848 100755 (executable)
@@ -80,6 +80,7 @@ SET(TEST_HARNESS_SOURCES
    ../dali-toolkit/dali-toolkit-test-utils/test-harness.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-gl-sync-abstraction.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-harness.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-gl-sync-abstraction.cpp
+   ../dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-graphics-command-buffer.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-graphics-controller.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-graphics-texture.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-graphics-command-buffer.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-graphics-controller.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-graphics-texture.cpp
index 694c656..fa86caf 100644 (file)
@@ -46,6 +46,7 @@ SET(TEST_HARNESS_SOURCES
    ../dali-toolkit/dali-toolkit-test-utils/test-platform-abstraction.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-gl-sync-abstraction.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-platform-abstraction.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-gl-sync-abstraction.cpp
+   ../dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-graphics-command-buffer.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-graphics-controller.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-graphics-texture.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-graphics-command-buffer.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-graphics-controller.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-graphics-texture.cpp
index 90f8b7c..ec88375 100644 (file)
@@ -32,6 +32,7 @@ SET(TEST_HARNESS_SOURCES
    ../dali-toolkit/dali-toolkit-test-utils/test-harness.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-gl-sync-abstraction.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-harness.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-gl-sync-abstraction.cpp
+   ../dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-graphics-command-buffer.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-graphics-controller.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-graphics-texture.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-graphics-command-buffer.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-graphics-controller.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-graphics-texture.cpp
index fe00bc9..832a04b 100755 (executable)
@@ -110,6 +110,7 @@ SET(TEST_HARNESS_SOURCES
   dali-toolkit-test-utils/test-gesture-generator.cpp
   dali-toolkit-test-utils/test-gl-abstraction.cpp
   dali-toolkit-test-utils/test-gl-sync-abstraction.cpp
   dali-toolkit-test-utils/test-gesture-generator.cpp
   dali-toolkit-test-utils/test-gl-abstraction.cpp
   dali-toolkit-test-utils/test-gl-sync-abstraction.cpp
+  dali-toolkit-test-utils/test-graphics-buffer.cpp
   dali-toolkit-test-utils/test-graphics-command-buffer.cpp
   dali-toolkit-test-utils/test-graphics-controller.cpp
   dali-toolkit-test-utils/test-graphics-texture.cpp
   dali-toolkit-test-utils/test-graphics-command-buffer.cpp
   dali-toolkit-test-utils/test-graphics-controller.cpp
   dali-toolkit-test-utils/test-graphics-texture.cpp
index 2af9660..4e14dd9 100644 (file)
@@ -102,6 +102,12 @@ public:
 
   inline void BindBuffer(GLenum target, GLuint buffer) override
   {
 
   inline void BindBuffer(GLenum target, GLuint buffer) override
   {
+    std::ostringstream o;
+    o << std::hex << target << ", " << buffer;
+    TraceCallStack::NamedParams namedParams;
+    namedParams["target"] = target;
+    namedParams["buffer"] = buffer;
+    mBufferTrace.PushCall("BindBuffer", o.str(), namedParams);
   }
 
   inline void BindFramebuffer(GLenum target, GLuint framebuffer) override
   }
 
   inline void BindFramebuffer(GLenum target, GLuint framebuffer) override
@@ -242,11 +248,28 @@ public:
 
   inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) override
   {
 
   inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) override
   {
+    std::ostringstream o;
+    o << std::hex << target << ", " << size << ", " << data << ", " << usage;
+    TraceCallStack::NamedParams namedParams;
+    namedParams["target"] = target;
+    namedParams["size"]   = size;
+    namedParams["usage"]  = usage;
+
+    mBufferTrace.PushCall("BufferData", o.str(), namedParams);
+
     mBufferDataCalls.push_back(size);
   }
 
   inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) override
   {
     mBufferDataCalls.push_back(size);
   }
 
   inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) override
   {
+    std::ostringstream o;
+    o << std::hex << target << ", " << offset << ", " << size << ", " << data;
+    TraceCallStack::NamedParams namedParams;
+    namedParams["target"] = target;
+    namedParams["offset"] = offset;
+    namedParams["size"]   = size;
+    mBufferTrace.PushCall("BufferSubData", o.str());
+
     mBufferSubDataCalls.push_back(size);
   }
 
     mBufferSubDataCalls.push_back(size);
   }
 
@@ -613,6 +636,12 @@ public:
   {
     // avoids an assert in GpuBuffers
     *buffers = 1u;
   {
     // avoids an assert in GpuBuffers
     *buffers = 1u;
+
+    std::ostringstream o;
+    o << n;
+    TraceCallStack::NamedParams namedParams;
+    namedParams["n"] = o.str();
+    mBufferTrace.PushCall("GenBuffers", o.str(), namedParams);
   }
 
   inline void GenerateMipmap(GLenum target) override
   }
 
   inline void GenerateMipmap(GLenum target) override
@@ -2171,6 +2200,10 @@ public: // TEST FUNCTIONS
   {
     return mViewportTrace;
   }
   {
     return mViewportTrace;
   }
+  inline TraceCallStack& GetBufferTrace()
+  {
+    return mBufferTrace;
+  }
 
   template<typename T>
   inline bool GetUniformValue(const char* name, T& value) const
 
   template<typename T>
   inline bool GetUniformValue(const char* name, T& value) const
@@ -2434,10 +2467,11 @@ private:
 
   ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
 
 
   ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
 
+  TraceCallStack mBufferTrace{"gl"};
   TraceCallStack mCullFaceTrace;
   TraceCallStack mEnableDisableTrace;
   TraceCallStack mShaderTrace;
   TraceCallStack mCullFaceTrace;
   TraceCallStack mEnableDisableTrace;
   TraceCallStack mShaderTrace;
-  TraceCallStack mTextureTrace{"GlA Texture:"};
+  TraceCallStack mTextureTrace{"gl"};
   TraceCallStack mTexParamaterTrace;
   TraceCallStack mDrawTrace;
   TraceCallStack mDepthFunctionTrace;
   TraceCallStack mTexParamaterTrace;
   TraceCallStack mDrawTrace;
   TraceCallStack mDepthFunctionTrace;
diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.cpp
new file mode 100644 (file)
index 0000000..2696078
--- /dev/null
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "test-graphics-buffer.h"
+
+#include <sstream>
+
+namespace Dali
+{
+TestGraphicsBuffer::TestGraphicsBuffer(TraceCallStack& callStack, TestGlAbstraction& glAbstraction, uint32_t size, Graphics::BufferUsageFlags usage)
+: mCallStack(callStack),
+  mGl(glAbstraction),
+  mUsage(usage)
+{
+  memory.reserve(size);
+  mGl.GetBufferTrace().EnableLogging(true);
+}
+
+void TestGraphicsBuffer::Bind()
+{
+  mCallStack.PushCall("Buffer::Bind", "");
+  if(!mId)
+  {
+    mGl.GenBuffers(1, &mId);
+  }
+  mGl.BindBuffer(GetTarget(), mId);
+}
+
+void TestGraphicsBuffer::Unbind()
+{
+  mCallStack.PushCall("Buffer::Unbind", "");
+  if(mId)
+  {
+    mGl.BindBuffer(GetTarget(), 0);
+  }
+}
+
+void TestGraphicsBuffer::Upload(uint32_t offset, uint32_t size)
+{
+  std::ostringstream o;
+  o << offset << ", " << size;
+  TraceCallStack::NamedParams namedParams;
+  namedParams["offset"] = offset;
+  namedParams["size"]   = size;
+  mCallStack.PushCall("Buffer::Upload", o.str(), namedParams);
+  if(size <= memory.size() && mCreated)
+  {
+    // Use subData to avoid re-allocation
+    mGl.BufferSubData(GetTarget(), offset, size, &memory[offset]);
+  }
+  else
+  {
+    mGl.BufferData(GetTarget(), size, &memory[0], GL_STATIC_DRAW); //@todo Query - do we need other usages?
+    mCreated = true;
+  }
+}
+
+GLenum TestGraphicsBuffer::GetTarget()
+{
+  GLenum target = GL_ARRAY_BUFFER;
+  if((mUsage & static_cast<Graphics::BufferUsageFlags>(Graphics::BufferUsage::INDEX_BUFFER)) != 0)
+  {
+    target = GL_ELEMENT_ARRAY_BUFFER;
+  }
+  return target;
+}
+
+} // namespace Dali
index 6a0acac..c4abc3e 100644 (file)
  */
 
 #include <dali/graphics-api/graphics-buffer.h>
  */
 
 #include <dali/graphics-api/graphics-buffer.h>
+#include <dali/graphics-api/graphics-types.h>
+
+#include "test-gl-abstraction.h"
+#include "test-trace-call-stack.h"
 
 namespace Dali
 {
 class TestGraphicsBuffer : public Graphics::Buffer
 {
 public:
 
 namespace Dali
 {
 class TestGraphicsBuffer : public Graphics::Buffer
 {
 public:
-  TestGraphicsBuffer() = default;
+  TestGraphicsBuffer(TraceCallStack& callStack, TestGlAbstraction& glAbstraction, uint32_t size, Graphics::BufferUsageFlags usage);
+  void   Bind();
+  void   Unbind();
+  void   Upload(uint32_t offset, uint32_t size);
+  GLenum GetTarget();
+
+  TraceCallStack&            mCallStack;
+  TestGlAbstraction&         mGl;
+  std::vector<uint8_t>       memory;
+  Graphics::BufferUsageFlags mUsage;
+  GLuint                     mId{0};
+  bool                       mCreated{false};
 };
 
 } // namespace Dali
 };
 
 } // namespace Dali
index 4732a9a..e7f80cd 100644 (file)
@@ -16,6 +16,7 @@
 
 #include "test-graphics-controller.h"
 
 
 #include "test-graphics-controller.h"
 
+#include "dali-test-suite-utils.h"
 #include "test-graphics-buffer.h"
 #include "test-graphics-command-buffer.h"
 #include "test-graphics-sampler.h"
 #include "test-graphics-buffer.h"
 #include "test-graphics-command-buffer.h"
 #include "test-graphics-sampler.h"
@@ -140,6 +141,59 @@ std::ostream& operator<<(std::ostream& o, const Graphics::SamplerCreateInfo& cre
   return o;
 }
 
   return o;
 }
 
+class TestGraphicsMemory : public Graphics::Memory
+{
+public:
+  TestGraphicsMemory(TraceCallStack& callStack, TestGraphicsBuffer& buffer, uint32_t mappedOffset, uint32_t mappedSize)
+  : mCallStack(callStack),
+    mBuffer(buffer),
+    mMappedOffset(mappedOffset),
+    mMappedSize(mappedSize)
+  {
+  }
+
+  void* LockRegion(uint32_t offset, uint32_t size) override
+  {
+    std::ostringstream o;
+    o << offset << ", " << size;
+    mCallStack.PushCall("Memory::LockRegion", o.str());
+
+    if(offset > mMappedOffset + mMappedSize ||
+       size + offset > mMappedOffset + mMappedSize)
+    {
+      tet_infoline("TestGraphics.Memory::LockRegion() Out of bounds");
+      mBuffer.memory.resize(mMappedOffset + offset + size); // Grow to prevent memcpy from crashing
+    }
+    mLockedOffset = offset;
+    mLockedSize   = size;
+    return &mBuffer.memory[mMappedOffset + offset];
+  }
+
+  void Unlock(bool flush) override
+  {
+    mCallStack.PushCall("Memory::Unlock", (flush ? "Flush" : "NoFlush"));
+    if(flush)
+    {
+      Flush();
+    }
+  }
+
+  void Flush() override
+  {
+    mCallStack.PushCall("Memory::Flush", "");
+    mBuffer.Bind();
+    mBuffer.Upload(mMappedOffset + mLockedOffset, mLockedSize);
+    mBuffer.Unbind();
+  }
+
+  TraceCallStack&     mCallStack;
+  TestGraphicsBuffer& mBuffer;
+  uint32_t            mMappedOffset;
+  uint32_t            mMappedSize;
+  uint32_t            mLockedOffset;
+  uint32_t            mLockedSize;
+};
+
 TestGraphicsController::TestGraphicsController()
 {
   mCallStack.Enable(true);
 TestGraphicsController::TestGraphicsController()
 {
   mCallStack.Enable(true);
@@ -158,7 +212,7 @@ void TestGraphicsController::SubmitCommandBuffers(const Graphics::SubmitInfo& su
   out << "cmdBuffer[" << submitInfo.cmdBuffer.size() << "], flags:" << std::hex << submitInfo.flags;
   namedParams["submitInfo"] = out.str();
 
   out << "cmdBuffer[" << submitInfo.cmdBuffer.size() << "], flags:" << std::hex << submitInfo.flags;
   namedParams["submitInfo"] = out.str();
 
-  mCallStack.PushCall("SubmitCommandBuffers", "", namedParams);
+  mCallStack.PushCall("Controller::SubmitCommandBuffers", "", namedParams);
 
   for(auto& commandBuffer : submitInfo.cmdBuffer)
   {
 
   for(auto& commandBuffer : submitInfo.cmdBuffer)
   {
@@ -195,7 +249,7 @@ void TestGraphicsController::PresentRenderTarget(Graphics::RenderTarget* renderT
   TraceCallStack::NamedParams namedParams;
   out << std::hex << renderTarget;
   namedParams["renderTarget"] = out.str();
   TraceCallStack::NamedParams namedParams;
   out << std::hex << renderTarget;
   namedParams["renderTarget"] = out.str();
-  mCallStack.PushCall("PresentRenderTarget", "", namedParams);
+  mCallStack.PushCall("Controller::PresentRenderTarget", "", namedParams);
 }
 
 /**
 }
 
 /**
@@ -203,7 +257,7 @@ void TestGraphicsController::PresentRenderTarget(Graphics::RenderTarget* renderT
  */
 void TestGraphicsController::WaitIdle()
 {
  */
 void TestGraphicsController::WaitIdle()
 {
-  mCallStack.PushCall("WaitIdle", "");
+  mCallStack.PushCall("Controller::WaitIdle", "");
 }
 
 /**
 }
 
 /**
@@ -211,7 +265,7 @@ void TestGraphicsController::WaitIdle()
  */
 void TestGraphicsController::Pause()
 {
  */
 void TestGraphicsController::Pause()
 {
-  mCallStack.PushCall("Pause", "");
+  mCallStack.PushCall("Controller::Pause", "");
 }
 
 /**
 }
 
 /**
@@ -219,7 +273,7 @@ void TestGraphicsController::Pause()
  */
 void TestGraphicsController::Resume()
 {
  */
 void TestGraphicsController::Resume()
 {
-  mCallStack.PushCall("Resume", "");
+  mCallStack.PushCall("Controller::Resume", "");
 }
 
 void TestGraphicsController::UpdateTextures(const std::vector<Graphics::TextureUpdateInfo>&       updateInfoList,
 }
 
 void TestGraphicsController::UpdateTextures(const std::vector<Graphics::TextureUpdateInfo>&       updateInfoList,
@@ -233,7 +287,7 @@ void TestGraphicsController::UpdateTextures(const std::vector<Graphics::TextureU
   out << "[" << sourceList.size() << "]:";
   namedParams["sourceList"] = out.str();
 
   out << "[" << sourceList.size() << "]:";
   namedParams["sourceList"] = out.str();
 
-  mCallStack.PushCall("UpdateTextures", "", namedParams);
+  mCallStack.PushCall("Controller::UpdateTextures", "", namedParams);
 
   // Call either TexImage2D or TexSubImage2D
   for(unsigned int i = 0; i < updateInfoList.size(); ++i)
 
   // Call either TexImage2D or TexSubImage2D
   for(unsigned int i = 0; i < updateInfoList.size(); ++i)
@@ -252,7 +306,7 @@ bool TestGraphicsController::EnableDepthStencilBuffer(bool enableDepth, bool ena
   TraceCallStack::NamedParams namedParams;
   namedParams["enableDepth"]   = enableDepth ? "T" : "F";
   namedParams["enableStencil"] = enableStencil ? "T" : "F";
   TraceCallStack::NamedParams namedParams;
   namedParams["enableDepth"]   = enableDepth ? "T" : "F";
   namedParams["enableStencil"] = enableStencil ? "T" : "F";
-  mCallStack.PushCall("EnableDepthStencilBuffer", "", namedParams);
+  mCallStack.PushCall("Controller::EnableDepthStencilBuffer", "", namedParams);
   return false;
 }
 
   return false;
 }
 
@@ -262,17 +316,17 @@ void TestGraphicsController::RunGarbageCollector(size_t numberOfDiscardedRendere
   out << numberOfDiscardedRenderers;
   TraceCallStack::NamedParams namedParams;
   namedParams["numberOfDiscardedrenderers"] = out.str();
   out << numberOfDiscardedRenderers;
   TraceCallStack::NamedParams namedParams;
   namedParams["numberOfDiscardedrenderers"] = out.str();
-  mCallStack.PushCall("RunGarbageCollector", "", namedParams);
+  mCallStack.PushCall("Controller::RunGarbageCollector", "", namedParams);
 }
 
 void TestGraphicsController::DiscardUnusedResources()
 {
 }
 
 void TestGraphicsController::DiscardUnusedResources()
 {
-  mCallStack.PushCall("DiscardUnusedResources", "");
+  mCallStack.PushCall("Controller::DiscardUnusedResources", "");
 }
 
 bool TestGraphicsController::IsDiscardQueueEmpty()
 {
 }
 
 bool TestGraphicsController::IsDiscardQueueEmpty()
 {
-  mCallStack.PushCall("IsDiscardQueueEmpty", "");
+  mCallStack.PushCall("Controller::IsDiscardQueueEmpty", "");
   return isDiscardQueueEmptyResult;
 }
 
   return isDiscardQueueEmptyResult;
 }
 
@@ -283,30 +337,29 @@ bool TestGraphicsController::IsDiscardQueueEmpty()
  */
 bool TestGraphicsController::IsDrawOnResumeRequired()
 {
  */
 bool TestGraphicsController::IsDrawOnResumeRequired()
 {
-  mCallStack.PushCall("IsDrawOnResumeRequired", "");
+  mCallStack.PushCall("Controller::IsDrawOnResumeRequired", "");
   return isDrawOnResumeRequiredResult;
 }
 
   return isDrawOnResumeRequiredResult;
 }
 
-Graphics::UniquePtr<Graphics::Buffer> TestGraphicsController::CreateBuffer(const Graphics::BufferCreateInfo& bufferCreateInfo, Graphics::UniquePtr<Graphics::Buffer>&& oldBuffer)
+Graphics::UniquePtr<Graphics::Buffer> TestGraphicsController::CreateBuffer(const Graphics::BufferCreateInfo& createInfo, Graphics::UniquePtr<Graphics::Buffer>&& oldBuffer)
 {
   std::ostringstream oss;
 {
   std::ostringstream oss;
-  oss << "bufferCreateInfo:" << bufferCreateInfo;
-  mCallStack.PushCall("CreateBuffer", oss.str());
-
-  return Graphics::MakeUnique<TestGraphicsBuffer>();
+  oss << "bufferCreateInfo:" << createInfo;
+  mCallStack.PushCall("Controller::CreateBuffer", oss.str());
+  return Graphics::MakeUnique<TestGraphicsBuffer>(mCallStack, mGlAbstraction, createInfo.size, createInfo.usage);
 }
 
 Graphics::UniquePtr<Graphics::CommandBuffer> TestGraphicsController::CreateCommandBuffer(const Graphics::CommandBufferCreateInfo& commandBufferCreateInfo, Graphics::UniquePtr<Graphics::CommandBuffer>&& oldCommandBuffer)
 {
   std::ostringstream oss;
   oss << "commandBufferCreateInfo:" << commandBufferCreateInfo;
 }
 
 Graphics::UniquePtr<Graphics::CommandBuffer> TestGraphicsController::CreateCommandBuffer(const Graphics::CommandBufferCreateInfo& commandBufferCreateInfo, Graphics::UniquePtr<Graphics::CommandBuffer>&& oldCommandBuffer)
 {
   std::ostringstream oss;
   oss << "commandBufferCreateInfo:" << commandBufferCreateInfo;
-  mCallStack.PushCall("CreateCommandBuffer", oss.str());
+  mCallStack.PushCall("Controller::CreateCommandBuffer", oss.str());
   return Graphics::MakeUnique<TestGraphicsCommandBuffer>(mCommandBufferCallStack, mGlAbstraction);
 }
 
 Graphics::UniquePtr<Graphics::RenderPass> TestGraphicsController::CreateRenderPass(const Graphics::RenderPassCreateInfo& renderPassCreateInfo, Graphics::UniquePtr<Graphics::RenderPass>&& oldRenderPass)
 {
   return Graphics::MakeUnique<TestGraphicsCommandBuffer>(mCommandBufferCallStack, mGlAbstraction);
 }
 
 Graphics::UniquePtr<Graphics::RenderPass> TestGraphicsController::CreateRenderPass(const Graphics::RenderPassCreateInfo& renderPassCreateInfo, Graphics::UniquePtr<Graphics::RenderPass>&& oldRenderPass)
 {
-  mCallStack.PushCall("CreateRenderPass", "");
+  mCallStack.PushCall("Controller::CreateRenderPass", "");
   return nullptr;
 }
 
   return nullptr;
 }
 
@@ -317,26 +370,26 @@ Graphics::UniquePtr<Graphics::Texture> TestGraphicsController::CreateTexture(con
   TraceCallStack::NamedParams namedParams;
   oss << textureCreateInfo;
   namedParams["textureCreateInfo"] = oss.str();
   TraceCallStack::NamedParams namedParams;
   oss << textureCreateInfo;
   namedParams["textureCreateInfo"] = oss.str();
-  mCallStack.PushCall("CreateTexture", params.str(), namedParams);
+  mCallStack.PushCall("Controller::CreateTexture", params.str(), namedParams);
 
   return Graphics::MakeUnique<TestGraphicsTexture>(mGlAbstraction, textureCreateInfo);
 }
 
 Graphics::UniquePtr<Graphics::Framebuffer> TestGraphicsController::CreateFramebuffer(const Graphics::FramebufferCreateInfo& framebufferCreateInfo, Graphics::UniquePtr<Graphics::Framebuffer>&& oldFramebuffer)
 {
 
   return Graphics::MakeUnique<TestGraphicsTexture>(mGlAbstraction, textureCreateInfo);
 }
 
 Graphics::UniquePtr<Graphics::Framebuffer> TestGraphicsController::CreateFramebuffer(const Graphics::FramebufferCreateInfo& framebufferCreateInfo, Graphics::UniquePtr<Graphics::Framebuffer>&& oldFramebuffer)
 {
-  mCallStack.PushCall("CreateFramebuffer", "");
+  mCallStack.PushCall("Controller::CreateFramebuffer", "");
   return nullptr;
 }
 
 Graphics::UniquePtr<Graphics::Pipeline> TestGraphicsController::CreatePipeline(const Graphics::PipelineCreateInfo& pipelineCreateInfo, Graphics::UniquePtr<Graphics::Pipeline>&& oldPipeline)
 {
   return nullptr;
 }
 
 Graphics::UniquePtr<Graphics::Pipeline> TestGraphicsController::CreatePipeline(const Graphics::PipelineCreateInfo& pipelineCreateInfo, Graphics::UniquePtr<Graphics::Pipeline>&& oldPipeline)
 {
-  mCallStack.PushCall("CreatePipeline", "");
+  mCallStack.PushCall("Controller::CreatePipeline", "");
   return nullptr;
 }
 
 Graphics::UniquePtr<Graphics::Shader> TestGraphicsController::CreateShader(const Graphics::ShaderCreateInfo& shaderCreateInfo, Graphics::UniquePtr<Graphics::Shader>&& oldShader)
 {
   return nullptr;
 }
 
 Graphics::UniquePtr<Graphics::Shader> TestGraphicsController::CreateShader(const Graphics::ShaderCreateInfo& shaderCreateInfo, Graphics::UniquePtr<Graphics::Shader>&& oldShader)
 {
-  mCallStack.PushCall("CreateShader", "");
+  mCallStack.PushCall("Controller::CreateShader", "");
   return nullptr;
 }
 
   return nullptr;
 }
 
@@ -347,57 +400,61 @@ Graphics::UniquePtr<Graphics::Sampler> TestGraphicsController::CreateSampler(con
   TraceCallStack::NamedParams namedParams;
   oss << samplerCreateInfo;
   namedParams["samplerCreateInfo"] = oss.str();
   TraceCallStack::NamedParams namedParams;
   oss << samplerCreateInfo;
   namedParams["samplerCreateInfo"] = oss.str();
-  mCallStack.PushCall("CreateSampler", params.str(), namedParams);
+  mCallStack.PushCall("Controller::CreateSampler", params.str(), namedParams);
 
   return Graphics::MakeUnique<TestGraphicsSampler>(mGlAbstraction, samplerCreateInfo);
 }
 
 Graphics::UniquePtr<Graphics::RenderTarget> TestGraphicsController::CreateRenderTarget(const Graphics::RenderTargetCreateInfo& renderTargetCreateInfo, Graphics::UniquePtr<Graphics::RenderTarget>&& oldRenderTarget)
 {
 
   return Graphics::MakeUnique<TestGraphicsSampler>(mGlAbstraction, samplerCreateInfo);
 }
 
 Graphics::UniquePtr<Graphics::RenderTarget> TestGraphicsController::CreateRenderTarget(const Graphics::RenderTargetCreateInfo& renderTargetCreateInfo, Graphics::UniquePtr<Graphics::RenderTarget>&& oldRenderTarget)
 {
-  mCallStack.PushCall("CreateRenderTarget", "");
+  mCallStack.PushCall("Controller::CreateRenderTarget", "");
   return nullptr;
 }
 
 Graphics::UniquePtr<Graphics::Memory> TestGraphicsController::MapBufferRange(const Graphics::MapBufferInfo& mapInfo)
 {
   return nullptr;
 }
 
 Graphics::UniquePtr<Graphics::Memory> TestGraphicsController::MapBufferRange(const Graphics::MapBufferInfo& mapInfo)
 {
-  mCallStack.PushCall("MapBufferRange", "");
-  return nullptr;
+  mCallStack.PushCall("Controller::MapBufferRange", "");
+
+  auto buffer = static_cast<TestGraphicsBuffer*>(mapInfo.buffer);
+  buffer->memory.resize(mapInfo.offset + mapInfo.size); // For initial testing, allow writes past capacity
+
+  return std::make_unique<TestGraphicsMemory>(mCallStack, *buffer, mapInfo.offset, mapInfo.size);
 }
 
 Graphics::UniquePtr<Graphics::Memory> TestGraphicsController::MapTextureRange(const Graphics::MapTextureInfo& mapInfo)
 {
 }
 
 Graphics::UniquePtr<Graphics::Memory> TestGraphicsController::MapTextureRange(const Graphics::MapTextureInfo& mapInfo)
 {
-  mCallStack.PushCall("MapTextureRange", "");
+  mCallStack.PushCall("Controller::MapTextureRange", "");
   return nullptr;
 }
 
 void TestGraphicsController::UnmapMemory(Graphics::UniquePtr<Graphics::Memory> memory)
 {
   return nullptr;
 }
 
 void TestGraphicsController::UnmapMemory(Graphics::UniquePtr<Graphics::Memory> memory)
 {
-  mCallStack.PushCall("UnmapMemory", "");
+  mCallStack.PushCall("Controller::UnmapMemory", "");
 }
 
 Graphics::MemoryRequirements TestGraphicsController::GetTextureMemoryRequirements(Graphics::Texture& texture) const
 {
 }
 
 Graphics::MemoryRequirements TestGraphicsController::GetTextureMemoryRequirements(Graphics::Texture& texture) const
 {
-  mCallStack.PushCall("GetTextureMemoryRequirements", "");
+  mCallStack.PushCall("Controller::GetTextureMemoryRequirements", "");
   return Graphics::MemoryRequirements{};
 }
 
 Graphics::MemoryRequirements TestGraphicsController::GetBufferMemoryRequirements(Graphics::Buffer& buffer) const
 {
   return Graphics::MemoryRequirements{};
 }
 
 Graphics::MemoryRequirements TestGraphicsController::GetBufferMemoryRequirements(Graphics::Buffer& buffer) const
 {
-  mCallStack.PushCall("GetBufferMemoryRequirements", "");
+  mCallStack.PushCall("Controller::GetBufferMemoryRequirements", "");
   return Graphics::MemoryRequirements{};
 }
 
 const Graphics::TextureProperties& TestGraphicsController::GetTextureProperties(const Graphics::Texture& texture)
 {
   static Graphics::TextureProperties textureProperties{};
   return Graphics::MemoryRequirements{};
 }
 
 const Graphics::TextureProperties& TestGraphicsController::GetTextureProperties(const Graphics::Texture& texture)
 {
   static Graphics::TextureProperties textureProperties{};
-  mCallStack.PushCall("GetTextureProperties", "");
+  mCallStack.PushCall("Controller::GetTextureProperties", "");
 
   return textureProperties;
 }
 
 bool TestGraphicsController::PipelineEquals(const Graphics::Pipeline& pipeline0, const Graphics::Pipeline& pipeline1) const
 {
 
   return textureProperties;
 }
 
 bool TestGraphicsController::PipelineEquals(const Graphics::Pipeline& pipeline0, const Graphics::Pipeline& pipeline1) const
 {
-  mCallStack.PushCall("PipelineEquals", "");
+  mCallStack.PushCall("Controller::PipelineEquals", "");
   return false;
 }
 
   return false;
 }