host/tests/GLSnapshotPrograms_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 "GLSnapshotTestStateUtils.h"
 #include "GLSnapshotTesting.h"
 #include "apigen-codec-common/glUtils.h"

 #include <gtest/gtest.h>
 #include <map>
 #include <string>

 namespace gfxstream {
 namespace gl {
 namespace {

 static const char kTestVertexShader[] = R"(
 attribute vec4 position;
 uniform mat4 testFloatMat;
 uniform mat4 transform;
 uniform mat4 screenSpace;
 uniform ivec3 testInts[2];
 varying float linear;
 void main(void) {
     gl_Position = testFloatMat * transform * position;
     linear = (screenSpace * position).x;
     gl_PointSize = linear * 0.5 + float(testInts[1].x);
 }
 )";

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

 struct GlShaderVariable {
     GLint size;
     GLenum type;
     std::vector<GLchar> name;
     GLint location;

     std::vector<GlValues> values;
 };

 struct GlProgramState {
     GLboolean deleteStatus;
     GLboolean linkStatus;
     GLboolean validateStatus;

     std::vector<GLchar> infoLog;

     std::vector<GLuint> shaders;

     GLint activeAttributes;
     GLint maxAttributeName;
     std::vector<GlShaderVariable> attributes;

     GLint activeUniforms;
     GLint maxUniformName;
     std::vector<GlShaderVariable> uniforms;
 };

 // SnapshotGlProgramTest - A helper class for testing the snapshot preservation
 // of program objects' state.
 //
 // This holds state information of a particular single program object whose
 // state is mutated in order to set up tests.
 // Provide a lambda via setStateChanger to set up the state which will be
 // checked for preservation.
 // A test can also verify that the snapshot keeps the correct program in use by
 // calling useProgram during state setup.
 //
 class SnapshotGlProgramTest : public SnapshotPreserveTest {
 public:
     void defaultStateCheck() override {
         EXPECT_EQ(GL_FALSE, gl->glIsProgram(m_program_name));
         EXPECT_TRUE(compareGlobalGlInt(gl, GL_CURRENT_PROGRAM, 0));
     }

     void changedStateCheck() override {
         SCOPED_TRACE("test program name = " + std::to_string(m_program_name));
         EXPECT_EQ(GL_TRUE, gl->glIsProgram(m_program_name));
         EXPECT_TRUE(
                 compareGlobalGlInt(gl, GL_CURRENT_PROGRAM, m_current_program));

         GlProgramState currentState = getProgramState();

         EXPECT_STREQ(m_program_state.infoLog.data(),
                      currentState.infoLog.data());

         EXPECT_EQ(m_program_state.deleteStatus, currentState.deleteStatus);
         EXPECT_EQ(m_program_state.linkStatus, currentState.linkStatus);
         EXPECT_EQ(m_program_state.validateStatus, currentState.validateStatus);

         // TODO(benzene): allow test to pass even if these are out of order
         EXPECT_EQ(m_program_state.shaders, currentState.shaders);

         EXPECT_EQ(m_program_state.activeAttributes,
                   currentState.activeAttributes);
         EXPECT_EQ(m_program_state.maxAttributeName,
                   currentState.maxAttributeName);
         ASSERT_EQ(m_program_state.attributes.size(),
                   currentState.attributes.size());
         for (int i = 0; i < currentState.attributes.size(); i++) {
             SCOPED_TRACE("active attribute i = " + std::to_string(i));
             EXPECT_EQ(m_program_state.attributes[i].size,
                       currentState.attributes[i].size);
             EXPECT_EQ(m_program_state.attributes[i].type,
                       currentState.attributes[i].type);
             EXPECT_STREQ(m_program_state.attributes[i].name.data(),
                          currentState.attributes[i].name.data());
             EXPECT_EQ(m_program_state.attributes[i].location,
                       currentState.attributes[i].location);

             // TODO(benzene): check attribute values?
         }

         EXPECT_EQ(m_program_state.activeUniforms, currentState.activeUniforms);
         EXPECT_EQ(m_program_state.maxUniformName, currentState.maxUniformName);
         ASSERT_EQ(m_program_state.uniforms.size(),
                   currentState.uniforms.size());
         for (int i = 0; i < currentState.uniforms.size(); i++) {
             SCOPED_TRACE("active uniform i = " + std::to_string(i));
             EXPECT_EQ(m_program_state.uniforms[i].size,
                       currentState.uniforms[i].size);
             EXPECT_EQ(m_program_state.uniforms[i].type,
                       currentState.uniforms[i].type);
             EXPECT_STREQ(m_program_state.uniforms[i].name.data(),
                          currentState.uniforms[i].name.data());
             EXPECT_EQ(m_program_state.uniforms[i].location,
                       currentState.uniforms[i].location);

             for (int j = 0; j < currentState.uniforms[i].size; j++) {
                 SCOPED_TRACE("value j = " + std::to_string(j));
                 GlValues& expectedVal = m_program_state.uniforms[i].values[j];
                 GlValues& currentVal = currentState.uniforms[i].values[j];
                 if (currentVal.floats.size() > 0 &&
                     currentVal.ints.size() > 0) {
                     ADD_FAILURE() << "Uniform "
                                   << currentState.uniforms[i].name.data()
                                   << " had both ints and floats at index " << j;
                 }
                 if (currentVal.floats.size() > 0) {
                     EXPECT_EQ(currentVal.floats, expectedVal.floats)
                             << currentState.uniforms[i].name.data();
                 } else {
                     EXPECT_EQ(currentVal.ints, expectedVal.ints)
                             << currentState.uniforms[i].name.data();
                 }
             }
         }
     }

     void stateChange() override {
         m_program_name = gl->glCreateProgram();
         m_program_state = getProgramState();
         m_state_changer();
     }

     void setStateChanger(std::function<void()> changer) {
         m_state_changer = changer;
     }

 protected:
     // As part of state change, have the GL use the test program.
     void useProgram() {
         gl->glUseProgram(m_program_name);
         EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
         m_current_program = m_program_name;
     }

     // Collects information about the test program object's current state.
     GlProgramState getProgramState() {
         GlProgramState ret = {};
         if (GL_FALSE == gl->glIsProgram(m_program_name)) {
             ADD_FAILURE() << "cannot get program state: was not a program";
             return ret;
         }

         // Info log
         GLsizei logLength;
         gl->glGetProgramiv(m_program_name, GL_INFO_LOG_LENGTH, &logLength);
         ret.infoLog.resize(logLength);
         GLsizei actualLength;
         gl->glGetProgramInfoLog(m_program_name, logLength, &actualLength,
                                 &ret.infoLog[0]);

         // Boolean statuses
         GLint val;
         gl->glGetProgramiv(m_program_name, GL_DELETE_STATUS, &val);
         ret.deleteStatus = val;
         gl->glGetProgramiv(m_program_name, GL_LINK_STATUS, &val);
         ret.linkStatus = val;
         gl->glGetProgramiv(m_program_name, GL_VALIDATE_STATUS, &val);
         ret.validateStatus = val;

         // Attached shaders
         GLint attachedShaders;
         gl->glGetProgramiv(m_program_name, GL_ATTACHED_SHADERS,
                            &attachedShaders);
         ret.shaders.resize(attachedShaders);
         GLsizei shaderCount;
         gl->glGetAttachedShaders(m_program_name, attachedShaders, &shaderCount,
                                  &ret.shaders[0]);

         // Uniforms
         gl->glGetProgramiv(m_program_name, GL_ACTIVE_UNIFORM_MAX_LENGTH,
                            &ret.maxUniformName);
         gl->glGetProgramiv(m_program_name, GL_ACTIVE_UNIFORMS,
                            &ret.activeUniforms);
         for (GLuint i = 0; i < ret.activeUniforms; i++) {
             GlShaderVariable unif = {};
             unif.name.resize(ret.maxUniformName);
             GLsizei unifLen;
             gl->glGetActiveUniform(m_program_name, i, ret.maxUniformName,
                                    &unifLen, &unif.size, &unif.type,
                                    &unif.name[0]);
             unif.location =
                     gl->glGetUniformLocation(m_program_name, unif.name.data());

             if (unif.size > 1) {
                 // uniform array; get values from each index
                 std::string baseName =
                         getUniformBaseName(std::string(unif.name.data()));
                 for (int uniformValueIndex = 0; uniformValueIndex < unif.size;
                      uniformValueIndex++) {
                     std::string indexedName =
                             baseName + '[' + std::to_string(uniformValueIndex) +
                             ']';
                     GLuint indexedLocation = gl->glGetUniformLocation(
                             m_program_name, indexedName.c_str());
                     getUniformValues(indexedLocation, unif.type, unif.values);
                 }
             } else {
                 getUniformValues(unif.location, unif.type, unif.values);
             }
             ret.uniforms.push_back(unif);
         }

         // Attributes
         gl->glGetProgramiv(m_program_name, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH,
                            &ret.maxAttributeName);
         gl->glGetProgramiv(m_program_name, GL_ACTIVE_ATTRIBUTES,
                            &ret.activeAttributes);
         for (GLuint i = 0; i < ret.activeAttributes; i++) {
             GlShaderVariable attr = {};
             attr.name.resize(ret.maxAttributeName);
             GLsizei attrLen;
             gl->glGetActiveAttrib(m_program_name, i, ret.maxAttributeName,
                                   &attrLen, &attr.size, &attr.type,
                                   &attr.name[0]);
             attr.location =
                     gl->glGetAttribLocation(m_program_name, &attr.name[0]);

             // TODO(benzene): get attribute values?

             ret.attributes.push_back(attr);
         }

         return ret;
     }

     // Retrieves the values of the uniform at |location| for the test program.
     // Returns them into |values|.
     void getUniformValues(GLuint location,
                           GLenum type,
                           std::vector<GlValues>& values) {
         GlValues val = {};
         switch (type) {
             case GL_FLOAT:
             case GL_FLOAT_VEC2:
             case GL_FLOAT_VEC3:
             case GL_FLOAT_VEC4:
             case GL_FLOAT_MAT2:
             case GL_FLOAT_MAT3:
             case GL_FLOAT_MAT4:
                 val.floats.resize(glSizeof(type) / sizeof(GLfloat));
                 gl->glGetUniformfv(m_program_name, location, val.floats.data());
                 values.push_back(std::move(val));
                 return;
             case GL_INT:
             case GL_INT_VEC2:
             case GL_INT_VEC3:
             case GL_INT_VEC4:
             case GL_BOOL:
             case GL_BOOL_VEC2:
             case GL_BOOL_VEC3:
             case GL_BOOL_VEC4:
             case GL_SAMPLER_2D:
             case GL_SAMPLER_CUBE:
                 val.ints.resize(glSizeof(type) / sizeof(GLint));
                 gl->glGetUniformiv(m_program_name, location, val.ints.data());
                 values.push_back(std::move(val));
                 break;
             default:
                 ADD_FAILURE() << "unsupported uniform type " << type;
                 return;
         }
     }

     // If string |name| ends with a subscript ([]) operator, return a substring
     // with the subscript removed.
     std::string getUniformBaseName(const std::string& name) {
         std::string baseName;
         int length = name.length();
         if (length < 3)
             return name;
         size_t lastBracket = name.find_last_of('[');
         if (lastBracket != std::string::npos) {
             baseName = name.substr(0, lastBracket);
         } else {
             baseName = name;
         }
         return baseName;
     }

     GLuint m_program_name = 0;
     GlProgramState m_program_state = {};
     GLuint m_current_program = 0;

     std::function<void()> m_state_changer = [] {};
 };

 TEST_F(SnapshotGlProgramTest, CreateProgram) {
     doCheckedSnapshot();
 }

 TEST_F(SnapshotGlProgramTest, AttachDetachShader) {
     setStateChanger([this] {
         GLuint vshader =
                 loadAndCompileShader(gl, GL_VERTEX_SHADER, kTestVertexShader);
         GLuint fshader = loadAndCompileShader(gl, GL_FRAGMENT_SHADER,
                                               kTestFragmentShader);
         gl->glAttachShader(m_program_name, vshader);
         gl->glAttachShader(m_program_name, fshader);
         gl->glDetachShader(m_program_name, vshader);
         m_program_state.shaders.push_back(fshader);
     });
     doCheckedSnapshot();
 }

 TEST_F(SnapshotGlProgramTest, LinkAndValidate) {
     setStateChanger([this] {
         GLuint vshader =
                 loadAndCompileShader(gl, GL_VERTEX_SHADER, kTestVertexShader);
         GLuint fshader = loadAndCompileShader(gl, GL_FRAGMENT_SHADER,
                                               kTestFragmentShader);

         gl->glAttachShader(m_program_name, vshader);
         gl->glAttachShader(m_program_name, fshader);

         gl->glLinkProgram(m_program_name);
         EXPECT_EQ(GL_NO_ERROR, gl->glGetError());

         gl->glValidateProgram(m_program_name);
         EXPECT_EQ(GL_NO_ERROR, gl->glGetError());

         m_program_state = getProgramState();

         EXPECT_EQ(1, m_program_state.activeAttributes);
         EXPECT_EQ(4, m_program_state.activeUniforms);
         EXPECT_EQ(GL_TRUE, m_program_state.linkStatus);
         EXPECT_EQ(GL_TRUE, m_program_state.validateStatus);
     });
     doCheckedSnapshot();
 }

 TEST_F(SnapshotGlProgramTest, UseProgramAndUniforms) {
     setStateChanger([this] {
         GLuint vshader =
                 loadAndCompileShader(gl, GL_VERTEX_SHADER, kTestVertexShader);
         GLuint fshader = loadAndCompileShader(gl, GL_FRAGMENT_SHADER,
                                               kTestFragmentShader);

         gl->glAttachShader(m_program_name, vshader);
         gl->glAttachShader(m_program_name, fshader);

         gl->glLinkProgram(m_program_name);
         EXPECT_EQ(GL_NO_ERROR, gl->glGetError());

         gl->glValidateProgram(m_program_name);
         EXPECT_EQ(GL_NO_ERROR, gl->glGetError());

         useProgram();

         GLuint floatMatUnifLocation =
                 gl->glGetUniformLocation(m_program_name, "testFloatMat");
         const GLfloat testFloatMatrix[16] = {
                 1.0, 0.9, 0.8, 0.7,  0.6,  0.5,  0.4,  0.3,
                 0.2, 0.1, 0.0, -0.1, -0.1, -0.3, -0.4, -0.5,
         };
         gl->glUniformMatrix4fv(floatMatUnifLocation, 1, GL_FALSE,
                                testFloatMatrix);

         GLuint intVecUnifLocation =
                 gl->glGetUniformLocation(m_program_name, "testInts");
         const GLint testIntVec[6] = {
                 10, 11, 12, 20, 21, 22,
         };
         gl->glUniform3iv(intVecUnifLocation, 2, testIntVec);

         m_program_state = getProgramState();
     });
     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 "GLSnapshotTestStateUtils.h"
	#include "GLSnapshotTesting.h"
	#include "apigen-codec-common/glUtils.h"

	#include <gtest/gtest.h>
	#include <map>
	#include <string>

	namespace gfxstream {
	namespace gl {
	namespace {

	static const char kTestVertexShader[] = R"(
	attribute vec4 position;
	uniform mat4 testFloatMat;
	uniform mat4 transform;
	uniform mat4 screenSpace;
	uniform ivec3 testInts[2];
	varying float linear;
	void main(void) {
	gl_Position = testFloatMat * transform * position;
	linear = (screenSpace * position).x;
	gl_PointSize = linear * 0.5 + float(testInts[1].x);
	}
	)";

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

	struct GlShaderVariable {
	GLint size;
	GLenum type;
	std::vector<GLchar> name;
	GLint location;

	std::vector<GlValues> values;
	};

	struct GlProgramState {
	GLboolean deleteStatus;
	GLboolean linkStatus;
	GLboolean validateStatus;

	std::vector<GLchar> infoLog;

	std::vector<GLuint> shaders;

	GLint activeAttributes;
	GLint maxAttributeName;
	std::vector<GlShaderVariable> attributes;

	GLint activeUniforms;
	GLint maxUniformName;
	std::vector<GlShaderVariable> uniforms;
	};

	// SnapshotGlProgramTest - A helper class for testing the snapshot preservation
	// of program objects' state.
	//
	// This holds state information of a particular single program object whose
	// state is mutated in order to set up tests.
	// Provide a lambda via setStateChanger to set up the state which will be
	// checked for preservation.
	// A test can also verify that the snapshot keeps the correct program in use by
	// calling useProgram during state setup.
	//
	class SnapshotGlProgramTest : public SnapshotPreserveTest {
	public:
	void defaultStateCheck() override {
	EXPECT_EQ(GL_FALSE, gl->glIsProgram(m_program_name));
	EXPECT_TRUE(compareGlobalGlInt(gl, GL_CURRENT_PROGRAM, 0));
	}

	void changedStateCheck() override {
	SCOPED_TRACE("test program name = " + std::to_string(m_program_name));
	EXPECT_EQ(GL_TRUE, gl->glIsProgram(m_program_name));
	EXPECT_TRUE(
	compareGlobalGlInt(gl, GL_CURRENT_PROGRAM, m_current_program));

	GlProgramState currentState = getProgramState();

	EXPECT_STREQ(m_program_state.infoLog.data(),
	currentState.infoLog.data());

	EXPECT_EQ(m_program_state.deleteStatus, currentState.deleteStatus);
	EXPECT_EQ(m_program_state.linkStatus, currentState.linkStatus);
	EXPECT_EQ(m_program_state.validateStatus, currentState.validateStatus);

	// TODO(benzene): allow test to pass even if these are out of order
	EXPECT_EQ(m_program_state.shaders, currentState.shaders);

	EXPECT_EQ(m_program_state.activeAttributes,
	currentState.activeAttributes);
	EXPECT_EQ(m_program_state.maxAttributeName,
	currentState.maxAttributeName);
	ASSERT_EQ(m_program_state.attributes.size(),
	currentState.attributes.size());
	for (int i = 0; i < currentState.attributes.size(); i++) {
	SCOPED_TRACE("active attribute i = " + std::to_string(i));
	EXPECT_EQ(m_program_state.attributes[i].size,
	currentState.attributes[i].size);
	EXPECT_EQ(m_program_state.attributes[i].type,
	currentState.attributes[i].type);
	EXPECT_STREQ(m_program_state.attributes[i].name.data(),
	currentState.attributes[i].name.data());
	EXPECT_EQ(m_program_state.attributes[i].location,
	currentState.attributes[i].location);

	// TODO(benzene): check attribute values?
	}

	EXPECT_EQ(m_program_state.activeUniforms, currentState.activeUniforms);
	EXPECT_EQ(m_program_state.maxUniformName, currentState.maxUniformName);
	ASSERT_EQ(m_program_state.uniforms.size(),
	currentState.uniforms.size());
	for (int i = 0; i < currentState.uniforms.size(); i++) {
	SCOPED_TRACE("active uniform i = " + std::to_string(i));
	EXPECT_EQ(m_program_state.uniforms[i].size,
	currentState.uniforms[i].size);
	EXPECT_EQ(m_program_state.uniforms[i].type,
	currentState.uniforms[i].type);
	EXPECT_STREQ(m_program_state.uniforms[i].name.data(),
	currentState.uniforms[i].name.data());
	EXPECT_EQ(m_program_state.uniforms[i].location,
	currentState.uniforms[i].location);

	for (int j = 0; j < currentState.uniforms[i].size; j++) {
	SCOPED_TRACE("value j = " + std::to_string(j));
	GlValues& expectedVal = m_program_state.uniforms[i].values[j];
	GlValues& currentVal = currentState.uniforms[i].values[j];
	if (currentVal.floats.size() > 0 &&
	currentVal.ints.size() > 0) {
	ADD_FAILURE() << "Uniform "
	<< currentState.uniforms[i].name.data()
	<< " had both ints and floats at index " << j;
	}
	if (currentVal.floats.size() > 0) {
	EXPECT_EQ(currentVal.floats, expectedVal.floats)
	<< currentState.uniforms[i].name.data();
	} else {
	EXPECT_EQ(currentVal.ints, expectedVal.ints)
	<< currentState.uniforms[i].name.data();
	}
	}
	}
	}

	void stateChange() override {
	m_program_name = gl->glCreateProgram();
	m_program_state = getProgramState();
	m_state_changer();
	}

	void setStateChanger(std::function<void()> changer) {
	m_state_changer = changer;
	}

	protected:
	// As part of state change, have the GL use the test program.
	void useProgram() {
	gl->glUseProgram(m_program_name);
	EXPECT_EQ(GL_NO_ERROR, gl->glGetError());
	m_current_program = m_program_name;
	}

	// Collects information about the test program object's current state.
	GlProgramState getProgramState() {
	GlProgramState ret = {};
	if (GL_FALSE == gl->glIsProgram(m_program_name)) {
	ADD_FAILURE() << "cannot get program state: was not a program";
	return ret;
	}

	// Info log
	GLsizei logLength;
	gl->glGetProgramiv(m_program_name, GL_INFO_LOG_LENGTH, &logLength);
	ret.infoLog.resize(logLength);
	GLsizei actualLength;
	gl->glGetProgramInfoLog(m_program_name, logLength, &actualLength,
	&ret.infoLog[0]);

	// Boolean statuses
	GLint val;
	gl->glGetProgramiv(m_program_name, GL_DELETE_STATUS, &val);
	ret.deleteStatus = val;
	gl->glGetProgramiv(m_program_name, GL_LINK_STATUS, &val);
	ret.linkStatus = val;
	gl->glGetProgramiv(m_program_name, GL_VALIDATE_STATUS, &val);
	ret.validateStatus = val;

	// Attached shaders
	GLint attachedShaders;
	gl->glGetProgramiv(m_program_name, GL_ATTACHED_SHADERS,
	&attachedShaders);
	ret.shaders.resize(attachedShaders);
	GLsizei shaderCount;
	gl->glGetAttachedShaders(m_program_name, attachedShaders, &shaderCount,
	&ret.shaders[0]);

	// Uniforms
	gl->glGetProgramiv(m_program_name, GL_ACTIVE_UNIFORM_MAX_LENGTH,
	&ret.maxUniformName);
	gl->glGetProgramiv(m_program_name, GL_ACTIVE_UNIFORMS,
	&ret.activeUniforms);
	for (GLuint i = 0; i < ret.activeUniforms; i++) {
	GlShaderVariable unif = {};
	unif.name.resize(ret.maxUniformName);
	GLsizei unifLen;
	gl->glGetActiveUniform(m_program_name, i, ret.maxUniformName,
	&unifLen, &unif.size, &unif.type,
	&unif.name[0]);
	unif.location =
	gl->glGetUniformLocation(m_program_name, unif.name.data());

	if (unif.size > 1) {
	// uniform array; get values from each index
	std::string baseName =
	getUniformBaseName(std::string(unif.name.data()));
	for (int uniformValueIndex = 0; uniformValueIndex < unif.size;
	uniformValueIndex++) {
	std::string indexedName =
	baseName + '[' + std::to_string(uniformValueIndex) +
	']';
	GLuint indexedLocation = gl->glGetUniformLocation(
	m_program_name, indexedName.c_str());
	getUniformValues(indexedLocation, unif.type, unif.values);
	}
	} else {
	getUniformValues(unif.location, unif.type, unif.values);
	}
	ret.uniforms.push_back(unif);
	}

	// Attributes
	gl->glGetProgramiv(m_program_name, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH,
	&ret.maxAttributeName);
	gl->glGetProgramiv(m_program_name, GL_ACTIVE_ATTRIBUTES,
	&ret.activeAttributes);
	for (GLuint i = 0; i < ret.activeAttributes; i++) {
	GlShaderVariable attr = {};
	attr.name.resize(ret.maxAttributeName);
	GLsizei attrLen;
	gl->glGetActiveAttrib(m_program_name, i, ret.maxAttributeName,
	&attrLen, &attr.size, &attr.type,
	&attr.name[0]);
	attr.location =
	gl->glGetAttribLocation(m_program_name, &attr.name[0]);

	// TODO(benzene): get attribute values?

	ret.attributes.push_back(attr);
	}

	return ret;
	}

	// Retrieves the values of the uniform at \|location\| for the test program.
	// Returns them into \|values\|.
	void getUniformValues(GLuint location,
	GLenum type,
	std::vector<GlValues>& values) {
	GlValues val = {};
	switch (type) {
	case GL_FLOAT:
	case GL_FLOAT_VEC2:
	case GL_FLOAT_VEC3:
	case GL_FLOAT_VEC4:
	case GL_FLOAT_MAT2:
	case GL_FLOAT_MAT3:
	case GL_FLOAT_MAT4:
	val.floats.resize(glSizeof(type) / sizeof(GLfloat));
	gl->glGetUniformfv(m_program_name, location, val.floats.data());
	values.push_back(std::move(val));
	return;
	case GL_INT:
	case GL_INT_VEC2:
	case GL_INT_VEC3:
	case GL_INT_VEC4:
	case GL_BOOL:
	case GL_BOOL_VEC2:
	case GL_BOOL_VEC3:
	case GL_BOOL_VEC4:
	case GL_SAMPLER_2D:
	case GL_SAMPLER_CUBE:
	val.ints.resize(glSizeof(type) / sizeof(GLint));
	gl->glGetUniformiv(m_program_name, location, val.ints.data());
	values.push_back(std::move(val));
	break;
	default:
	ADD_FAILURE() << "unsupported uniform type " << type;
	return;
	}
	}

	// If string \|name\| ends with a subscript ([]) operator, return a substring
	// with the subscript removed.
	std::string getUniformBaseName(const std::string& name) {
	std::string baseName;
	int length = name.length();
	if (length < 3)
	return name;
	size_t lastBracket = name.find_last_of('[');
	if (lastBracket != std::string::npos) {
	baseName = name.substr(0, lastBracket);
	} else {
	baseName = name;
	}
	return baseName;
	}

	GLuint m_program_name = 0;
	GlProgramState m_program_state = {};
	GLuint m_current_program = 0;

	std::function<void()> m_state_changer = [] {};
	};

	TEST_F(SnapshotGlProgramTest, CreateProgram) {
	doCheckedSnapshot();
	}

	TEST_F(SnapshotGlProgramTest, AttachDetachShader) {
	setStateChanger([this] {
	GLuint vshader =
	loadAndCompileShader(gl, GL_VERTEX_SHADER, kTestVertexShader);
	GLuint fshader = loadAndCompileShader(gl, GL_FRAGMENT_SHADER,
	kTestFragmentShader);
	gl->glAttachShader(m_program_name, vshader);
	gl->glAttachShader(m_program_name, fshader);
	gl->glDetachShader(m_program_name, vshader);
	m_program_state.shaders.push_back(fshader);
	});
	doCheckedSnapshot();
	}

	TEST_F(SnapshotGlProgramTest, LinkAndValidate) {
	setStateChanger([this] {
	GLuint vshader =
	loadAndCompileShader(gl, GL_VERTEX_SHADER, kTestVertexShader);
	GLuint fshader = loadAndCompileShader(gl, GL_FRAGMENT_SHADER,
	kTestFragmentShader);

	gl->glAttachShader(m_program_name, vshader);
	gl->glAttachShader(m_program_name, fshader);

	gl->glLinkProgram(m_program_name);
	EXPECT_EQ(GL_NO_ERROR, gl->glGetError());

	gl->glValidateProgram(m_program_name);
	EXPECT_EQ(GL_NO_ERROR, gl->glGetError());

	m_program_state = getProgramState();

	EXPECT_EQ(1, m_program_state.activeAttributes);
	EXPECT_EQ(4, m_program_state.activeUniforms);
	EXPECT_EQ(GL_TRUE, m_program_state.linkStatus);
	EXPECT_EQ(GL_TRUE, m_program_state.validateStatus);
	});
	doCheckedSnapshot();
	}

	TEST_F(SnapshotGlProgramTest, UseProgramAndUniforms) {
	setStateChanger([this] {
	GLuint vshader =
	loadAndCompileShader(gl, GL_VERTEX_SHADER, kTestVertexShader);
	GLuint fshader = loadAndCompileShader(gl, GL_FRAGMENT_SHADER,
	kTestFragmentShader);

	gl->glAttachShader(m_program_name, vshader);
	gl->glAttachShader(m_program_name, fshader);

	gl->glLinkProgram(m_program_name);
	EXPECT_EQ(GL_NO_ERROR, gl->glGetError());

	gl->glValidateProgram(m_program_name);
	EXPECT_EQ(GL_NO_ERROR, gl->glGetError());

	useProgram();

	GLuint floatMatUnifLocation =
	gl->glGetUniformLocation(m_program_name, "testFloatMat");
	const GLfloat testFloatMatrix[16] = {
	1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3,
	0.2, 0.1, 0.0, -0.1, -0.1, -0.3, -0.4, -0.5,
	};
	gl->glUniformMatrix4fv(floatMatUnifLocation, 1, GL_FALSE,
	testFloatMatrix);

	GLuint intVecUnifLocation =
	gl->glGetUniformLocation(m_program_name, "testInts");
	const GLint testIntVec[6] = {
	10, 11, 12, 20, 21, 22,
	};
	gl->glUniform3iv(intVecUnifLocation, 2, testIntVec);

	m_program_state = getProgramState();
	});
	doCheckedSnapshot();
	}

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