void piglit_init(int argc, char **argv)
{
	bool pass = true;

	GLuint fb;
	GLuint tex;

	piglit_require_extension("GL_ARB_framebuffer_object");

	glGenTextures(1, &tex);
	glGenFramebuffers(1, &fb);
	glBindTexture(GL_TEXTURE_2D, tex);
	glBindFramebuffer(GL_FRAMEBUFFER, fb);

	glTexImage2D(GL_TEXTURE_2D,
		     0, /*level*/
		     GL_DEPTH_STENCIL,
		     200, 200, /*width, height*/
		     0, /*border*/
		     GL_DEPTH_STENCIL,
		     GL_UNSIGNED_INT_24_8,
		     NULL);
	glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER,
			       GL_DEPTH_STENCIL_ATTACHMENT,
			       GL_TEXTURE_2D,
			       tex,
			       0); /*level*/

	pass = piglit_check_gl_error(0) && pass;

	pass = check_attachment(GL_DEPTH_ATTACHMENT, tex) && pass;
	pass = check_attachment(GL_STENCIL_ATTACHMENT, tex) && pass;
	pass = check_attachment(GL_DEPTH_STENCIL_ATTACHMENT, tex) && pass;

	pass = piglit_check_gl_error(0) && pass;

	piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}

/**
 * Conformance test #1 in the EGL_EXT_client_extensions spec:
 *
 *     1. Before any call to eglGetDisplay, call `eglQueryString(EGL_NO_DISPLAY,
 *        EGL_EXTENSIONS)`. Verify that either
 *
 *          a. The call returns NULL and generates EGL_BAD_DISPLAY.
 *          b. The call returns an extension string that contains, at a minimum,
 *             this extension and generates no error.
 */
static void
test_1(void)
{
	enum piglit_result result = PIGLIT_PASS;
	const char *client_extensions;

	printf("Making process's first EGL call, "
	       "eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS) ...\n");
	client_extensions = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);

	if (client_extensions == NULL) {
		printf("Returned NULL\n");
		if (piglit_check_egl_error(EGL_BAD_DISPLAY)) {
			printf("And correctly emitted EGL_BAD_DISPLAY\n");
		} else {
			printf("But did not emit EGL_BAD_DISPLAY\n");
			result = PIGLIT_FAIL;
		}
	} else {
		printf("Returned a non-null extension string\n");

		if (!piglit_check_egl_error(EGL_SUCCESS)) {
			result = PIGLIT_FAIL;
		}

		if (!piglit_is_extension_in_string(client_extensions,
						   "EGL_EXT_client_extensions")) {
			printf("But it does not contain "
			       "EGL_EXT_client_extensions\n");
			result = PIGLIT_FAIL;
		} else {
			printf("And contains EGL_EXT_client_extensions "
			       "as expected\n");
		}
	}

	piglit_report_result(result);
}

static GLuint
make_vao(void)
{
	static const float pos_tc[12][2] = {
		{ -1.0, -1.0 },
		{  0.0, -1.0 },
		{  0.0,  1.0 },
		{  0.0,  1.0 },
		{ -1.0,  1.0 },
		{ -1.0, -1.0 },
		{ -1.0, -1.0 },
		{  1.0, -1.0 },
		{  1.0,  1.0 },
		{  1.0,  1.0 },
		{ -1.0,  1.0 },
		{ -1.0, -1.0 }
	};
	const int stride = sizeof(pos_tc[0]);
	GLuint vbo, vao;

	glGenVertexArrays(1, &vao);
	glBindVertexArray(vao);

	glGenBuffers(1, &vbo);
	glBindBuffer(GL_ARRAY_BUFFER, vbo);
	glBufferData(GL_ARRAY_BUFFER, sizeof(pos_tc), pos_tc, GL_STATIC_DRAW);
	piglit_check_gl_error(GL_NO_ERROR);

	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, stride, (void *) 0);

	glEnableVertexAttribArray(0);

	if (!piglit_check_gl_error(GL_NO_ERROR)) {
		piglit_report_result(PIGLIT_FAIL);
	}

	return vbo;
}

PIGLIT_GL_TEST_CONFIG_END

void
piglit_init(int argc, char **argv)
{
	static const GLubyte ubytes[4] = { 255, 0, 0, 127 };
	bool pass = true;
	GLint size;

	piglit_require_gl_version(20);
	piglit_require_extension("GL_ARB_vertex_array_bgra");

	glColorPointer(GL_BGRA, GL_UNSIGNED_BYTE, sizeof ubytes, ubytes);
	size = 0;
	glGetIntegerv(GL_COLOR_ARRAY_SIZE, &size);
	if (size != GL_BGRA) {
		fprintf(stderr, "glGetIntegerv(GL_COLOR_ARRAY_SIZE) returned %i, GL_BGRA expected\n", size);
		pass = false;
	}

	glSecondaryColorPointer(GL_BGRA, GL_UNSIGNED_BYTE, sizeof ubytes, ubytes);
	size = 0;
	glGetIntegerv(GL_SECONDARY_COLOR_ARRAY_SIZE, &size);
	if (size != GL_BGRA) {
		fprintf(stderr, "glGetIntegerv(GL_SECONDARY_COLOR_ARRAY_SIZE) returned %i, GL_BGRA expected\n", size);
		pass = false;
	}

	glVertexAttribPointer(1, GL_BGRA, GL_UNSIGNED_BYTE, GL_TRUE, sizeof ubytes, ubytes);
	size = 0;
	glGetVertexAttribiv(1, GL_VERTEX_ATTRIB_ARRAY_SIZE, &size);
	if (size != GL_BGRA) {
		fprintf(stderr, "glGetVertexAttribiv(GL_VERTEX_ATTRIB_ARRAY_SIZE) returned %i, GL_BGRA expected\n", size);
		pass = false;
	}

	piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}

static void
init(void)
{
   if (piglit_is_extension_supported("GL_ARB_vertex_shader")) {
      glGetIntegerv(GL_MAX_TEXTURE_COORDS, &MaxTextureCoordUnits);
      glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &MaxTextureImageUnits);
      glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &MaxTextureVertexUnits);
      glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &MaxTextureCombinedUnits);
   }
   else if (piglit_is_extension_supported("GL_ARB_fragment_shader") ||
            piglit_is_extension_supported("GL_ARB_fragment_program")) {
      glGetIntegerv(GL_MAX_TEXTURE_COORDS, &MaxTextureCoordUnits);
      glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &MaxTextureImageUnits);
      MaxTextureVertexUnits = 0;
      MaxTextureCombinedUnits = MaxTextureImageUnits;
   }
   else {
      glGetIntegerv(GL_MAX_TEXTURE_UNITS, &MaxTextureCoordUnits);
      MaxTextureImageUnits =
      MaxTextureCombinedUnits = MaxTextureCoordUnits;
      MaxTextureVertexUnits = 0;
   }

   report_info();

   if (MaxTextureCombinedUnits > MAX_UNITS) {
      /* Need to increase the MAX_UNITS limit */
      piglit_report_result(PIGLIT_WARN);
   }

   generate_random_numbers();

   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
}

const struct uniform_type *
get_transposed_type(const struct uniform_type *type)
{
	const char *name = NULL;
	int i;

	switch (type->gl_type) {
	case GL_FLOAT_MAT2x3:
		name = "mat3x2";
		break;
	case GL_FLOAT_MAT2x4:
		name = "mat4x2";
		break;
	case GL_FLOAT_MAT3x2:
		name = "mat2x3";
		break;
	case GL_FLOAT_MAT3x4:
		name = "mat4x3";
		break;
	case GL_FLOAT_MAT4x2:
		name = "mat2x4";
		break;
	case GL_FLOAT_MAT4x3:
		name = "mat3x4";
		break;
	default:
		return type;
	}

	for (i = 0; uniform_types[i].type; i++) {
		if (strcmp(uniform_types[i].type, name) == 0)
			return &uniform_types[i];
	}

	printf("failed lookup of %s\n", name);
	piglit_report_result(PIGLIT_FAIL);
	return type;
}

void
piglit_init(int argc, char **argv)
{
	GLint vs, fs;

	if (piglit_get_gl_version() < 20) {
		printf("Requires OpenGL 2.0\n");
		piglit_report_result(PIGLIT_SKIP);
	}

	piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);

	vs = piglit_compile_shader(GL_VERTEX_SHADER,
				   "shaders/glsl-preprocessor-comments.vert");
	fs = piglit_compile_shader(GL_FRAGMENT_SHADER,
				   "shaders/glsl-preprocessor-comments.frag");

	prog = piglit_link_simple_program(vs, fs);

	glUseProgram(prog);

	args1_location = glGetUniformLocation(prog, "args1");
}

void
piglit_init(int argc, char **argv)
{
	const GLenum expect = (piglit_is_extension_supported("GL_ARB_geometry_shader4")
			       || piglit_is_extension_supported("GL_EXT_geometry_shader4")
			       || piglit_is_extension_supported("GL_NV_geometry_shader4"))
		? 0 : GL_INVALID_ENUM;
	GLboolean pass;

	piglit_require_gl_version(20);

	piglit_require_extension("GL_EXT_separate_shader_objects");

	pass = try_UseShaderProgram(GL_PROXY_TEXTURE_3D, GL_INVALID_ENUM);
	pass = try_UseShaderProgram(GL_VERTEX_SHADER, 0)
		&& pass;
	pass = try_UseShaderProgram(GL_FRAGMENT_SHADER, 0)
		&& pass;
	pass = try_UseShaderProgram(GL_GEOMETRY_SHADER_ARB, expect)
		&& pass;

	piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}

void
piglit_init(int argc, char **argv)
{
	bool pass = true;
	GLuint bo;

	piglit_require_extension("GL_ARB_vertex_type_10f_11f_11f_rev");

	/* a small temporary bo for tests to work with. content doesn't matter,
	 * we won't be rendering from it. */
	glGenBuffers(1, &bo);
	glBindBuffer(GL_ARRAY_BUFFER, bo);
	glBufferData(GL_ARRAY_BUFFER, 64, (GLvoid const *)0, GL_STATIC_DRAW);

	if (piglit_is_extension_supported("GL_ARB_vertex_attrib_binding")) {
		pass = test_vertex_attrib_format() && pass;
	}

	pass = test_legacy_vertex_attribs() && pass;
	pass = test_vertex_attribs() && pass;

	piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}

XVisualInfo *
get_single_buffer_visual(Display *dpy)
{
	XVisualInfo *visinfo;
	int attrib[] = {
		GLX_RGBA,
		GLX_RED_SIZE, 1,
		GLX_GREEN_SIZE, 1,
		GLX_BLUE_SIZE, 1,
		GLX_ALPHA_SIZE, 1,
		None
	};
	int screen = DefaultScreen(dpy);

	visinfo = glXChooseVisual(dpy, screen, attrib);
	if (visinfo == NULL) {
		fprintf(stderr,
			"Couldn't get a single buffered, RGBA visual\n");
		piglit_report_result(PIGLIT_SKIP);
	}

	return visinfo;
}

XVisualInfo *
piglit_get_glx_visual(Display *dpy)
{
	XVisualInfo *visinfo;
	int attrib[] = {
		GLX_RGBA,
		GLX_RED_SIZE, 1,
		GLX_GREEN_SIZE, 1,
		GLX_BLUE_SIZE, 1,
		GLX_DOUBLEBUFFER,
		None
	};
	int screen = DefaultScreen(dpy);

	visinfo = glXChooseVisual(dpy, screen, attrib);
	if (visinfo == NULL) {
		fprintf(stderr,
			"Couldn't get an RGBA, double-buffered visual\n");
		piglit_report_result(PIGLIT_FAIL);
	}

	return visinfo;
}

void
piglit_init(int argc, char **argv)
{
	bool pass = true;

	/* The first 5 indices should be ignored */
	const unsigned indices[6] = {0, 0, 0, 0, 0, 1};

	piglit_require_extension("GL_ARB_shader_subroutine");
	piglit_require_extension("GL_ARB_explicit_uniform_location");
	piglit_require_extension("GL_ARB_explicit_attrib_location");

	prog = piglit_build_simple_program(NULL, frag_shader_text);

	glUseProgram(prog);
	glUniformSubroutinesuiv(GL_FRAGMENT_SHADER, 6, indices);

	if (!piglit_check_gl_error(0)) {
		pass = false;
	}

	piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}

void
piglit_init(int argc, char **argv)
{
	GLint num;
	int i;

	for (i = 1; i < argc; i++) {
		if (strcmp(argv[i], "clear") == 0) {
			puts("Testing glClear.");
			test_clear = GL_TRUE;
		}
	}

	piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);

	piglit_require_extension("GL_EXT_framebuffer_object");
	piglit_require_extension("GL_ARB_draw_buffers");
	piglit_require_extension("GL_EXT_draw_buffers2");

	glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &num);
	if (num < 2)
		piglit_report_result(PIGLIT_SKIP);
}

static GLuint link_program(GLuint vs, GLuint fs)
{
	GLuint program;
	GLint status;

	program = glCreateProgramObjectARB();
	if (vs)
		glAttachObjectARB(program, vs);
	if (fs)
		glAttachObjectARB(program, fs);

	glLinkProgramARB(program);
	glGetObjectParameterivARB(program, GL_OBJECT_LINK_STATUS_ARB, &status);
	if (!status) {
		GLchar log[1000];
		GLsizei len;
		glGetInfoLogARB(program, 1000, &len, log);
		fprintf(stderr, "Error: problem linking program: %s\n", log);
		piglit_report_result(PIGLIT_FAIL);
	}

	return program;
}

void
piglit_init(int argc, char **argv)
{
	GLuint buffer;
	double ssbo_values[SSBO_SIZE] = {0};

	piglit_require_extension("GL_ARB_shader_storage_buffer_object");
	piglit_require_GLSL_version(400);

	prog = piglit_build_simple_program(vs_pass_thru_text, fs_source);

	glUseProgram(prog);

	glClearColor(0, 0, 0, 1);

	glGenBuffers(1, &buffer);
	glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, buffer);
	glBufferData(GL_SHADER_STORAGE_BUFFER, SSBO_SIZE*sizeof(GLdouble),
		     &ssbo_values[0], GL_DYNAMIC_DRAW);

	if (!piglit_check_gl_error(GL_NO_ERROR))
		piglit_report_result(PIGLIT_FAIL);
}

int
main(int argc, char **argv)
{
	int ret;
	pthread_t thread1, thread2;

	pthread_mutex_init(&mutex, NULL);

	/* Now, spawn some threads that compile simple shaders.
	 */
	pthread_create(&thread1, NULL, thread_func, NULL);
	pthread_create(&thread2, NULL, thread_func, NULL);

	ret = pthread_join(thread1, NULL);
	assert(ret == 0);
	ret = pthread_join(thread2, NULL);
	assert(ret == 0);

	pthread_mutex_destroy(&mutex);

	piglit_report_result(PIGLIT_PASS);
	return 0;
}

void
piglit_init(int argc, char **argv)
{
	GLint vs, fs, prog;
	const char *fs_source =
		"void main()\n"
		"{\n"
		"	gl_FragColor = gl_Fog.color;\n"
		"}\n";

	if (piglit_get_gl_version() < 20) {
		printf("Requires OpenGL 2.0\n");
		piglit_report_result(PIGLIT_SKIP);
	}

	vs = piglit_compile_shader(GL_VERTEX_SHADER,
				   "shaders/glsl-mvp.vert");
	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_source);

	prog = piglit_link_simple_program(vs, fs);

	glUseProgram(prog);
}

void
piglit_init(int argc, char **argv)
{
	piglit_require_extension("GL_ARB_vertex_program");

	printf("%-50s %8s %8s\n", "token", "minimum", "value");

	MIN_PROGRAM_TEST(GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, 96);
	MIN_PROGRAM_TEST(GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, 96);
	MIN_INTEGER_TEST(GL_MAX_PROGRAM_MATRICES_ARB, 8);
	MIN_INTEGER_TEST(GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB, 1);
	MIN_PROGRAM_TEST(GL_MAX_PROGRAM_INSTRUCTIONS_ARB, 128);
	MIN_PROGRAM_TEST(GL_MAX_PROGRAM_TEMPORARIES_ARB, 12);
	MIN_PROGRAM_TEST(GL_MAX_PROGRAM_PARAMETERS_ARB, 96);
	MIN_PROGRAM_TEST(GL_MAX_PROGRAM_ATTRIBS_ARB, 16);
	MIN_PROGRAM_TEST(GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB, 1);
	/* No specified minimum, but test that we can query them anyway. */
	MIN_PROGRAM_TEST(GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, 0);
	MIN_PROGRAM_TEST(GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, 0);
	MIN_PROGRAM_TEST(GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, 0);
	MIN_PROGRAM_TEST(GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB, 0);
	MIN_PROGRAM_TEST(GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB, 0);

	/* See the GL_ARB_fragment_program specification for this
	 * consistency requirement.
	 */
	if (piglit_is_extension_supported("GL_ARB_fragment_program")) {
		MIN_PROGRAM_TEST(GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB, 0);
		MIN_PROGRAM_TEST(GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB, 0);
		MIN_PROGRAM_TEST(GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB, 0);
		MIN_PROGRAM_TEST(GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, 0);
		MIN_PROGRAM_TEST(GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB, 0);
		MIN_PROGRAM_TEST(GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB, 0);
	}

	piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}

static bool
test_glBlitFramebuffer(const GLenum drawbufs[4])
{
	GLuint rb, readfb;
	GLenum status;

	/* Create a new renderbuffer and attach it to a new FBO. */
	glGenRenderbuffers(1, &rb);
	glBindRenderbuffer(GL_RENDERBUFFER, rb);
	glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, FB_SIZE, FB_SIZE);

	glGenFramebuffers(1, &readfb);
	glBindFramebuffer(GL_FRAMEBUFFER, readfb);
	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
				  GL_RENDERBUFFER, rb);

	status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
	if (status != GL_FRAMEBUFFER_COMPLETE) {
		fprintf(stderr,
			"Framebuffer with color"
			"attachment was not complete: 0x%04x\n",
			status);
		piglit_report_result(PIGLIT_FAIL);
	}

	/* Clear the renderbuffer to red. */
	glClearColor(1, 0, 0, 1);
	glClear(GL_COLOR_BUFFER_BIT);

	/* Blit the renderbuffer to our FBO with MRT. */
	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fb);
	glBlitFramebuffer(0, 0, FB_SIZE, FB_SIZE, 0, 0, FB_SIZE, FB_SIZE,
			  GL_COLOR_BUFFER_BIT, GL_NEAREST);

	glBindFramebuffer(GL_FRAMEBUFFER, fb);
	return probe_buffers(drawbufs, colors_all_red);
}

int main(int argc, char **argv)
{
	static const int invalid_render_types[] = {
		GLX_COLOR_INDEX_BIT,
		GLX_RGBA_BIT,
		GLX_RGBA_FLOAT_BIT_ARB,
		GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT,
		0,
		-1,
		~GLX_RGBA_TYPE,
		~GLX_COLOR_INDEX_TYPE
	};
	bool pass = true;
	unsigned i;

	GLX_ARB_create_context_setup();

	for (i = 0; i < ARRAY_SIZE(invalid_render_types); i++) {
		pass = try_render_type(invalid_render_types[i])
			&& pass;
	}

	if (!piglit_is_glx_extension_supported(dpy, "GLX_ARB_fbconfig_float")) {
		pass = try_render_type(GLX_RGBA_FLOAT_TYPE_ARB)
			&& pass;
	}

	if (!piglit_is_glx_extension_supported(dpy, "GLX_EXT_fbconfig_packed_float")) {
		pass = try_render_type(GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT)
			&& pass;
	}

	GLX_ARB_create_context_teardown();

	piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
	return 0;
}