${TEST_HARNESS_DIR}/test-graphics-texture.cpp
${TEST_HARNESS_DIR}/test-graphics-sampler.cpp
${TEST_HARNESS_DIR}/test-graphics-pipeline.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-program.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-shader.cpp
${TEST_HARNESS_DIR}/test-graphics-reflection.cpp
${TEST_HARNESS_DIR}/test-platform-abstraction.cpp
${TEST_HARNESS_DIR}/test-render-controller.cpp
${TEST_HARNESS_DIR}/test-graphics-controller.cpp
${TEST_HARNESS_DIR}/test-graphics-texture.cpp
${TEST_HARNESS_DIR}/test-graphics-sampler.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-program.cpp
${TEST_HARNESS_DIR}/test-graphics-pipeline.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-shader.cpp
${TEST_HARNESS_DIR}/test-graphics-reflection.cpp
${TEST_HARNESS_DIR}/test-platform-abstraction.cpp
${TEST_HARNESS_DIR}/test-render-controller.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-program.cpp
../dali-toolkit/dali-toolkit-test-utils/test-graphics-pipeline.cpp
../dali-toolkit/dali-toolkit-test-utils/test-graphics-reflection.cpp
../dali-toolkit/dali-toolkit-test-utils/test-graphics-sampler.cpp
+ ../dali-toolkit/dali-toolkit-test-utils/test-graphics-shader.cpp
../dali-toolkit/dali-toolkit-test-utils/test-platform-abstraction.cpp
../dali-toolkit/dali-toolkit-test-utils/test-render-controller.cpp
../dali-toolkit/dali-toolkit-test-utils/test-trace-call-stack.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-pipeline.cpp
- ../dali-toolkit/dali-toolkit-test-utils/test-graphics-reflection.cpp
+ ../dali-toolkit/dali-toolkit-test-utils/test-graphics-program.cpp
../dali-toolkit/dali-toolkit-test-utils/test-graphics-sampler.cpp
+ ../dali-toolkit/dali-toolkit-test-utils/test-graphics-shader.cpp
+ ../dali-toolkit/dali-toolkit-test-utils/test-graphics-reflection.cpp
../dali-toolkit/dali-toolkit-test-utils/test-render-controller.cpp
../dali-toolkit/dali-toolkit-test-utils/test-trace-call-stack.cpp
../dali-toolkit/dali-toolkit-test-utils/test-native-image.cpp
../dali-toolkit/dali-toolkit-test-utils/test-graphics-texture.cpp
../dali-toolkit/dali-toolkit-test-utils/test-graphics-sampler.cpp
../dali-toolkit/dali-toolkit-test-utils/test-graphics-pipeline.cpp
+ ../dali-toolkit/dali-toolkit-test-utils/test-graphics-program.cpp
+ ../dali-toolkit/dali-toolkit-test-utils/test-graphics-shader.cpp
../dali-toolkit/dali-toolkit-test-utils/test-graphics-reflection.cpp
../dali-toolkit/dali-toolkit-test-utils/test-platform-abstraction.cpp
../dali-toolkit/dali-toolkit-test-utils/test-render-controller.cpp
dali-toolkit-test-utils/test-graphics-controller.cpp
dali-toolkit-test-utils/test-graphics-texture.cpp
dali-toolkit-test-utils/test-graphics-pipeline.cpp
+ dali-toolkit-test-utils/test-graphics-program.cpp
dali-toolkit-test-utils/test-graphics-reflection.cpp
dali-toolkit-test-utils/test-graphics-sampler.cpp
+ dali-toolkit-test-utils/test-graphics-shader.cpp
dali-toolkit-test-utils/test-platform-abstraction.cpp
dali-toolkit-test-utils/test-render-controller.cpp
dali-toolkit-test-utils/test-trace-call-stack.cpp
#include "test-graphics-command-buffer.h"
#include "test-graphics-reflection.h"
#include "test-graphics-sampler.h"
+#include "test-graphics-shader.h"
+#include "test-graphics-program.h"
#include "test-graphics-texture.h"
#include <dali/integration-api/gl-defines.h>
namedParams["submitInfo"] << "cmdBuffer[" << submitInfo.cmdBuffer.size()
<< "], flags:" << std::hex << submitInfo.flags;
- mCallStack.PushCall("Controller::SubmitCommandBuffers", "", namedParams);
+ mCallStack.PushCall("SubmitCommandBuffers", "", namedParams);
+
+ mSubmitStack.emplace_back(submitInfo);
for(auto& graphicsCommandBuffer : submitInfo.cmdBuffer)
{
{
TraceCallStack::NamedParams namedParams;
namedParams["renderTarget"] << std::hex << renderTarget;
- mCallStack.PushCall("Controller::PresentRenderTarget", "", namedParams);
+ mCallStack.PushCall("PresentRenderTarget", "", namedParams);
}
/**
*/
void TestGraphicsController::WaitIdle()
{
- mCallStack.PushCall("Controller::WaitIdle", "");
+ mCallStack.PushCall("WaitIdle", "");
}
/**
*/
void TestGraphicsController::Pause()
{
- mCallStack.PushCall("Controller::Pause", "");
+ mCallStack.PushCall("Pause", "");
}
/**
*/
void TestGraphicsController::Resume()
{
- mCallStack.PushCall("Controller::Resume", "");
+ mCallStack.PushCall("Resume", "");
}
void TestGraphicsController::UpdateTextures(const std::vector<Graphics::TextureUpdateInfo>& updateInfoList,
namedParams["updateInfoList"] << "[" << updateInfoList.size() << "]:";
namedParams["sourceList"] << "[" << sourceList.size() << "]:";
- mCallStack.PushCall("Controller::UpdateTextures", "", namedParams);
+ mCallStack.PushCall("UpdateTextures", "", namedParams);
// Call either TexImage2D or TexSubImage2D
for(unsigned int i = 0; i < updateInfoList.size(); ++i)
TraceCallStack::NamedParams namedParams;
namedParams["enableDepth"] << (enableDepth ? "T" : "F");
namedParams["enableStencil"] << (enableStencil ? "T" : "F");
- mCallStack.PushCall("Controller::EnableDepthStencilBuffer", "", namedParams);
+ mCallStack.PushCall("EnableDepthStencilBuffer", "", namedParams);
return false;
}
{
TraceCallStack::NamedParams namedParams;
namedParams["numberOfDiscardedRenderers"] << numberOfDiscardedRenderers;
- mCallStack.PushCall("Controller::RunGarbageCollector", "", namedParams);
+ mCallStack.PushCall("RunGarbageCollector", "", namedParams);
}
void TestGraphicsController::DiscardUnusedResources()
{
- mCallStack.PushCall("Controller::DiscardUnusedResources", "");
+ mCallStack.PushCall("DiscardUnusedResources", "");
}
bool TestGraphicsController::IsDiscardQueueEmpty()
{
- mCallStack.PushCall("Controller::IsDiscardQueueEmpty", "");
+ mCallStack.PushCall("IsDiscardQueueEmpty", "");
return isDiscardQueueEmptyResult;
}
*/
bool TestGraphicsController::IsDrawOnResumeRequired()
{
- mCallStack.PushCall("Controller::IsDrawOnResumeRequired", "");
+ mCallStack.PushCall("IsDrawOnResumeRequired", "");
return isDrawOnResumeRequiredResult;
}
{
std::ostringstream oss;
oss << "bufferCreateInfo:" << createInfo;
- mCallStack.PushCall("Controller::CreateBuffer", oss.str());
+ mCallStack.PushCall("CreateBuffer", oss.str());
return Graphics::MakeUnique<TestGraphicsBuffer>(mCallStack, mGl, createInfo.size, createInfo.usage);
}
{
std::ostringstream oss;
oss << "commandBufferCreateInfo:" << commandBufferCreateInfo;
- mCallStack.PushCall("Controller::CreateCommandBuffer", oss.str());
+ mCallStack.PushCall("CreateCommandBuffer", oss.str());
return Graphics::MakeUnique<TestGraphicsCommandBuffer>(mCommandBufferCallStack, mGl);
}
Graphics::UniquePtr<Graphics::RenderPass> TestGraphicsController::CreateRenderPass(const Graphics::RenderPassCreateInfo& renderPassCreateInfo, Graphics::UniquePtr<Graphics::RenderPass>&& oldRenderPass)
{
- mCallStack.PushCall("Controller::CreateRenderPass", "");
+ mCallStack.PushCall("CreateRenderPass", "");
return nullptr;
}
{
TraceCallStack::NamedParams namedParams;
namedParams["textureCreateInfo"] << textureCreateInfo;
- mCallStack.PushCall("Controller::CreateTexture", namedParams.str(), namedParams);
+ mCallStack.PushCall("CreateTexture", namedParams.str(), namedParams);
return Graphics::MakeUnique<TestGraphicsTexture>(mGl, textureCreateInfo);
}
Graphics::UniquePtr<Graphics::Framebuffer> TestGraphicsController::CreateFramebuffer(const Graphics::FramebufferCreateInfo& framebufferCreateInfo, Graphics::UniquePtr<Graphics::Framebuffer>&& oldFramebuffer)
{
- mCallStack.PushCall("Controller::CreateFramebuffer", "");
+ mCallStack.PushCall("CreateFramebuffer", "");
return nullptr;
}
Graphics::UniquePtr<Graphics::Pipeline> TestGraphicsController::CreatePipeline(const Graphics::PipelineCreateInfo& pipelineCreateInfo, Graphics::UniquePtr<Graphics::Pipeline>&& oldPipeline)
{
- mCallStack.PushCall("Controller::CreatePipeline", "");
+ mCallStack.PushCall("CreatePipeline", "");
return std::make_unique<TestGraphicsPipeline>(mGl, pipelineCreateInfo);
}
+Graphics::UniquePtr<Graphics::Program> TestGraphicsController::CreateProgram(const Graphics::ProgramCreateInfo& programCreateInfo, Graphics::UniquePtr<Graphics::Program>&& oldProgram)
+{
+ mCallStack.PushCall("CreateProgram", "");
+ return Graphics::MakeUnique<TestGraphicsProgram>(mGl, programCreateInfo, mVertexFormats);
+}
+
Graphics::UniquePtr<Graphics::Shader> TestGraphicsController::CreateShader(const Graphics::ShaderCreateInfo& shaderCreateInfo, Graphics::UniquePtr<Graphics::Shader>&& oldShader)
{
- mCallStack.PushCall("Controller::CreateShader", "");
- return nullptr;
+ mCallStack.PushCall("CreateShader", "");
+ return Graphics::MakeUnique<TestGraphicsShader>(mGl, shaderCreateInfo);
}
Graphics::UniquePtr<Graphics::Sampler> TestGraphicsController::CreateSampler(const Graphics::SamplerCreateInfo& samplerCreateInfo, Graphics::UniquePtr<Graphics::Sampler>&& oldSampler)
{
TraceCallStack::NamedParams namedParams;
namedParams["samplerCreateInfo"] << samplerCreateInfo;
- mCallStack.PushCall("Controller::CreateSampler", namedParams.str(), namedParams);
+ mCallStack.PushCall("CreateSampler", namedParams.str(), namedParams);
return Graphics::MakeUnique<TestGraphicsSampler>(mGl, samplerCreateInfo);
}
Graphics::UniquePtr<Graphics::RenderTarget> TestGraphicsController::CreateRenderTarget(const Graphics::RenderTargetCreateInfo& renderTargetCreateInfo, Graphics::UniquePtr<Graphics::RenderTarget>&& oldRenderTarget)
{
- mCallStack.PushCall("Controller::CreateRenderTarget", "");
+ mCallStack.PushCall("CreateRenderTarget", "");
return nullptr;
}
Graphics::UniquePtr<Graphics::Memory> TestGraphicsController::MapBufferRange(const Graphics::MapBufferInfo& mapInfo)
{
- mCallStack.PushCall("Controller::MapBufferRange", "");
+ mCallStack.PushCall("MapBufferRange", "");
auto buffer = static_cast<TestGraphicsBuffer*>(mapInfo.buffer);
buffer->memory.resize(mapInfo.offset + mapInfo.size); // For initial testing, allow writes past capacity
Graphics::UniquePtr<Graphics::Memory> TestGraphicsController::MapTextureRange(const Graphics::MapTextureInfo& mapInfo)
{
- mCallStack.PushCall("Controller::MapTextureRange", "");
+ mCallStack.PushCall("MapTextureRange", "");
return nullptr;
}
void TestGraphicsController::UnmapMemory(Graphics::UniquePtr<Graphics::Memory> memory)
{
- mCallStack.PushCall("Controller::UnmapMemory", "");
+ mCallStack.PushCall("UnmapMemory", "");
}
Graphics::MemoryRequirements TestGraphicsController::GetTextureMemoryRequirements(Graphics::Texture& texture) const
{
- mCallStack.PushCall("Controller::GetTextureMemoryRequirements", "");
+ mCallStack.PushCall("GetTextureMemoryRequirements", "");
return Graphics::MemoryRequirements{};
}
Graphics::MemoryRequirements TestGraphicsController::GetBufferMemoryRequirements(Graphics::Buffer& buffer) const
{
- mCallStack.PushCall("Controller::GetBufferMemoryRequirements", "");
+ mCallStack.PushCall("GetBufferMemoryRequirements", "");
return Graphics::MemoryRequirements{};
}
const Graphics::TextureProperties& TestGraphicsController::GetTextureProperties(const Graphics::Texture& texture)
{
static Graphics::TextureProperties textureProperties{};
- mCallStack.PushCall("Controller::GetTextureProperties", "");
+ mCallStack.PushCall("GetTextureProperties", "");
return textureProperties;
}
-const Graphics::Reflection& TestGraphicsController::GetPipelineReflection(const Graphics::Pipeline& pipeline)
+const Graphics::Reflection& TestGraphicsController::GetProgramReflection(const Graphics::Program& program)
{
- static TestGraphicsReflection reflection(mGl);
- mCallStack.PushCall("Controller::GetPipelineReflection", "");
+ mCallStack.PushCall("GetProgramReflection", "");
- return reflection;
+ return static_cast<const TestGraphicsProgram*>(&program)->GetReflection();
}
bool TestGraphicsController::PipelineEquals(const Graphics::Pipeline& pipeline0, const Graphics::Pipeline& pipeline1) const
{
- mCallStack.PushCall("Controller::PipelineEquals", "");
+ mCallStack.PushCall("PipelineEquals", "");
+ return false;
+}
+
+bool TestGraphicsController::GetProgramParameter(Graphics::Program& program, uint32_t parameterId, void* outData )
+{
+ mCallStack.PushCall("GetProgramParameter", "");
return false;
}
Graphics::UniquePtr<Graphics::Pipeline> CreatePipeline(const Graphics::PipelineCreateInfo& pipelineCreateInfo, Graphics::UniquePtr<Graphics::Pipeline>&& oldPipeline) override;
/**
+ * @brief Creates new Program object
+ *
+ * @param[in] programCreateInfo The valid ProgramCreateInfo structure
+ * @return pointer to the Program object
+ */
+ Graphics::UniquePtr<Graphics::Program> CreateProgram(const Graphics::ProgramCreateInfo& programCreateInfo, Graphics::UniquePtr<Graphics::Program>&& oldProgram) override;
+
+ /**
* @brief Creates new Shader object
*
* @param[in] shaderCreateInfo The valid ShaderCreateInfo structure
const Graphics::TextureProperties& GetTextureProperties(const Graphics::Texture& texture) override;
/**
- * @brief Returns the reflection of the given pipeline
+ * @brief Returns the reflection of the given program
*
- * @param[in] pipeline The pipeline
- * @return The reflection of the pipeline
+ * @param[in] program The program
+ * @return The reflection of the program
*/
- const Graphics::Reflection& GetPipelineReflection(const Graphics::Pipeline& pipeline) override;
+ const Graphics::Reflection& GetProgramReflection(const Graphics::Program& program) override;
/**
* @brief Tests whether two Pipelines are the same.
*/
bool PipelineEquals(const Graphics::Pipeline& pipeline0, const Graphics::Pipeline& pipeline1) const override;
+public: // Test Functions
+ void SetVertexFormats(Property::Array& vfs)
+ {
+ mVertexFormats = vfs;
+ }
+
+ void ClearSubmitStack()
+ {
+ mSubmitStack.clear();
+ }
+
+ /**
+ * @brief Retrieves program parameters
+ *
+ * This function can be used to retrieve data from internal implementation
+ *
+ * @param[in] program Valid program object
+ * @param[in] parameterId Integer parameter id
+ * @param[out] outData Pointer to output memory
+ * @return True on success
+ */
+ bool GetProgramParameter(Graphics::Program& program, uint32_t parameterId, void* outData ) override;
+
public:
- mutable TraceCallStack mCallStack;
- mutable TraceCallStack mCommandBufferCallStack;
+ mutable TraceCallStack mCallStack;
+ mutable TraceCallStack mCommandBufferCallStack;
+ mutable std::vector<Graphics::SubmitInfo> mSubmitStack;
TestGlAbstraction mGl;
TestGlSyncAbstraction mGlSyncAbstraction;
bool isDiscardQueueEmptyResult{true};
bool isDrawOnResumeRequiredResult{true};
+
+ Property::Array mVertexFormats;
};
} // namespace Dali
if(createInfo.colorBlendState)
colorBlendState = *createInfo.colorBlendState;
- if(createInfo.shaderState)
- shaderState = *createInfo.shaderState;
+ if(createInfo.programState)
+ programState = *createInfo.programState;
if(createInfo.viewportState)
viewportState = *createInfo.viewportState;
#include <dali/graphics-api/graphics-pipeline-create-info.h>
#include <dali/graphics-api/graphics-pipeline.h>
#include "test-gl-abstraction.h"
+#include "test-graphics-program.h"
+#include "test-graphics-reflection.h"
namespace Dali
{
+class TestGraphicsReflection;
+
+template<typename T>
+T* Uncast(const Graphics::Program* object)
+{
+ return const_cast<T*>(static_cast<const T*>(object));
+}
+
class TestGraphicsPipeline : public Graphics::Pipeline
{
public:
TestGraphicsPipeline(TestGlAbstraction& gl, const Graphics::PipelineCreateInfo& createInfo);
+ const TestGraphicsReflection& GetReflection() const
+ {
+ return Uncast<TestGraphicsProgram>(programState.program)->GetReflection();
+ }
+
+public:
TestGlAbstraction& mGl;
Graphics::ColorBlendState colorBlendState;
- std::vector<Graphics::ShaderState> shaderState;
+ Graphics::ProgramState programState;
Graphics::ViewportState viewportState;
Graphics::FramebufferState framebufferState;
Graphics::Pipeline basePipeline;
--- /dev/null
+/*
+ * 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-program.h"
+
+namespace Dali
+{
+TestGraphicsProgram::TestGraphicsProgram(TestGlAbstraction& gl, const Graphics::ProgramCreateInfo& createInfo, Property::Array& vertexFormats)
+: mGl(gl),
+ mCreateInfo(createInfo),
+ mReflection(gl, vertexFormats)
+{
+}
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_TEST_GRAPHICS_PROGRAM_H
+#define DALI_TEST_GRAPHICS_PROGRAM_H
+
+/*
+ * 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 <dali/graphics-api/graphics-program-create-info.h>
+#include <dali/graphics-api/graphics-program.h>
+#include "test-gl-abstraction.h"
+#include "test-graphics-reflection.h"
+
+namespace Dali
+{
+class TestGraphicsProgram : public Graphics::Program
+{
+public:
+ TestGraphicsProgram(TestGlAbstraction& gl, const Graphics::ProgramCreateInfo& createInfo, Property::Array& vertexFormats);
+
+ // For API
+ const TestGraphicsReflection& GetReflection() const
+ {
+ // Build a reflection
+ return mReflection;
+ }
+
+ // For tests
+ TestGraphicsReflection& GetProgamReflection()
+ {
+ return mReflection;
+ }
+
+public:
+ TestGlAbstraction& mGl;
+ Graphics::ProgramCreateInfo mCreateInfo;
+ TestGraphicsReflection mReflection;
+};
+
+} // namespace Dali
+
+#endif //DALI_TEST_GRAPHICS_PROGRAM_H
*/
#include "test-graphics-reflection.h"
+#include <dali/public-api/object/property-map.h>
namespace Dali
{
-TestGraphicsReflection::TestGraphicsReflection(TestGlAbstraction& gl)
+TestGraphicsReflection::TestGraphicsReflection(TestGlAbstraction& gl, Property::Array& vfs)
: mGl(gl)
{
+ for(Property::Array::SizeType i = 0; i < vfs.Count(); ++i)
+ {
+ Property::Map* vertexFormat = vfs[i].GetMap();
+ if(vertexFormat)
+ {
+ for(Property::Map::SizeType j = 0; j < vertexFormat->Count(); ++j)
+ {
+ auto key = vertexFormat->GetKeyAt(j);
+ if(key.type == Property::Key::STRING)
+ {
+ mAttributes.push_back(key.stringKey);
+ }
+ }
+ }
+ }
}
uint32_t TestGraphicsReflection::GetVertexAttributeLocation(const std::string& name) const
{
+ // Automatically assign locations to named attributes when requested
+ auto iter = std::find(mAttributes.begin(), mAttributes.end(), name);
+ if(iter != mAttributes.end())
+ {
+ return iter - mAttributes.begin();
+ }
+ else
+ {
+ uint32_t location = mAttributes.size();
+ mAttributes.push_back(name);
+ return location;
+ }
return 0u;
}
std::vector<uint32_t> TestGraphicsReflection::GetVertexAttributeLocations() const
{
- return std::vector<uint32_t>{};
+ std::vector<uint32_t> locs;
+ for(uint32_t i = 0; i < mAttributes.size(); ++i)
+ {
+ locs.push_back(i);
+ }
+ return locs;
}
uint32_t TestGraphicsReflection::GetUniformBlockCount() const
class TestGraphicsReflection : public Graphics::Reflection
{
public:
- TestGraphicsReflection(TestGlAbstraction& gl);
+ TestGraphicsReflection(TestGlAbstraction& gl, Property::Array& vertexFormats);
uint32_t GetVertexAttributeLocation(const std::string& name) const override;
Dali::Graphics::VertexInputAttributeFormat GetVertexAttributeFormat(uint32_t location) const override;
std::vector<Dali::Graphics::UniformInfo> GetSamplers() const override;
Graphics::ShaderLanguage GetLanguage() const override;
- TestGlAbstraction& mGl;
+public: // Test methods
+ void SetAttributes(std::vector<std::string> locations)
+ {
+ mAttributes.clear();
+ mAttributes.resize(locations.size());
+ for(auto& location : locations)
+ {
+ mAttributes.push_back(location);
+ }
+ }
+
+ TestGlAbstraction& mGl;
+ mutable std::vector<std::string> mAttributes;
};
} // namespace Dali
--- /dev/null
+/*
+ * 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-shader.h"
+
+namespace Dali
+{
+TestGraphicsShader::TestGraphicsShader(TestGlAbstraction& gl, const Graphics::ShaderCreateInfo& createInfo)
+: mGl(gl),
+ mCreateInfo(createInfo)
+{
+}
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_TEST_GRAPHICS_SHADER_H
+#define DALI_TEST_GRAPHICS_SHADER_H
+
+/*
+ * 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 <dali/graphics-api/graphics-shader-create-info.h>
+#include <dali/graphics-api/graphics-shader.h>
+#include "test-gl-abstraction.h"
+
+namespace Dali
+{
+class TestGraphicsShader : public Graphics::Shader
+{
+public:
+ TestGraphicsShader(TestGlAbstraction& gl, const Graphics::ShaderCreateInfo& createInfo);
+
+public:
+ TestGlAbstraction& mGl;
+ Graphics::ShaderCreateInfo mCreateInfo;
+};
+
+} // namespace Dali
+
+#endif //DALI_TEST_GRAPHICS_SHADER_H