XCEngine/tests/Resources/Shader/test_shader.cpp

#include <gtest/gtest.h>
#include <XCEngine/Resources/Shader/Shader.h>
#include <XCEngine/Core/Asset/ResourceTypes.h>
#include <XCEngine/Core/Containers/Array.h>

using namespace XCEngine::Resources;
using namespace XCEngine::Containers;

namespace {

TEST(Shader, DefaultConstructor) {
    Shader shader;
    EXPECT_EQ(shader.GetShaderType(), ShaderType::Fragment);
    EXPECT_EQ(shader.GetShaderLanguage(), ShaderLanguage::GLSL);
    EXPECT_FALSE(shader.IsValid());
    EXPECT_EQ(shader.GetMemorySize(), 0u);
}

TEST(Shader, GetType) {
    Shader shader;
    EXPECT_EQ(shader.GetType(), ResourceType::Shader);
}

TEST(Shader, SetGetShaderType) {
    Shader shader;
    
    shader.SetShaderType(ShaderType::Vertex);
    EXPECT_EQ(shader.GetShaderType(), ShaderType::Vertex);
    
    shader.SetShaderType(ShaderType::Fragment);
    EXPECT_EQ(shader.GetShaderType(), ShaderType::Fragment);
    
    shader.SetShaderType(ShaderType::Geometry);
    EXPECT_EQ(shader.GetShaderType(), ShaderType::Geometry);
    
    shader.SetShaderType(ShaderType::Compute);
    EXPECT_EQ(shader.GetShaderType(), ShaderType::Compute);
}

TEST(Shader, SetGetShaderLanguage) {
    Shader shader;
    
    shader.SetShaderLanguage(ShaderLanguage::GLSL);
    EXPECT_EQ(shader.GetShaderLanguage(), ShaderLanguage::GLSL);
    
    shader.SetShaderLanguage(ShaderLanguage::HLSL);
    EXPECT_EQ(shader.GetShaderLanguage(), ShaderLanguage::HLSL);
    
    shader.SetShaderLanguage(ShaderLanguage::SPIRV);
    EXPECT_EQ(shader.GetShaderLanguage(), ShaderLanguage::SPIRV);
}

TEST(Shader, SetGetSourceCode) {
    Shader shader;
    const char* source = "#version 330 core\nvoid main() {}";
    
    shader.SetSourceCode(source);
    EXPECT_EQ(shader.GetSourceCode(), source);
}

TEST(Shader, SetGetCompiledBinary) {
    Shader shader;
    XCEngine::Containers::Array<XCEngine::Core::uint8> binary = { 0x00, 0x01, 0x02, 0x03 };
    
    shader.SetCompiledBinary(binary);
    EXPECT_EQ(shader.GetCompiledBinary().Size(), 4u);
    EXPECT_EQ(shader.GetCompiledBinary()[0], 0x00);
    EXPECT_EQ(shader.GetCompiledBinary()[3], 0x03);
}

TEST(Shader, AddGetUniforms) {
    Shader shader;
    
    ShaderUniform uniform1;
    uniform1.name = "uModelView";
    uniform1.location = 0;
    uniform1.size = 1;
    uniform1.type = 4;
    
    shader.AddUniform(uniform1);
    
    const auto& uniforms = shader.GetUniforms();
    EXPECT_EQ(uniforms.Size(), 1u);
    EXPECT_EQ(uniforms[0].name, "uModelView");
}

TEST(Shader, AddGetAttributes) {
    Shader shader;
    
    ShaderAttribute attr1;
    attr1.name = "aPosition";
    attr1.location = 0;
    attr1.size = 1;
    attr1.type = 3;
    
    shader.AddAttribute(attr1);
    
    const auto& attributes = shader.GetAttributes();
    EXPECT_EQ(attributes.Size(), 1u);
    EXPECT_EQ(attributes[0].name, "aPosition");
}

} // namespace