arb_texture_compression: Check that only the correct formats are advertised

There are particular rules about which formats should be advertised
via the GL_COMPRESSED_TEXTURE_FORMATS query.  This checks that those
rules are followed.

This test, in all its variations, passes on NVIDIA (driver 260.19.36).

This test fails on AMD (driver 11.6) because the
GL_COMPRESSED_TEXTURE_FORMATS query does not return *any* formats.

This test fails on Mesa (driver 7.10.3) because the S3TC sRGB
formats are advertised even when GL_EXT_texture_compress_s3tc is not
available.

3 files changed, 487 insertions, 0 deletions

diff --git a/tests/all.tests b/tests/all.tests
index e9170168..306ae7ed 100644
--- a/tests/all.tests
+++ b/tests/all.tests
@@ -838,6 +838,8 @@ add_texwrap_test2(arb_texture_rectangle, 'RECT', 'proj')
 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')
+tdfx_texture_compression_fxt1['invalid formats'] = PlainExecTest(['arb_texture_compression-invalid-formats', 'fxt1'])
+tdfx_texture_compression_fxt1['invalid formats'].runConcurrent = True
 
 def add_color_buffer_float_test(name, format, p1, p2):
 	arb_color_buffer_float[format + '-' + name + ('-' + p1 if len(p1) else '') + ('-' + p2 if len(p2) else '')] = PlainExecTest(['arb_color_buffer_float-' + name, format, p1, p2])
@@ -924,6 +926,13 @@ add_texwrap_test2(arb_texture_compression, '2D', 'GL_COMPRESSED_RGB')
 add_texwrap_test2(arb_texture_compression, '2D', 'GL_COMPRESSED_RGBA')
 arb_texture_compression['GL_TEXTURE_INTERNAL_FORMAT query'] = PlainExecTest(['arb_texture_compression-internal-format-query', '-auto'])
 arb_texture_compression['GL_TEXTURE_INTERNAL_FORMAT query'].runConcurrent = True
+arb_texture_compression['unknown formats'] = PlainExecTest(['arb_texture_compression-invalid-formats', 'unknown'])
+arb_texture_compression['unknown formats'].runConcurrent = True
+
+arb_texture_compression_bptc = Group()
+spec['ARB_texture_compression_bptc'] = arb_texture_compression_bptc
+arb_texture_compression_bptc['invalid formats'] = PlainExecTest(['arb_texture_compression-invalid-formats', 'bptc'])
+arb_texture_compression_bptc['invalid formats'].runConcurrent = True
 
 arb_vertex_buffer_object = Group()
 spec['ARB_vertex_buffer_object'] = arb_vertex_buffer_object
@@ -960,6 +969,8 @@ add_texwrap_test2(ext_texture_compression_latc, '2D', 'GL_COMPRESSED_LUMINANCE_L
 add_texwrap_test2(ext_texture_compression_latc, '2D', 'GL_COMPRESSED_SIGNED_LUMINANCE_LATC1')
 add_texwrap_test2(ext_texture_compression_latc, '2D', 'GL_COMPRESSED_LUMINANCE_ALPHA_LATC2')
 add_texwrap_test2(ext_texture_compression_latc, '2D', 'GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2')
+ext_texture_compression_latc['invalid formats'] = PlainExecTest(['arb_texture_compression-invalid-formats', 'latc'])
+ext_texture_compression_latc['invalid formats'].runConcurrent = True
 
 ext_texture_compression_rgtc = Group()
 spec['EXT_texture_compression_rgtc'] = ext_texture_compression_rgtc
@@ -969,6 +980,8 @@ add_texwrap_test2(ext_texture_compression_rgtc, '2D', 'GL_COMPRESSED_RED_RGTC1')
 add_texwrap_test2(ext_texture_compression_rgtc, '2D', 'GL_COMPRESSED_SIGNED_RED_RGTC1')
 add_texwrap_test2(ext_texture_compression_rgtc, '2D', 'GL_COMPRESSED_RG_RGTC2')
 add_texwrap_test2(ext_texture_compression_rgtc, '2D', 'GL_COMPRESSED_SIGNED_RG_RGTC2')
+ext_texture_compression_rgtc['invalid formats'] = PlainExecTest(['arb_texture_compression-invalid-formats', 'rgtc'])
+ext_texture_compression_rgtc['invalid formats'].runConcurrent = True
 
 ext_texture_compression_s3tc = Group()
 spec['EXT_texture_compression_s3tc'] = ext_texture_compression_s3tc
@@ -977,11 +990,15 @@ add_texwrap_test2(ext_texture_compression_s3tc, '2D', 'GL_COMPRESSED_RGB_S3TC_DX
 add_texwrap_test2(ext_texture_compression_s3tc, '2D', 'GL_COMPRESSED_RGBA_S3TC_DXT1')
 add_texwrap_test2(ext_texture_compression_s3tc, '2D', 'GL_COMPRESSED_RGBA_S3TC_DXT3')
 add_texwrap_test2(ext_texture_compression_s3tc, '2D', 'GL_COMPRESSED_RGBA_S3TC_DXT5')
+ext_texture_compression_s3tc['invalid formats'] = PlainExecTest(['arb_texture_compression-invalid-formats', 's3tc'])
+ext_texture_compression_s3tc['invalid formats'].runConcurrent = True
 
 ati_texture_compression_3dc = Group()
 spec['ATI_texture_compression_3dc'] = ati_texture_compression_3dc
 add_fbo_generatemipmap_extension(ati_texture_compression_3dc, 'GL_ATI_texture_compression_3dc', 'fbo-generatemipmap-formats')
 add_texwrap_test2(ati_texture_compression_3dc, '2D', 'GL_COMPRESSED_LUMINANCE_ALPHA_3DC')
+ati_texture_compression_3dc['invalid formats'] = PlainExecTest(['arb_texture_compression-invalid-formats', '3dc'])
+ati_texture_compression_3dc['invalid formats'].runConcurrent = True
 
 ext_packed_float = Group()
 spec['EXT_packed_float'] = ext_packed_float
@@ -1078,6 +1095,8 @@ add_fbo_generatemipmap_extension(ext_texture_srgb, 'GL_EXT_texture_sRGB', 'fbo-g
 #add_fbo_blending_extension(ext_texture_srgb, 'GL_EXT_texture_sRGB', 'fbo-blending-formats')
 add_fbo_alphatest_extension(ext_texture_srgb, 'GL_EXT_texture_sRGB', 'fbo-alphatest-formats')
 add_fbo_generatemipmap_extension(ext_texture_srgb, 'GL_EXT_texture_sRGB-s3tc', 'fbo-generatemipmap-formats-s3tc')
+ext_texture_srgb['invalid formats'] = PlainExecTest(['arb_texture_compression-invalid-formats', 'srgb'])
+ext_texture_srgb['invalid formats'].runConcurrent = True
 
 ati_draw_buffers = Group()
 spec['ATI_draw_buffers'] = ati_draw_buffers
@@ -1121,6 +1140,11 @@ nv_conditional_render['drawpixels'] = PlainExecTest(['nv_conditional_render-draw
 nv_conditional_render['generatemipmap'] = PlainExecTest(['nv_conditional_render-generatemipmap', '-auto'])
 nv_conditional_render['vertex_array'] = PlainExecTest(['nv_conditional_render-vertex_array', '-auto'])
 
+oes_compressed_paletted_texture = Group()
+spec['OES_compressed_paletted_texture'] = oes_compressed_paletted_texture
+oes_compressed_paletted_texture['invalid formats'] = PlainExecTest(['arb_texture_compression-invalid-formats', 'paletted'])
+oes_compressed_paletted_texture['invalid formats'].runConcurrent = True
+
 # group glslparsertest ------------------------------------------------------
 glslparsertest = Group()
 # Add all shader source files in the directories below.
diff --git a/tests/spec/arb_texture_compression/CMakeLists.gl.txt b/tests/spec/arb_texture_compression/CMakeLists.gl.txt
index 7fdf00c6..5a9040da 100644
--- a/tests/spec/arb_texture_compression/CMakeLists.gl.txt
+++ b/tests/spec/arb_texture_compression/CMakeLists.gl.txt
@@ -13,5 +13,6 @@ link_libraries (
 )
 
 add_executable (arb_texture_compression-internal-format-query internal-format-query.c)
+add_executable (arb_texture_compression-invalid-formats invalid-formats.c)
 
 # vim: ft=cmake:
diff --git a/tests/spec/arb_texture_compression/invalid-formats.c b/tests/spec/arb_texture_compression/invalid-formats.c
new file mode 100644
index 00000000..114f2f5e
--- /dev/null
+++ b/tests/spec/arb_texture_compression/invalid-formats.c
@@ -0,0 +1,462 @@
+/*
+ * Copyright © 2011 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+/**
+ * \file internal-format-query.c
+ * Check that only general-purpose fmts are listed by COMPRESSED_TEXTURE_FORMATS
+ *
+ * From page 117 (page 129 of the PDF) of the OpenGL 1.3 spec says:
+ *
+ *     "The set of specific compressed internal formats supported by the
+ *     renderer can be obtained by querying the value of COMPRESSED TEXTURE
+ *     FORMATS. The only values returned by this query are those corresponding
+ *     to formats suitable for general-purpose usage. The renderer will not
+ *     enumerate formats with restrictions that need to be specifically
+ *     understood prior to use."
+ *
+ * All texture compression extensions have taken this to mean only linear RGB
+ * and linear RGBA formats should be exposed.
+ */
+#include "piglit-util.h"
+
+int piglit_width = 10, piglit_height = 10;
+int piglit_window_mode = GLUT_RGB;
+
+#define ENUM_AND_STRING(e) \
+	# e, e
+
+struct format_tuple {
+	const char *name;
+	GLenum format;
+};
+
+/**
+ * Set of formats for a particular extension
+ *
+ * Each array of "good" formats and "bad" formats is terminated by a sentinel
+ * with \c format set to zero.
+ *
+ * \note
+ * The arrays are sized for the largest set from any extension.  They may need
+ * to be expanded in the future.
+ */
+struct format_list {
+	/**
+	 * Formats that are part of the extension and should be exposed.
+	 */
+	struct format_tuple good[11];
+
+	/**
+	 * Formats that are part of the extension but should not be exposed.
+	 */
+	struct format_tuple bad[5];
+};
+
+/**
+ * Formats belonging to GL_ARB_texture_comrpession_bptc
+ */
+static const struct format_list bptc_formats = {
+	{
+		{ ENUM_AND_STRING(GL_COMPRESSED_RGBA_BPTC_UNORM_ARB) },
+		{ ENUM_AND_STRING(GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB) },
+		{ ENUM_AND_STRING(GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB) },
+		{ ENUM_AND_STRING(GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB) },
+		{ NULL, 0 },
+	},
+	{
+		{ NULL, 0 },
+	}
+};
+
+/**
+ * Formats belonging to GL_ARB_texture_comrpession_rgtc
+ */
+static const struct format_list rgtc_formats = {
+	{
+		{ NULL, 0 },
+	},
+	{
+		{ ENUM_AND_STRING(GL_COMPRESSED_RED_RGTC1) },
+		{ ENUM_AND_STRING(GL_COMPRESSED_SIGNED_RED_RGTC1) },
+		{ ENUM_AND_STRING(GL_COMPRESSED_RG_RGTC2) },
+		{ ENUM_AND_STRING(GL_COMPRESSED_SIGNED_RG_RGTC2) },
+		{ NULL, 0 },
+	}
+};
+
+/**
+ * Formats belonging to GL_3DFX_texture_comrpession_FXT1
+ */
+static const struct format_list fxt1_formats = {
+	{
+		{ ENUM_AND_STRING(GL_COMPRESSED_RGB_FXT1_3DFX) },
+		{ ENUM_AND_STRING(GL_COMPRESSED_RGBA_FXT1_3DFX) },
+		{ NULL, 0 },
+	},
+	{
+		{ NULL, 0 },
+	}
+};
+
+/**
+ * Formats belonging to GL_ATI_texture_comrpession_3dc
+ */
+static const struct format_list ati_3dc_formats = {
+	{
+		{ NULL, 0 },
+	},
+	{
+		{ "GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI", 0x8837 },
+		{ NULL, 0 },
+	}
+};
+
+/**
+ * Formats belonging to GL_EXT_texture_comrpession_latc
+ */
+static const struct format_list latc_formats = {
+	{
+		{ NULL, 0 },
+	},
+	{
+		{ ENUM_AND_STRING(GL_COMPRESSED_LUMINANCE_LATC1_EXT) },
+		{ ENUM_AND_STRING(GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT) },
+		{ ENUM_AND_STRING(GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT) },
+		{ ENUM_AND_STRING(GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT) },
+		{ NULL, 0 },
+	}
+};
+
+/**
+ * Formats belonging to GL_EXT_texture_comrpession_s3tc
+ */
+static const struct format_list s3tc_formats = {
+	{
+		{ ENUM_AND_STRING(GL_COMPRESSED_RGB_S3TC_DXT1_EXT) },
+		{ ENUM_AND_STRING(GL_COMPRESSED_RGBA_S3TC_DXT3_EXT) },
+		{ ENUM_AND_STRING(GL_COMPRESSED_RGBA_S3TC_DXT5_EXT) },
+		{ NULL, 0 },
+	},
+	{
+		{ ENUM_AND_STRING(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT) },
+		{ NULL, 0 },
+	}
+};
+
+/**
+ * Formats belonging to GL_EXT_texture_sRGB
+ *
+ * These should only be exported if GL_EXT_texture_compression_s3tc is also
+ * supported.
+ */
+static const struct format_list srgb_formats = {
+	{
+		{ NULL, 0 },
+	},
+	{
+		{ ENUM_AND_STRING(GL_COMPRESSED_SRGB_S3TC_DXT1_EXT) },
+		{ ENUM_AND_STRING(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT) },
+		{ ENUM_AND_STRING(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT) },
+		{ ENUM_AND_STRING(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT) },
+		{ NULL, 0 },
+	}
+};
+
+/**
+ * Formats belonging to GL_OES_comrpessed_paletted_texture
+ */
+static const struct format_list paletted_formats = {
+	{
+		{ ENUM_AND_STRING(GL_PALETTE4_RGB8_OES) },
+		{ ENUM_AND_STRING(GL_PALETTE4_RGBA8_OES) },
+		{ ENUM_AND_STRING(GL_PALETTE4_R5_G6_B5_OES) },
+		{ ENUM_AND_STRING(GL_PALETTE4_RGBA4_OES) },
+		{ ENUM_AND_STRING(GL_PALETTE4_RGB5_A1_OES) },
+		{ ENUM_AND_STRING(GL_PALETTE8_RGB8_OES) },
+		{ ENUM_AND_STRING(GL_PALETTE8_RGBA8_OES) },
+		{ ENUM_AND_STRING(GL_PALETTE8_R5_G6_B5_OES) },
+		{ ENUM_AND_STRING(GL_PALETTE8_RGBA4_OES) },
+		{ ENUM_AND_STRING(GL_PALETTE8_RGB5_A1_OES) },
+		{ NULL, 0 },
+	},
+	{
+		{ NULL, 0 },
+	}
+};
+
+/**
+ * List of all known compression methods to test
+ *
+ * The dummy first element is because this list is used by \c main to replace
+ * the \c argv vector when no command line parameters are supplied.
+ */
+const char *all_formats[] = {
+	"argv[0]",
+	"bptc",
+	"s3tc",
+	"fxt1",
+	"latc",
+	"3dc",
+	"rgtc",
+	"srgb",
+	"paletted"
+};
+
+enum piglit_result
+piglit_display(void)
+{
+	return PIGLIT_FAIL;
+}
+
+static bool
+reject_bad(const struct format_tuple *bad, GLenum *compressed_formats,
+	   GLint num_compressed_formats, bool check_errors)
+{
+	bool pass = true;
+	unsigned i;
+	unsigned j;
+
+	for (i = 0; bad[i].format != 0; i++) {
+		for (j = 0; j < num_compressed_formats; j++) {
+			if (compressed_formats[j] == 0)
+				continue;
+
+			if (compressed_formats[j] == bad[i].format)
+				break;
+		}
+
+		if (j != num_compressed_formats) {
+			if (check_errors) {
+				fprintf(stderr,
+					"%s should not be available.\n",
+					bad[i].name);
+				pass = false;
+			}
+
+			/* Replace formats that have been processed with
+			 * zero.  This allows detection of values that don't
+			 * belong to any compression extension.
+			 */
+			compressed_formats[j] = 0;
+		}
+	}
+
+	return pass;
+}
+
+static bool
+try_formats(const struct format_list *t, GLenum *compressed_formats,
+	    GLint num_compressed_formats, bool check_errors, bool supported)
+{
+	bool pass = true;
+
+	if (!supported) {
+		pass = reject_bad(t->good, compressed_formats,
+				  num_compressed_formats, check_errors)
+			&& pass;
+	} else {
+		unsigned i;
+		unsigned j;
+
+		for (i = 0; t->good[i].format != 0; i++) {
+			for (j = 0; j < num_compressed_formats; j++) {
+				if (compressed_formats[j] == 0)
+					continue;
+
+				if (compressed_formats[j] == t->good[i].format)
+					break;
+			}
+
+			if (j == num_compressed_formats) {
+				if (check_errors) {
+					fprintf(stderr,
+						"%s should be available.\n",
+						t->good[i].name);
+					pass = false;
+				}
+			} else {
+				/* Replace formats that have been processed
+				 * with zero.  This allows detection of values
+				 * that don't belong to any compression
+				 * extension.
+				 */
+				compressed_formats[j] = 0;
+			}
+		}
+	}
+
+	pass = reject_bad(t->bad, compressed_formats, num_compressed_formats,
+			  check_errors)
+		&& pass;
+
+	return pass;
+}
+
+void
+piglit_init(int argc, char **argv)
+{
+	GLint num_compressed_formats;
+	GLenum *compressed_formats = NULL;
+	unsigned i;
+	bool pass = true;
+	bool log_header = true;
+	bool do_all = false;
+	bool check_errors = true;
+
+	piglit_require_extension("GL_ARB_texture_compression");
+
+	glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS,
+		      &num_compressed_formats);
+	if (num_compressed_formats == 0) {
+		printf("No compressed formats supported.\n");
+	} else {
+		compressed_formats = calloc(num_compressed_formats,
+					    sizeof(GLenum));
+		glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS,
+			      (GLint *) compressed_formats);
+
+		printf("Driver reported the following compressed formats:\n");
+		for (i = 0; i < num_compressed_formats; i++) {
+			printf("    0x%04x\n", compressed_formats[i]);
+		}
+		printf("\n");
+		fflush(stdout);
+	}
+
+	/* First scan the list of formats looking for zeros.  We use that as
+	 * magic flag later in the test.
+	 */
+	for (i = 0; i < num_compressed_formats; i++) {
+		if (compressed_formats[i] == 0) {
+			fprintf(stderr,
+				"Invalid value 0x0000 in format list.\n");
+			piglit_report_result(PIGLIT_FAIL);
+		}
+	}
+
+	/* The "unknown" flag instructs the test to just check for values that
+	 * don't belong to any compression extension supported by this
+	 * implementation.
+	 */
+	if (argc > 1 && strcmp("unknown", argv[1]) == 0) {
+		check_errors = false;
+		argv++;
+		argc--;
+	}
+
+	if (argc == 1) {
+		argv = all_formats;
+		argc = ARRAY_SIZE(all_formats);
+		do_all = true;
+	}
+
+	for (i = 1; i < argc; i++) {
+		if (strcmp(argv[i], "bptc") == 0) {
+			pass = try_formats(&bptc_formats,
+					   compressed_formats,
+					   num_compressed_formats,
+					   check_errors,
+					   GLEW_ARB_texture_compression_bptc)
+				&& pass;
+		} else if (strcmp(argv[i], "s3tc") == 0) {
+			pass = try_formats(&s3tc_formats,
+					   compressed_formats,
+					   num_compressed_formats,
+					   check_errors,
+					   GLEW_EXT_texture_compression_s3tc)
+				&& pass;
+		} else if (strcmp(argv[i], "fxt1") == 0) {
+			pass = try_formats(&fxt1_formats,
+					   compressed_formats,
+					   num_compressed_formats,
+					   check_errors,
+					   GLEW_3DFX_texture_compression_FXT1)
+				&& pass;
+		} else if (strcmp(argv[i], "latc") == 0) {
+			pass = try_formats(&latc_formats,
+					   compressed_formats,
+					   num_compressed_formats,
+					   check_errors,
+					   GLEW_EXT_texture_compression_latc)
+				&& pass;
+		} else if (strcmp(argv[i], "3dc") == 0) {
+			pass = try_formats(&ati_3dc_formats,
+					   compressed_formats,
+					   num_compressed_formats,
+					   check_errors,
+					   GLEW_ATI_texture_compression_3dc)
+				&& pass;
+		} else if (strcmp(argv[i], "rgtc") == 0) {
+			pass = try_formats(&rgtc_formats,
+					   compressed_formats,
+					   num_compressed_formats,
+					   check_errors,
+					   (GLEW_ARB_texture_compression_rgtc
+					    || GLEW_EXT_texture_compression_rgtc))
+				&& pass;
+		} else if (strcmp(argv[i], "srgb") == 0) {
+			pass = try_formats(&srgb_formats,
+					   compressed_formats,
+					   num_compressed_formats,
+					   check_errors,
+					   (GLEW_EXT_texture_sRGB
+					    && GLEW_EXT_texture_compression_s3tc))
+				&& pass;
+		} else if (strcmp(argv[i], "paletted") == 0) {
+			pass = try_formats(&paletted_formats,
+					   compressed_formats,
+					   num_compressed_formats,
+					   check_errors,
+					   GLEW_OES_compressed_paletted_texture)
+				&& pass;
+		} else {
+			fprintf(stderr,
+				"Unrecognized selection `%s'\n", argv[i]);
+			piglit_report_result(PIGLIT_FAIL);
+		}
+	}
+
+	/* After all of the known formats have been processed, the entire
+	 * format array should be zeroed out.  Any non-zero values are either
+	 * errors or formats from unknown extensions... meaning that the test
+	 * may need to be updated.
+	 */
+	if (do_all) {
+		for (i = 0; i < num_compressed_formats; i++) {
+			if (compressed_formats[i] != 0) {
+				if (log_header) {
+					fprintf(stderr,
+						"Unrecognized compressed "
+						"texture formats:\n");
+					log_header = false;
+				}
+
+				fprintf(stderr, "    0x%04x\n",
+					compressed_formats[i]);
+				pass = false;
+			}
+		}
+	}
+
+	piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
+}