host/tests/GLSnapshotShaders_unittest.cpp - platform/hardware/google/gfxstream - Git at Google

 // Copyright (C) 2018 The Android Open Source Project
 //
 // 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 "GLSnapshotTesting.h"

 #include <gtest/gtest.h>

 #include <string>

 namespace gfxstream {
 namespace gl {
 namespace {

 static const char kTestVertexShaderSource[] = R"(
 attribute vec4 position;
 uniform mat4 projection;
 uniform mat4 transform;
 uniform mat4 screenSpace;
 varying float linear;
 void main(void) {
     vec4 transformedPosition = projection * transform * position;
     gl_Position = transformedPosition;
     linear = (screenSpace * position).x;
 }
 )";

 static const char kTestFragmentShaderSource[] = R"(
 precision mediump float;
 void main() {
     gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
 }
 )";

 struct GlShaderState {
     GLenum type;
     GLboolean deleteStatus;
     GLboolean compileStatus;
     GLint infoLogLength;
     std::vector<GLchar> infoLog;
     GLint sourceLength;
     std::string source;
 };

 // SnapshotGlShaderTest - A helper class for testing snapshot's preservation of
 // a GL shader object's states.
 //
 // It operates like SnapshotPreserveTest, and also holds information about a
 // particular shader object which is manipulated in tests using
 // SnapshotGlShaderTest as a fixture.
 // Helper functions like loadSource first need a created shader identified by
 // |m_shader_name|. This creation happens by default in stateChange. Use them in
 // a lambda, set through setShaderStateChanger, to set up state without
 // overriding doCheckedSnapshot.
 //
 class SnapshotGlShaderTest : public SnapshotPreserveTest {
 public:
     void defaultStateCheck() override {
         EXPECT_EQ(GL_FALSE, gl->glIsShader(m_shader_name));
     }

     void changedStateCheck() override {
         SCOPED_TRACE("for shader " + std::to_string(m_shader_name));

         EXPECT_TRUE(compareParameter(GL_SHADER_TYPE, m_shader_state.type));
         EXPECT_TRUE(compareParameter(GL_DELETE_STATUS,
                                      m_shader_state.deleteStatus));
         EXPECT_TRUE(compareParameter(GL_COMPILE_STATUS,
                                      m_shader_state.compileStatus));
         EXPECT_TRUE(compareParameter(GL_INFO_LOG_LENGTH,
                                      m_shader_state.infoLogLength));
         EXPECT_TRUE(compareParameter(GL_SHADER_SOURCE_LENGTH,
                                      m_shader_state.sourceLength));

         std::vector<GLchar> srcData = {};
         srcData.resize(m_shader_state.sourceLength);
         gl->glGetShaderSource(m_shader_name, m_shader_state.sourceLength,
                               nullptr, srcData.data());
         if (srcData.data() == NULL) {
             EXPECT_EQ(0, m_shader_state.source.length()) << "source is empty";
         } else {
             EXPECT_STREQ(m_shader_state.source.c_str(), srcData.data());
         }

         std::vector<GLchar> infoLogData = {};
         infoLogData.resize(m_shader_state.infoLogLength);
         gl->glGetShaderInfoLog(m_shader_name, m_shader_state.infoLogLength,
                                nullptr, infoLogData.data());
         if (infoLogData.data() == NULL) {
             EXPECT_EQ(0, m_shader_state.infoLogLength) << "info log is empty";
         } else {
             EXPECT_STREQ(m_shader_state.infoLog.data(), infoLogData.data());
         }
     }

     void stateChange() override {
         m_shader_name = gl->glCreateShader(m_shader_state.type);
         m_shader_state_changer();

         // Store state of info log
         gl->glGetShaderiv(m_shader_name, GL_INFO_LOG_LENGTH,
                           &m_shader_state.infoLogLength);
         m_shader_state.infoLog.resize(m_shader_state.infoLogLength);
         gl->glGetShaderInfoLog(m_shader_name, m_shader_state.infoLogLength,
                                nullptr, m_shader_state.infoLog.data());
     }

     void loadSource(const std::string& sourceString) {
         GLboolean compiler;
         gl->glGetBooleanv(GL_SHADER_COMPILER, &compiler);
         EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
         if (compiler == GL_FALSE) {
             fprintf(stderr, "Shader compiler is not supported.\n");
             return;
         }

         if (m_shader_name == 0) {
             FAIL() << "Cannot set source without a shader name";
         }
         m_shader_state.source = sourceString;
         GLint len = sourceString.length();
         if (len > 0) {
             m_shader_state.sourceLength =
                     len + 1;  // Counts the null terminator
         }
         const char* source = sourceString.c_str();
         const char** sources = &source;
         gl->glShaderSource(m_shader_name, 1, sources, &len);
         EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
     }

     void compile(GLboolean expectCompileStatus = GL_TRUE) {
         GLboolean compiler;
         gl->glGetBooleanv(GL_SHADER_COMPILER, &compiler);
         if (compiler == GL_FALSE) {
             fprintf(stderr, "Shader compiler is not supported.\n");
             return;
         }

         if (m_shader_name == 0) {
             ADD_FAILURE() << "Cannot compile shader without a shader name";
         }
         if (m_shader_state.source.length() == 0) {
             ADD_FAILURE() << "Shader needs source to compile";
         }
         gl->glCompileShader(m_shader_name);
         m_shader_state.compileStatus = expectCompileStatus;
     }

     // Supply a lambda as |changer| to perform additional state setup after the
     // shader has been created but before the snapshot is performed.
     void setShaderStateChanger(std::function<void()> changer) {
         m_shader_state_changer = changer;
     }

 protected:
     testing::AssertionResult compareParameter(GLenum paramName,
                                               GLenum expected) {
         GLint value;
         gl->glGetShaderiv(m_shader_name, paramName, &value);
         EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
         return compareValue<GLint>(
                 expected, value,
                 "mismatch on parameter " + describeGlEnum(paramName) +
                         " for shader " + std::to_string(m_shader_name));
     }

     GlShaderState m_shader_state = {};
     GLuint m_shader_name;
     std::function<void()> m_shader_state_changer = [] {};
 };

 class SnapshotGlVertexShaderTest : public SnapshotGlShaderTest {
 public:
     SnapshotGlVertexShaderTest() { m_shader_state = {GL_VERTEX_SHADER}; }
 };

 TEST_F(SnapshotGlVertexShaderTest, Create) {
     doCheckedSnapshot();
 }

 TEST_F(SnapshotGlVertexShaderTest, SetSource) {
     setShaderStateChanger(
             [this] { loadSource(std::string(kTestVertexShaderSource)); });
     doCheckedSnapshot();
 }

 TEST_F(SnapshotGlVertexShaderTest, CompileSuccess) {
     setShaderStateChanger([this] {
         loadSource(std::string(kTestVertexShaderSource));
         compile();
     });
     doCheckedSnapshot();
 }

 TEST_F(SnapshotGlVertexShaderTest, CompileFail) {
     std::string failedShader = "vec3 hi my name is compile failed";
     setShaderStateChanger([this, &failedShader] {
         loadSource(failedShader);
         compile(GL_FALSE);
     });
     doCheckedSnapshot();
 }

 class SnapshotGlFragmentShaderTest : public SnapshotGlShaderTest {
 public:
     SnapshotGlFragmentShaderTest() { m_shader_state = {GL_FRAGMENT_SHADER}; }
 };

 TEST_F(SnapshotGlFragmentShaderTest, Create) {
     doCheckedSnapshot();
 }

 TEST_F(SnapshotGlFragmentShaderTest, SetSource) {
     setShaderStateChanger(
             [this] { loadSource(std::string(kTestFragmentShaderSource)); });
     doCheckedSnapshot();
 }

 TEST_F(SnapshotGlFragmentShaderTest, CompileSuccess) {
     setShaderStateChanger([this] {
         loadSource(std::string(kTestFragmentShaderSource));
         compile();
     });
     doCheckedSnapshot();
 }

 TEST_F(SnapshotGlFragmentShaderTest, CompileFail) {
     std::string failedShader = "vec3 nice to meet you compile failed";
     setShaderStateChanger([this, &failedShader] {
         loadSource(failedShader);
         compile(GL_FALSE);
     });
     doCheckedSnapshot();
 }

 }  // namespace
 }  // namespace gl
 }  // namespace gfxstream
	// Copyright (C) 2018 The Android Open Source Project
	//
	// 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 "GLSnapshotTesting.h"

	#include <gtest/gtest.h>

	#include <string>

	namespace gfxstream {
	namespace gl {
	namespace {

	static const char kTestVertexShaderSource[] = R"(
	attribute vec4 position;
	uniform mat4 projection;
	uniform mat4 transform;
	uniform mat4 screenSpace;
	varying float linear;
	void main(void) {
	vec4 transformedPosition = projection * transform * position;
	gl_Position = transformedPosition;
	linear = (screenSpace * position).x;
	}
	)";

	static const char kTestFragmentShaderSource[] = R"(
	precision mediump float;
	void main() {
	gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
	}
	)";

	struct GlShaderState {
	GLenum type;
	GLboolean deleteStatus;
	GLboolean compileStatus;
	GLint infoLogLength;
	std::vector<GLchar> infoLog;
	GLint sourceLength;
	std::string source;
	};

	// SnapshotGlShaderTest - A helper class for testing snapshot's preservation of
	// a GL shader object's states.
	//
	// It operates like SnapshotPreserveTest, and also holds information about a
	// particular shader object which is manipulated in tests using
	// SnapshotGlShaderTest as a fixture.
	// Helper functions like loadSource first need a created shader identified by
	// \|m_shader_name\|. This creation happens by default in stateChange. Use them in
	// a lambda, set through setShaderStateChanger, to set up state without
	// overriding doCheckedSnapshot.
	//
	class SnapshotGlShaderTest : public SnapshotPreserveTest {
	public:
	void defaultStateCheck() override {
	EXPECT_EQ(GL_FALSE, gl->glIsShader(m_shader_name));
	}

	void changedStateCheck() override {
	SCOPED_TRACE("for shader " + std::to_string(m_shader_name));

	EXPECT_TRUE(compareParameter(GL_SHADER_TYPE, m_shader_state.type));
	EXPECT_TRUE(compareParameter(GL_DELETE_STATUS,
	m_shader_state.deleteStatus));
	EXPECT_TRUE(compareParameter(GL_COMPILE_STATUS,
	m_shader_state.compileStatus));
	EXPECT_TRUE(compareParameter(GL_INFO_LOG_LENGTH,
	m_shader_state.infoLogLength));
	EXPECT_TRUE(compareParameter(GL_SHADER_SOURCE_LENGTH,
	m_shader_state.sourceLength));

	std::vector<GLchar> srcData = {};
	srcData.resize(m_shader_state.sourceLength);
	gl->glGetShaderSource(m_shader_name, m_shader_state.sourceLength,
	nullptr, srcData.data());
	if (srcData.data() == NULL) {
	EXPECT_EQ(0, m_shader_state.source.length()) << "source is empty";
	} else {
	EXPECT_STREQ(m_shader_state.source.c_str(), srcData.data());
	}

	std::vector<GLchar> infoLogData = {};
	infoLogData.resize(m_shader_state.infoLogLength);
	gl->glGetShaderInfoLog(m_shader_name, m_shader_state.infoLogLength,
	nullptr, infoLogData.data());
	if (infoLogData.data() == NULL) {
	EXPECT_EQ(0, m_shader_state.infoLogLength) << "info log is empty";
	} else {
	EXPECT_STREQ(m_shader_state.infoLog.data(), infoLogData.data());
	}
	}

	void stateChange() override {
	m_shader_name = gl->glCreateShader(m_shader_state.type);
	m_shader_state_changer();

	// Store state of info log
	gl->glGetShaderiv(m_shader_name, GL_INFO_LOG_LENGTH,
	&m_shader_state.infoLogLength);
	m_shader_state.infoLog.resize(m_shader_state.infoLogLength);
	gl->glGetShaderInfoLog(m_shader_name, m_shader_state.infoLogLength,
	nullptr, m_shader_state.infoLog.data());
	}

	void loadSource(const std::string& sourceString) {
	GLboolean compiler;
	gl->glGetBooleanv(GL_SHADER_COMPILER, &compiler);
	EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
	if (compiler == GL_FALSE) {
	fprintf(stderr, "Shader compiler is not supported.\n");
	return;
	}

	if (m_shader_name == 0) {
	FAIL() << "Cannot set source without a shader name";
	}
	m_shader_state.source = sourceString;
	GLint len = sourceString.length();
	if (len > 0) {
	m_shader_state.sourceLength =
	len + 1; // Counts the null terminator
	}
	const char* source = sourceString.c_str();
	const char** sources = &source;
	gl->glShaderSource(m_shader_name, 1, sources, &len);
	EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
	}

	void compile(GLboolean expectCompileStatus = GL_TRUE) {
	GLboolean compiler;
	gl->glGetBooleanv(GL_SHADER_COMPILER, &compiler);
	if (compiler == GL_FALSE) {
	fprintf(stderr, "Shader compiler is not supported.\n");
	return;
	}

	if (m_shader_name == 0) {
	ADD_FAILURE() << "Cannot compile shader without a shader name";
	}
	if (m_shader_state.source.length() == 0) {
	ADD_FAILURE() << "Shader needs source to compile";
	}
	gl->glCompileShader(m_shader_name);
	m_shader_state.compileStatus = expectCompileStatus;
	}

	// Supply a lambda as \|changer\| to perform additional state setup after the
	// shader has been created but before the snapshot is performed.
	void setShaderStateChanger(std::function<void()> changer) {
	m_shader_state_changer = changer;
	}

	protected:
	testing::AssertionResult compareParameter(GLenum paramName,
	GLenum expected) {
	GLint value;
	gl->glGetShaderiv(m_shader_name, paramName, &value);
	EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
	return compareValue<GLint>(
	expected, value,
	"mismatch on parameter " + describeGlEnum(paramName) +
	" for shader " + std::to_string(m_shader_name));
	}

	GlShaderState m_shader_state = {};
	GLuint m_shader_name;
	std::function<void()> m_shader_state_changer = [] {};
	};

	class SnapshotGlVertexShaderTest : public SnapshotGlShaderTest {
	public:
	SnapshotGlVertexShaderTest() { m_shader_state = {GL_VERTEX_SHADER}; }
	};

	TEST_F(SnapshotGlVertexShaderTest, Create) {
	doCheckedSnapshot();
	}

	TEST_F(SnapshotGlVertexShaderTest, SetSource) {
	setShaderStateChanger(
	[this] { loadSource(std::string(kTestVertexShaderSource)); });
	doCheckedSnapshot();
	}

	TEST_F(SnapshotGlVertexShaderTest, CompileSuccess) {
	setShaderStateChanger([this] {
	loadSource(std::string(kTestVertexShaderSource));
	compile();
	});
	doCheckedSnapshot();
	}

	TEST_F(SnapshotGlVertexShaderTest, CompileFail) {
	std::string failedShader = "vec3 hi my name is compile failed";
	setShaderStateChanger([this, &failedShader] {
	loadSource(failedShader);
	compile(GL_FALSE);
	});
	doCheckedSnapshot();
	}

	class SnapshotGlFragmentShaderTest : public SnapshotGlShaderTest {
	public:
	SnapshotGlFragmentShaderTest() { m_shader_state = {GL_FRAGMENT_SHADER}; }
	};

	TEST_F(SnapshotGlFragmentShaderTest, Create) {
	doCheckedSnapshot();
	}

	TEST_F(SnapshotGlFragmentShaderTest, SetSource) {
	setShaderStateChanger(
	[this] { loadSource(std::string(kTestFragmentShaderSource)); });
	doCheckedSnapshot();
	}

	TEST_F(SnapshotGlFragmentShaderTest, CompileSuccess) {
	setShaderStateChanger([this] {
	loadSource(std::string(kTestFragmentShaderSource));
	compile();
	});
	doCheckedSnapshot();
	}

	TEST_F(SnapshotGlFragmentShaderTest, CompileFail) {
	std::string failedShader = "vec3 nice to meet you compile failed";
	setShaderStateChanger([this, &failedShader] {
	loadSource(failedShader);
	compile(GL_FALSE);
	});
	doCheckedSnapshot();
	}

	} // namespace
	} // namespace gl
	} // namespace gfxstream