Improve/split the ARB_color_buffer_float tests

10 files changed, 209 insertions, 125 deletions

diff --git a/tests/all.tests b/tests/all.tests
index 30bfb2818..68353dfcc 100644
--- a/tests/all.tests
+++ b/tests/all.tests
@@ -702,16 +702,47 @@ tdfx_texture_compression_fxt1 = Group()
 spec['3DFX_texture_compression_FXT1'] = tdfx_texture_compression_fxt1
 add_fbo_generatemipmap_extension(tdfx_texture_compression_fxt1, 'GL_3DFX_texture_compression_FXT1', 'fbo-generatemipmap-formats')
 
+def add_color_buffer_float_test(name, format, p1, p2):
+	arb_color_buffer_float[name + '-' + format + ('-' + p1 if len(p1) else '') + ('-' + p2 if len(p2) else '')] = PlainExecTest(['arb_color_buffer_float-' + name, format, p1, p2])
+
 arb_color_buffer_float = Group()
 spec['ARB_color_buffer_float'] = arb_color_buffer_float
-add_plain_test(arb_color_buffer_float, 'arb_color_buffer_float-getteximage')
-add_plain_test(arb_color_buffer_float, 'arb_color_buffer_float-queries')
-add_plain_test(arb_color_buffer_float, 'arb_color_buffer_float-readpixels')
-add_plain_test(arb_color_buffer_float, 'arb_color_buffer_float-probepixel')
-add_plain_test(arb_color_buffer_float, 'arb_color_buffer_float-drawpixels')
-add_plain_test(arb_color_buffer_float, 'arb_color_buffer_float-clear')
-add_plain_test(arb_color_buffer_float, 'arb_color_buffer_float-render')
-add_plain_test(arb_color_buffer_float, 'arb_color_buffer_float-mrt')
+add_color_buffer_float_test('getteximage', 'GL_RGBA8', '', '')
+add_color_buffer_float_test('queries', 'GL_RGBA8', '', '')
+add_color_buffer_float_test('readpixels', 'GL_RGBA8', '', '')
+add_color_buffer_float_test('probepixel', 'GL_RGBA8', '', '')
+add_color_buffer_float_test('drawpixels', 'GL_RGBA8', '', '')
+add_color_buffer_float_test('clear', 'GL_RGBA8', '', '')
+add_color_buffer_float_test('mrt', 'GL_RGBA8', '', '')
+add_color_buffer_float_test('render', 'GL_RGBA8', '', '')
+add_color_buffer_float_test('render', 'GL_RGBA8', 'fog', '')
+add_color_buffer_float_test('render', 'GL_RGBA8', 'sanity', '')
+add_color_buffer_float_test('render', 'GL_RGBA8', 'sanity', 'fog')
+
+add_color_buffer_float_test('getteximage', 'GL_RGBA16F', '', '')
+add_color_buffer_float_test('queries', 'GL_RGBA16F', '', '')
+add_color_buffer_float_test('readpixels', 'GL_RGBA16F', '', '')
+add_color_buffer_float_test('probepixel', 'GL_RGBA16F', '', '')
+add_color_buffer_float_test('drawpixels', 'GL_RGBA16F', '', '')
+add_color_buffer_float_test('clear', 'GL_RGBA16F', '', '')
+add_color_buffer_float_test('mrt', 'GL_RGBA16F', '', '')
+add_color_buffer_float_test('render', 'GL_RGBA16F', '', '')
+add_color_buffer_float_test('render', 'GL_RGBA16F', 'fog', '')
+add_color_buffer_float_test('render', 'GL_RGBA16F', 'sanity', '')
+add_color_buffer_float_test('render', 'GL_RGBA16F', 'sanity', 'fog')
+
+add_color_buffer_float_test('getteximage', 'GL_RGBA32F', '', '')
+add_color_buffer_float_test('queries', 'GL_RGBA32F', '', '')
+add_color_buffer_float_test('readpixels', 'GL_RGBA32F', '', '')
+add_color_buffer_float_test('probepixel', 'GL_RGBA32F', '', '')
+add_color_buffer_float_test('drawpixels', 'GL_RGBA32F', '', '')
+add_color_buffer_float_test('clear', 'GL_RGBA32F', '', '')
+add_color_buffer_float_test('mrt', 'GL_RGBA32F', '', '')
+add_color_buffer_float_test('render', 'GL_RGBA32F', '', '')
+add_color_buffer_float_test('render', 'GL_RGBA32F', 'fog', '')
+add_color_buffer_float_test('render', 'GL_RGBA32F', 'sanity', '')
+add_color_buffer_float_test('render', 'GL_RGBA32F', 'sanity', 'fog')
+
 
 arb_depth_texture = Group()
 spec['ARB_depth_texture'] = arb_depth_texture
diff --git a/tests/spec/arb_color_buffer_float/clear.c b/tests/spec/arb_color_buffer_float/clear.c
index 62d15dbe9..3ebbea7ed 100644
--- a/tests/spec/arb_color_buffer_float/clear.c
+++ b/tests/spec/arb_color_buffer_float/clear.c
@@ -44,16 +44,21 @@
 GLboolean test()
 {
 	GLboolean pass = GL_TRUE;
+	unsigned vert_clamp, frag_clamp;
 
-	for(vert_clamp = 0; vert_clamp < 3; ++vert_clamp)
+	for (vert_clamp = 0; vert_clamp < (test_defaults ? 1 : 3); ++vert_clamp)
 	{
-		for(frag_clamp = 0; frag_clamp < 3; ++frag_clamp)
+		for (frag_clamp = test_defaults ? 1 : 0; frag_clamp < (test_defaults ? 2 : 3); ++frag_clamp)
 		{
 			GLboolean cpass;
 			GLboolean opass;
+			float* expected;
+
 			printf("glClear of fbo for float texture with vertex clamp %s and fragment clamp %s (expecting no clamping)\n", clamp_strings[vert_clamp], clamp_strings[frag_clamp]);
-			glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, clamp_enums[vert_clamp]);
-			glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, clamp_enums[frag_clamp]);
+			if (!test_defaults) {
+				glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, clamp_enums[vert_clamp]);
+				glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, clamp_enums[frag_clamp]);
+			}
 
 			glClearColor(pixels[0], pixels[1], pixels[2], pixels[3]);
 			glClear(GL_COLOR_BUFFER_BIT);
diff --git a/tests/spec/arb_color_buffer_float/common.h b/tests/spec/arb_color_buffer_float/common.h
index e3873ac9c..a24c9a566 100644
--- a/tests/spec/arb_color_buffer_float/common.h
+++ b/tests/spec/arb_color_buffer_float/common.h
@@ -37,66 +37,64 @@ int piglit_height = 128;
 int piglit_window_mode = GLUT_RGB | GLUT_ALPHA | GLUT_DOUBLE;
 
 /* use small values for pixels[0..3], so that the 0.01 tolerance is met for fp16 */
-float pixels[] = {
+static float pixels[] = {
 	7, -2.75, -0.25, 0.75,
 	0.0, 1.0, 2.0, -1.0,
 	0.5, 9.0 / 8.0, -156, 390,
 	234, -86, -21.5, 46.5,
 };
 
-float clamped_pixels[16];
-float pixels_mul_2[16];
-float clamped_pixels_mul_2[16];
-float pixels_plus_half[16];
-float clamped_pixels_plus_half[16];
-float clamped_pixels_plus_half_clamped[16];
+static float clamped_pixels[16];
+static float pixels_mul_2[16];
+static float clamped_pixels_mul_2[16];
+static float pixels_plus_half[16];
+static float clamped_pixels_plus_half[16];
+static float clamped_pixels_plus_half_clamped[16];
 
-const char* clamp_strings[] = {"TRUE", "FIXED_ONLY", "FALSE"};
-GLenum clamp_enums[] = {GL_TRUE, GL_FIXED_ONLY_ARB, GL_FALSE};
+static const char* clamp_strings[] = {"TRUE ", "FIXED", "FALSE"};
+static GLenum clamp_enums[] = {GL_TRUE, GL_FIXED_ONLY_ARB, GL_FALSE};
 
 const char* mrt_mode_strings[] = {"single target", "homogeneous framebuffer", "dishomogeneous framebuffer"};
 
 static float clamp(float f)
 {
-	if(f >= 0.0f && f <= 1.0f)
+	if (f >= 0.0f && f <= 1.0f)
 		return f;
-	else if(f > 0.0f)
+	else if (f > 0.0f)
 		return 1.0f;
 	else
 		return 0.0f;
 }
 
-unsigned ati_driver;
-unsigned nvidia_driver;
+static unsigned ati_driver;
+static unsigned nvidia_driver;
 
-char test_name[4096];
-float observed[16];
-unsigned vert_clamp, frag_clamp, read_clamp;
-float* expected;
-float* expected1;
-GLuint tex, tex1, fb;
-GLenum status;
-unsigned error;
+static GLuint tex, tex1, fb;
+static GLenum status;
+static unsigned error;
 
-int fbo_width = 2;
-int fbo_height = 2;
+static int fbo_width = 2;
+static int fbo_height = 2;
 
-#define TEST_NO_RT 0
-#define TEST_SRT 1
-#define TEST_MRT 2
-#define TEST_SRT_MRT 3
+enum test_mode_type {
+	TEST_NO_RT,
+	TEST_SRT,
+	TEST_MRT,
+	TEST_SRT_MRT
+};
 
-int test_mode = TEST_SRT;
+static enum test_mode_type test_mode;
 
-GLenum format;
-const char* format_name;
-GLboolean fixed;
-GLboolean fixed0, fixed1;
-unsigned mrt_mode;
+static GLboolean test_defaults, test_fog;
+static GLenum format;
+static const char* format_name;
+static GLboolean fixed;
+static GLboolean fixed0, fixed1;
+static unsigned mrt_mode;
 
-GLboolean test();
+static GLboolean test();
 
-GLboolean run_test()
+static GLboolean run_test()
 {
 	GLboolean pass = GL_TRUE;
 	fixed = fixed0 = format == GL_RGBA8;
@@ -110,13 +108,13 @@ GLboolean run_test()
 		     2, 2, 0,
 		     GL_RGBA, GL_FLOAT, pixels);
 	error = glGetError();
-	if(error)
+	if (error)
 	{
 		printf("GL error after glTexImage2D 0x%04X\n", error);
 		return GL_FALSE;
 	}
 
-	if(test_mode)
+	if (test_mode)
 	{
 		glBindTexture(GL_TEXTURE_2D, 0);
 
@@ -130,7 +128,7 @@ GLboolean run_test()
 					  tex,
 					  0);
 		error = glGetError();
-		if(error)
+		if (error)
 		{
 			printf("GL error after FBO 0x%04X\n", error);
 			return GL_FALSE;
@@ -143,9 +141,10 @@ GLboolean run_test()
 		}
 	}
 
-	if(test_mode <= TEST_SRT)
+	if (test_mode <= TEST_SRT)
 	{
-		glClampColorARB(GL_CLAMP_READ_COLOR_ARB, GL_FALSE);
+		if (!test_defaults)
+			glClampColorARB(GL_CLAMP_READ_COLOR_ARB, GL_FALSE);
 		pass = test();
 	}
 	else
@@ -153,14 +152,14 @@ GLboolean run_test()
 		unsigned mrt_modes = GLEW_ARB_draw_buffers ? (GLEW_ARB_texture_float ? 3 : 2) : 1;
 		unsigned first_mrt_mode = (test_mode == TEST_MRT) ? 1 : 0;
 
-		for(mrt_mode = first_mrt_mode; mrt_mode < mrt_modes; ++mrt_mode)
+		for (mrt_mode = first_mrt_mode; mrt_mode < mrt_modes; ++mrt_mode)
 		{
 			fixed1 = fixed;
-			if(mrt_mode)
+			if (mrt_mode)
 			{
 				GLenum bufs[2] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1};
 				unsigned format1;
-				if(mrt_mode == 1)
+				if (mrt_mode == 1)
 					format1 = format;
 				else
 				{
@@ -177,7 +176,7 @@ GLboolean run_test()
 					     2, 2, 0,
 					     GL_RGBA, GL_FLOAT, pixels);
 				error = glGetError();
-				if(error)
+				if (error)
 				{
 					printf("GL error after second glTexImage2D 0x%04X\n", error);
 					return GL_FALSE;
@@ -191,7 +190,7 @@ GLboolean run_test()
 
 				status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
 				if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-					if(mrt_mode == 2)
+					if (mrt_mode == 2)
 						printf("Dishomogeneous framebuffer is incomplete, skipping dishomogeneous tests (status = 0x%04x)\n", status);
 					else
 					{
@@ -204,18 +203,19 @@ GLboolean run_test()
 				glDrawBuffers(2, bufs);
 
 				error = glGetError();
-				if(error)
+				if (error)
 				{
 					printf("GL error after second glDrawBuffers 0x%04X\n", error);
 					return GL_FALSE;
 				}
 			}
 
-			glClampColorARB(GL_CLAMP_READ_COLOR_ARB, GL_FALSE);
+			if (!test_defaults)
+				glClampColorARB(GL_CLAMP_READ_COLOR_ARB, GL_FALSE);
 			pass = test() && pass;
 
 	skip_mrt:
-			if(mrt_mode)
+			if (mrt_mode)
 			{
 				glDrawBuffer(GL_COLOR_ATTACHMENT0);
 
@@ -232,14 +232,14 @@ GLboolean run_test()
 	glDeleteTextures(1, &tex);
 	tex = 0;
 	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
-	if(fb)
+	if (fb)
 	{
 		glDeleteFramebuffersEXT(1, &fb);
 		fb = 0;
 	}
 
 	error = glGetError();
-	if(error)
+	if (error)
 	{
 		printf("GL error after test 0x%04X\n", error);
 		return GL_FALSE;
@@ -251,29 +251,11 @@ GLboolean run_test()
 enum piglit_result
 piglit_display(void)
 {
-	GLboolean pass = GL_TRUE;
 	unsigned error;
-	printf("Testing 8-bit fixed-point FBO\n");
-	format = GL_RGBA8;
-	format_name = "un8";
-	pass = run_test() && pass;
-
-	if(GLEW_ARB_texture_float)
-	{
-		printf("\n\n\nTesting 32-bit floating point FBO\n");
-		format = GL_RGBA32F_ARB;
-		format_name = "f32";
-		pass = run_test() && pass;
-		printf("\n\n\nTesting 16-bit floating point FBO\n");
-		format = GL_RGBA16F_ARB;
-		format_name = "f16";
-		pass = run_test() && pass;
-	}
-	else
-		printf("\n\n\nSkipping floating point FBO tests because of no ARB_texture_float.\n");
+	GLboolean pass = run_test();
 
 	error = glGetError();
-	if(error)
+	if (error)
 	{
 		printf("GL error at end 0x%04X\n", error);
 		return GL_FALSE;
@@ -282,7 +264,7 @@ piglit_display(void)
 	return pass ? PIGLIT_SUCCESS : PIGLIT_FAILURE;
 }
 
-unsigned init();
+static unsigned init();
 
 void
 piglit_init(int argc, char **argv)
@@ -290,32 +272,55 @@ piglit_init(int argc, char **argv)
 	int i;
 	GLboolean distinguish_xfails = GL_FALSE;
 
-	(void)i;
 	/* displaying thousands of single-pixel floating point results isn't really useful, or even doable */
 	piglit_automatic = GL_TRUE;
 
-	piglit_require_extension("GL_ARB_color_buffer_float");
-
 	test_mode = init();
 
-	if(test_mode != TEST_NO_RT)
+	if (test_mode != TEST_NO_RT)
 		piglit_require_extension("GL_EXT_framebuffer_object");
 
-	for(i = 1; i < argc; ++i)
+	for (i = 1; i < argc; ++i)
 	{
-		if(!strcmp(argv[i], "-xfail"))
+		if (!strcmp(argv[i], "-xfail")) {
 			distinguish_xfails = GL_TRUE;
+		} else if (!strcmp(argv[i], "sanity")) {
+			test_defaults = GL_TRUE;
+		} else if (!strcmp(argv[i], "fog")) {
+			test_fog = GL_TRUE;
+		} else if (!strcmp(argv[i], "GL_RGBA16F")) {
+			piglit_require_extension("GL_ARB_texture_float");
+			format = GL_RGBA16F;
+			format_name = "f16";
+			printf("\n\n\nTesting 16-bit floating point FBO\n");
+		} else if (!strcmp(argv[i], "GL_RGBA32F")) {
+			piglit_require_extension("GL_ARB_texture_float");
+			format = GL_RGBA32F;
+			format_name = "f32";
+			printf("\n\n\nTesting 32-bit floating point FBO\n");
+		}
+	}
+	if (!format) {
+		format = GL_RGBA8;
+		format_name = "un8";
+		printf("Testing 8-bit fixed-point FBO\n");
+	}
+
+	if (test_defaults) {
+		printf("Testing default clamping rules only. This is a sanity check. GL_ARB_color_buffer_float is not required.\n");
+	} else {
+		piglit_require_extension("GL_ARB_color_buffer_float");
 	}
 
 	/* current ATI drivers are broken */
-	if(!strcmp((char*)glGetString(GL_VENDOR), "ATI Technologies Inc."))
+	if (!strcmp((char*)glGetString(GL_VENDOR), "ATI Technologies Inc."))
 		ati_driver = 1;
 
 	/* current nVidia drivers are broken at least on GeForce 7xxx */
-	if(!strcmp((char*)glGetString(GL_VENDOR), "NVIDIA Corporation"))
+	if (!strcmp((char*)glGetString(GL_VENDOR), "NVIDIA Corporation"))
 		nvidia_driver = 1;
 
-	if(ati_driver || nvidia_driver)
+	if (ati_driver || nvidia_driver)
 	{
 		/* print both so users don't think either driver is better */
 		printf("Notice: the ATI proprietary driver does NOT conform to the GL_ARB_color_buffer_float specification! (tested version was 10.6 on cypress, on Linux x86)\n");
@@ -323,10 +328,10 @@ piglit_init(int argc, char **argv)
 		printf("Notice: the nVidia and ATI proprietary drivers are both nonconformant, in different ways!\n\n\n");
 	}
 
-	if(!distinguish_xfails)
+	if (!distinguish_xfails)
 		ati_driver = nvidia_driver = 0;
 
-	for(i = 0; i < sizeof(pixels) / sizeof(pixels[0]); ++i)
+	for (i = 0; i < sizeof(pixels) / sizeof(pixels[0]); ++i)
 	{
 		clamped_pixels[i] = clamp(pixels[i]);
 		pixels_mul_2[i] = pixels[i] * 2.0f;
@@ -341,9 +346,9 @@ GLboolean compare_arrays(float* expected, float* observed, int length)
 {
 	GLboolean pass = GL_TRUE;
 	unsigned i;
-	for(i = 0; i < length; ++i)
+	for (i = 0; i < length; ++i)
 	{
-		if(fabs(expected[i] - observed[i]) > 0.01)
+		if (fabs(expected[i] - observed[i]) > 0.01)
 		{
 			printf("At %i Expected: %f Observed: %f\n", i, expected[i], observed[i]);
 			pass = GL_FALSE;
diff --git a/tests/spec/arb_color_buffer_float/drawpixels.c b/tests/spec/arb_color_buffer_float/drawpixels.c
index c209b49e4..2e4835b64 100644
--- a/tests/spec/arb_color_buffer_float/drawpixels.c
+++ b/tests/spec/arb_color_buffer_float/drawpixels.c
@@ -37,15 +37,19 @@
 GLboolean test()
 {
 	GLboolean pass = GL_TRUE;
+	unsigned frag_clamp;
 
-	for(frag_clamp = 0; frag_clamp < 3; ++frag_clamp)
+	for (frag_clamp = test_defaults ? 1 : 0; frag_clamp < (test_defaults ? 2 : 3); ++frag_clamp)
 	{
 		GLboolean cpass = GL_TRUE;
 		GLboolean opass;
 		unsigned clamped = clamp_enums[frag_clamp] == GL_TRUE || (clamp_enums[frag_clamp] == GL_FIXED_ONLY_ARB && fixed);
 		unsigned x, y;
+		float* expected;
+
 		printf("glDrawPixels of fbo for float texture with fragment clamp %s (expecting %sclamping)\n", clamp_strings[frag_clamp], clamped ? "" : "no ");
-		glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, clamp_enums[frag_clamp]);
+		if (!test_defaults)
+			glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, clamp_enums[frag_clamp]);
 
 		glClearColor(0, 0, 0, 0);
 		glClear(GL_COLOR_BUFFER_BIT);
diff --git a/tests/spec/arb_color_buffer_float/getteximage.c b/tests/spec/arb_color_buffer_float/getteximage.c
index 4d9dd9d14..750543616 100644
--- a/tests/spec/arb_color_buffer_float/getteximage.c
+++ b/tests/spec/arb_color_buffer_float/getteximage.c
@@ -33,11 +33,16 @@
 GLboolean test()
 {
 	GLboolean pass = GL_TRUE;
+	unsigned read_clamp;
 
 	for(read_clamp = 0; read_clamp < 3; ++read_clamp)
 	{
+		float observed[16];
+		float* expected;
+
 		printf("glGetTexImage of %s texture with read clamp %s (expecting %sclamping)\n", format_name, clamp_strings[read_clamp], fixed ? "" : "no ");
-		glClampColorARB(GL_CLAMP_READ_COLOR_ARB, clamp_enums[read_clamp]);
+		if (!test_defaults)
+			glClampColorARB(GL_CLAMP_READ_COLOR_ARB, clamp_enums[read_clamp]);
 
 		memset(observed, 0, sizeof(observed));
 		glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_FLOAT, observed);
diff --git a/tests/spec/arb_color_buffer_float/mrt.c b/tests/spec/arb_color_buffer_float/mrt.c
index 7d1bd8e69..0f51485c7 100644
--- a/tests/spec/arb_color_buffer_float/mrt.c
+++ b/tests/spec/arb_color_buffer_float/mrt.c
@@ -70,15 +70,18 @@ GLboolean
 test()
 {
 	GLboolean pass = GL_TRUE;
+	unsigned frag_clamp;
 
-	for(frag_clamp = 0; frag_clamp < 3; ++frag_clamp)
+	for (frag_clamp = test_defaults ? 1 : 0; frag_clamp < (test_defaults ? 2 : 3); ++frag_clamp)
 	{
 		GLboolean cpass = GL_TRUE;
 		GLboolean opass;
 		GLboolean clamped = clamp_enums[frag_clamp] == GL_TRUE || (clamp_enums[frag_clamp] == GL_FIXED_ONLY_ARB && fixed);
+		float *expected, *expected1;
 
 		printf("MRT rendering in %s mode with fragment clamp %s (expecting %sclamping)\n", mrt_mode_strings[mrt_mode], clamp_strings[frag_clamp], clamped ? "" : "no ");
-		glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, clamp_enums[frag_clamp]);
+		if (!test_defaults)
+			glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, clamp_enums[frag_clamp]);
 
 		glBindProgramARB(GL_VERTEX_PROGRAM_ARB, mrt_vp);
 		glEnable(GL_VERTEX_PROGRAM_ARB);
diff --git a/tests/spec/arb_color_buffer_float/probepixel.c b/tests/spec/arb_color_buffer_float/probepixel.c
index 74eb08649..b5af7ed5a 100644
--- a/tests/spec/arb_color_buffer_float/probepixel.c
+++ b/tests/spec/arb_color_buffer_float/probepixel.c
@@ -37,13 +37,17 @@
 GLboolean test()
 {
 	GLboolean pass = GL_TRUE;
+	unsigned read_clamp;
 
 	for(read_clamp = 0; read_clamp < 3; ++read_clamp)
 	{
 		unsigned clamped = clamp_enums[read_clamp] == GL_TRUE || (clamp_enums[read_clamp] == GL_FIXED_ONLY_ARB && fixed);
 		unsigned x, y;
+		float* expected;
+
 		printf("probe_pixel of fbo for float texture with read clamp %s (expecting %sclamping)\n", clamp_strings[read_clamp], clamped ? "" : "no ");
-		glClampColorARB(GL_CLAMP_READ_COLOR_ARB, clamp_enums[read_clamp]);
+		if (!test_defaults)
+			glClampColorARB(GL_CLAMP_READ_COLOR_ARB, clamp_enums[read_clamp]);
 
 		expected = (fixed || clamped) ? clamped_pixels : pixels;
 
@@ -66,7 +70,8 @@ GLboolean test()
 			}
 	}
 
-	glClampColorARB(GL_CLAMP_READ_COLOR_ARB, GL_FALSE);
+	if (!test_defaults)
+		glClampColorARB(GL_CLAMP_READ_COLOR_ARB, GL_FALSE);
 	return pass;
 }
 
diff --git a/tests/spec/arb_color_buffer_float/queries.c b/tests/spec/arb_color_buffer_float/queries.c
index c77117da4..79ce807b1 100644
--- a/tests/spec/arb_color_buffer_float/queries.c
+++ b/tests/spec/arb_color_buffer_float/queries.c
@@ -44,22 +44,27 @@ GLboolean test()
 {
 	GLboolean pass = GL_TRUE;
 	glBindTexture(GL_TEXTURE_2D, tex); /* for border color */
+	unsigned frag_clamp;
 
-	for(frag_clamp = 0; frag_clamp < 3; ++frag_clamp)
+	for (frag_clamp = test_defaults ? 1 : 0; frag_clamp < (test_defaults ? 2 : 3); ++frag_clamp)
 	{
 		const char *value_names[] = { "texture border color", "texenv color", "fog color", "alpha test reference", "blend color", "clear color" };
 		unsigned value;
 		for(value = 0; value < 6; ++value)
 		{
+			float observed[16];
+			char test_name[4096];
 			GLboolean cpass = GL_TRUE;
 			GLboolean opass;
 			unsigned clamped = clamp_enums[frag_clamp] == GL_TRUE || (clamp_enums[frag_clamp] == GL_FIXED_ONLY_ARB && fixed);
 			unsigned comps = 4;
+			float* expected;
 
 			sprintf(test_name, "glGet of %s in %s mode with fragment clamp %s (expecting %sclamping)", value_names[value], mrt_mode_strings[mrt_mode], clamp_strings[frag_clamp], clamped ? "" : "no ");
 			printf("%s\n", test_name);
 
-			glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, clamp_enums[frag_clamp]);
+			if (!test_defaults)
+				glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, clamp_enums[frag_clamp]);
 
 			memset(observed, 0, sizeof(observed));
 			switch (value)
diff --git a/tests/spec/arb_color_buffer_float/readpixels.c b/tests/spec/arb_color_buffer_float/readpixels.c
index f7c4654ae..eb8eae1ab 100644
--- a/tests/spec/arb_color_buffer_float/readpixels.c
+++ b/tests/spec/arb_color_buffer_float/readpixels.c
@@ -43,15 +43,19 @@
 GLboolean test()
 {
 	GLboolean pass = GL_TRUE;
+	unsigned read_clamp;
 
 	for(read_clamp = 0; read_clamp < 3; ++read_clamp)
 	{
+		float observed[16];
 		GLboolean cpass = GL_TRUE;
 		GLboolean opass;
 		unsigned clamped = clamp_enums[read_clamp] == GL_TRUE || (clamp_enums[read_clamp] == GL_FIXED_ONLY_ARB && fixed);
+		float* expected;
 
 		printf("glReadPixels of fbo for float texture with read clamp %s (expecting %sclamping)\n", clamp_strings[read_clamp], clamped ? "" : "no ");
-		glClampColorARB(GL_CLAMP_READ_COLOR_ARB, clamp_enums[read_clamp]);
+		if (!test_defaults)
+			glClampColorARB(GL_CLAMP_READ_COLOR_ARB, clamp_enums[read_clamp]);
 
 		memset(observed, 0, sizeof(observed));
 		glReadPixels(0, 0, 2, 2, GL_RGBA, GL_FLOAT, observed);
@@ -68,7 +72,8 @@ GLboolean test()
 		pass = opass && pass;
 	}
 
-	glClampColorARB(GL_CLAMP_READ_COLOR_ARB, GL_FALSE);
+	if (!test_defaults)
+		glClampColorARB(GL_CLAMP_READ_COLOR_ARB, GL_FALSE);
 	return pass;
 }
 
diff --git a/tests/spec/arb_color_buffer_float/render.c b/tests/spec/arb_color_buffer_float/render.c
index 3160f89b6..1699f5cb6 100644
--- a/tests/spec/arb_color_buffer_float/render.c
+++ b/tests/spec/arb_color_buffer_float/render.c
@@ -41,7 +41,7 @@
 
 #include "common.h"
 
-const char *blend_strings[] = { "disabled", "(ONE, ZERO)", "(CONSTANT_COLOR, ZERO)", "(ONE, ONE)" };
+const char *blend_strings[] = { "disabled     ", "(ONE, ZERO)  ", "(CONST, ZERO)", "(ONE, ONE)   " };
 GLenum blend_src[] = { 0, GL_ONE, GL_CONSTANT_COLOR, GL_ONE };
 GLenum blend_dst[] = { 0, GL_ZERO, GL_ZERO, GL_ONE };
 
@@ -80,21 +80,25 @@ unsigned fps[4];
 
 GLboolean test()
 {
+	GLfloat probe[4];
 	GLboolean pass = GL_TRUE;
-	unsigned semantic, blend, logicop, vpmode, fpmode, fog;
+	int npass = 0, total = 0;
+	unsigned semantic, blend, logicop, vpmode, fpmode;
 	unsigned vpmodes = 1 + !!GLEW_ARB_vertex_program;
 	unsigned fpmodes = 1 + !!GLEW_ARB_fragment_program;
+	unsigned vert_clamp, frag_clamp;
+
 	glFogi(GL_FOG_MODE, GL_LINEAR);
 
-	for(vert_clamp = 0; vert_clamp < 3; ++vert_clamp)
-	for(frag_clamp = 0; frag_clamp < 3; ++frag_clamp)
+	for(vert_clamp = 0; vert_clamp < (test_defaults ? 1 : 3); ++vert_clamp)
+	for (frag_clamp = test_defaults ? 1 : 0; frag_clamp < (test_defaults ? 2 : 3); ++frag_clamp)
 	for(semantic = 0; semantic < 2; ++semantic)
 	for(blend = 0; blend < 4; ++blend)
 	for(logicop = 0; logicop < 2; ++logicop)
 	for(vpmode = 0; vpmode < vpmodes; ++vpmode)
 	for(fpmode = 0; fpmode < fpmodes; ++fpmode)
-	for(fog = 0; fog < 2; ++fog)
 	{
+		char test_name[4096];
 		unsigned clamped = (semantic == 0 && (clamp_enums[vert_clamp] == GL_TRUE || (clamp_enums[vert_clamp] == GL_FIXED_ONLY_ARB && fixed))) || clamp_enums[frag_clamp] == GL_TRUE || (clamp_enums[frag_clamp] == GL_FIXED_ONLY_ARB && fixed);
 		float *expected;
 		GLboolean cpass;
@@ -103,10 +107,11 @@ GLboolean test()
 		if(!fpmode && semantic)
 			continue;
 
-		sprintf(test_name, "%s: render constant through %s with vertex clamp %s and fragment clamp %s and blending %s and logicop %s using %s and %s%s (expecting %sclamping)", format_name, semantic ? "TEXCOORD0" : "COLOR", clamp_strings[vert_clamp], clamp_strings[frag_clamp], blend_strings[blend], logicop ? "enabled" : "disabled", vpmode ? "ARB_vp" : "ffvp", fpmode ? "ARB_fp" : "fffp", fog ? " with fog" : "", clamped ? "" : "no ");
-		printf("%s\n", test_name);
-		glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, clamp_enums[vert_clamp]);
-		glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, clamp_enums[frag_clamp]);
+		sprintf(test_name, "%s: Attrib %s  VertClamp %s  FragClamp %s  Blending %s  LogicOp %s  %s  %s  Fog %s (expecting %sclamping)", format_name, semantic ? "TEXCOORD0" : "COLOR    ", clamp_strings[vert_clamp], clamp_strings[frag_clamp], blend_strings[blend], logicop ? "Yes" : "No ", vpmode ? "ARB_vp" : "ffvp  ", fpmode ? "ARB_fp" : "fffp  ", test_fog ? "Yes" : "No ", clamped ? "" : "no ");
+		if (!test_defaults) {
+			glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, clamp_enums[vert_clamp]);
+			glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, clamp_enums[frag_clamp]);
+		}
 
 		glColor4f(0.1f, 0.2f, 0.3f, 0.4f);
 		glTexCoord4f(0.5f, 0.6f, 0.7f, 0.8f);
@@ -126,12 +131,12 @@ GLboolean test()
 
 		if(fpmode)
 		{
-			glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, fps[semantic + (fog ? 2 : 0)]);
+			glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, fps[semantic + (test_fog ? 2 : 0)]);
 			glEnable(GL_FRAGMENT_PROGRAM_ARB);
 		}
 		else
 		{
-			if(fog)
+			if(test_fog)
 				glEnable(GL_FOG);
 		}
 
@@ -157,7 +162,7 @@ GLboolean test()
 			glDisable(GL_VERTEX_PROGRAM_ARB);
 		if(fpmode)
 			glDisable(GL_FRAGMENT_PROGRAM_ARB);
-		else if(fog)
+		else if(test_fog)
 			glDisable(GL_FOG);
 
 		if(blend == 2 && !logicop)
@@ -177,27 +182,38 @@ GLboolean test()
 		else
 			expected = (clamped || fixed) ? clamped_pixels : pixels;
 
-		opass = cpass = piglit_probe_pixel_rgba(0, 0, expected);
+		opass = cpass = piglit_probe_pixel_rgba_silent(0, 0, expected, probe);
 
-		if(!cpass && nvidia_driver && clamped && !(semantic == 0 && clamp_enums[vert_clamp] == GL_TRUE) && clamp_enums[frag_clamp] == GL_TRUE && !fixed && fpmode && (!blend || logicop || format == GL_RGBA16F_ARB))
+		if(nvidia_driver && clamped && !(semantic == 0 && clamp_enums[vert_clamp] == GL_TRUE) && clamp_enums[frag_clamp] == GL_TRUE && !fixed && fpmode && (!blend || logicop || format == GL_RGBA16F_ARB))
 		{
 			printf("nVidia driver known *** MAJOR BUG ***: they don't clamp fragment program results with ARB_fp on either fp32 with no blending or fp16!\n");
 			opass = GL_TRUE;
 		}
-		if(!cpass && nvidia_driver && clamped && !fixed && !fpmode && semantic == 0 && clamp_enums[vert_clamp] != GL_TRUE && clamp_enums[frag_clamp] == GL_TRUE)
+		if(nvidia_driver && clamped && !fixed && !fpmode && semantic == 0 && clamp_enums[vert_clamp] != GL_TRUE && clamp_enums[frag_clamp] == GL_TRUE)
 		{
 			printf("nVidia driver known *** MAJOR BUG ***: they don't clamp fragment program results with fffp, vertex clamp off and fragment clamp on fp16/fp32!\n");
 			opass = GL_TRUE;
 		}
-		if(!cpass && fog && fpmode)
+		if(test_fog && fpmode)
 		{
-			printf("Unclear specification on GL_ARB_fog_*\n");
+			//printf("Unclear specification on GL_ARB_fog_*\n");
 			opass = GL_TRUE;
 		}
-		printf("%s: %s\n", (cpass ? "PASS" : (opass ? "XFAIL" : "FAIL")), test_name);
+
+		if (!opass) {
+			printf("%s: %s\n", (cpass ? "PASS" : (opass ? "XFAIL" : "FAIL")), test_name);
+			printf("  Expected: %f %f %f %f\n", expected[0], expected[1], expected[2], expected[3]);
+			printf("  Observed: %f %f %f %f\n", probe[0], probe[1], probe[2], probe[3]);
+
+		} else {
+			npass++;
+		}
+		total++;
+
 		pass = opass && pass;
 	}
 
+	printf("Summary: %i/%i passed.\n", npass, total);
 	return pass;
 }