# -*- coding: utf-8 -*-
# All tests that come with piglit, using default settings

import itertools
import os
import os.path as path
import platform
import shlex

from framework.core import *
from framework.exectest import *
from framework.gleantest import *
from framework.glsl_parser_test import GLSLParserTest, add_glsl_parser_test, import_glsl_parser_tests
from framework.shader_test import add_shader_test_dir

# Blacklisted tests are removed from the test profile.
blacklist = [
	]

# Path to tests dir, correct even when not running from the top directory.
testsDir = path.dirname(__file__)

# Find the generated_tests directory, by looking either in
# $PIGLIT_BUILD_DIR (if that environment variable exists) or in the
# parent directory of the directory containing this file.
generatedTestDir = os.path.join(
	os.environ.get(
		'PIGLIT_BUILD_DIR',
		os.path.join(testsDir, '..')),
	'generated_tests')

# Quick wrapper for PlainExecTest for our usual concurrent args.
def plain_test(args):
	return PlainExecTest(shlex.split(args) + ['-auto'])

def add_single_param_test_set(group, name, *params):
    for param in params:
        group[name + '-' + param] = PlainExecTest([name, param, '-auto'])

def add_plain_test(group, args):
	group[args] = PlainExecTest(shlex.split(args) + ['-auto'])

def concurrent_test(args):
	test = PlainExecTest(shlex.split(args) + ['-auto', '-fbo'])
	test.runConcurrent = True
	return test

def add_concurrent_test(group, args):
	group[args] = concurrent_test(args)

# Generate all possible subsets of the given set, including the empty set.
def power_set(s):
        if len(s) == 0:
                return [[]]
        result = []
        for p in power_set(s[:-1]):
                result.append(p)
                result.append(p + [s[-1]])
        return result

######
# Collecting all tests
profile = TestProfile()

try:
	execfile(path.join(testsDir, 'gtf.tests'))
except SystemExit:
	pass

# List of all of the MSAA sample counts we wish to test
MSAA_SAMPLE_COUNTS = (2, 4, 6, 8, 16, 32)

def add_fbo_depthstencil_tests(group, format):
	if format == 'default_fb':
		prefix = ''
	else:
		prefix = 'fbo-'
	group[prefix + 'depthstencil-' + format + '-clear'] = PlainExecTest(['fbo-depthstencil', '-auto', 'clear', format])
	group[prefix + 'depthstencil-' + format + '-readpixels-FLOAT-and-USHORT'] = PlainExecTest(['fbo-depthstencil', '-auto', 'readpixels', format, 'FLOAT-and-USHORT'])
	group[prefix + 'depthstencil-' + format + '-readpixels-24_8'] = PlainExecTest(['fbo-depthstencil', '-auto', 'readpixels', format, '24_8'])
	group[prefix + 'depthstencil-' + format + '-readpixels-32F_24_8_REV'] = PlainExecTest(['fbo-depthstencil', '-auto', 'readpixels', format, '32F_24_8_REV'])
	group[prefix + 'depthstencil-' + format + '-drawpixels-FLOAT-and-USHORT'] = PlainExecTest(['fbo-depthstencil', '-auto', 'drawpixels', format, 'FLOAT-and-USHORT'])
	group[prefix + 'depthstencil-' + format + '-drawpixels-24_8'] = PlainExecTest(['fbo-depthstencil', '-auto', 'drawpixels', format, '24_8'])
	group[prefix + 'depthstencil-' + format + '-drawpixels-32F_24_8_REV'] = PlainExecTest(['fbo-depthstencil', '-auto', 'drawpixels', format, '32F_24_8_REV'])
	group[prefix + 'depthstencil-' + format + '-copypixels'] = PlainExecTest(['fbo-depthstencil', '-auto', 'copypixels', format])
	group[prefix + 'depthstencil-' + format + '-blit'] = PlainExecTest(['fbo-depthstencil', '-auto', 'blit', format])


def add_depthstencil_render_miplevels_tests(group, test_types):
        # Note: the buffer sizes below have been chosen to exercise
        # many possible combinations of buffer alignments on i965.
        for texture_size in (146, 273, 292, 585, 1024):
                for test_type in test_types:
                        test_name = 'depthstencil-render-miplevels {0} {1}'.format(
                                texture_size, test_type)
                        group[test_name] = PlainExecTest(test_name + ' -auto')


glean = Group()
glean['basic'] = GleanTest('basic')
glean['api2'] = GleanTest('api2')
glean['makeCurrent'] = GleanTest('makeCurrent')
glean['blendFunc'] = GleanTest('blendFunc')
glean['bufferObject'] = GleanTest('bufferObject')
glean['depthStencil'] = GleanTest('depthStencil')
glean['fbo'] = GleanTest('fbo')
glean['fpexceptions'] = GleanTest('fpexceptions')
glean['getString'] = GleanTest('getString')
glean['logicOp'] = GleanTest('logicOp')
glean['occluquery'] = GleanTest('occluQry')
glean['orthoPosRandTris'] = GleanTest('orthoPosRandTris')
glean['orthoPosRandRects'] = GleanTest('orthoPosRandRects')
glean['orthoPosTinyQuads'] = GleanTest('orthoPosTinyQuads')
glean['orthoPosHLines'] = GleanTest('orthoPosHLines')
glean['orthoPosVLines'] = GleanTest('orthoPosVLines')
glean['orthoPosPoints'] = GleanTest('orthoPosPoints')
glean['paths'] = GleanTest('paths')
glean['pbo'] = GleanTest('pbo')
glean['polygonOffset'] = GleanTest('polygonOffset')
glean['pixelFormats'] = GleanTest('pixelFormats')
glean['pointAtten'] = GleanTest('pointAtten')
glean['pointSprite'] = GleanTest('pointSprite')
# exactRGBA is not included intentionally, because it's too strict and
# the equivalent functionality is covered by other tests
glean['readPixSanity'] = GleanTest('readPixSanity')
glean['shaderAPI'] = GleanTest('shaderAPI')
glean['stencil2'] = GleanTest('stencil2')
glean['texCombine'] = GleanTest('texCombine')
glean['texCube'] = GleanTest('texCube')
glean['texEnv'] = GleanTest('texEnv')
glean['texgen'] = GleanTest('texgen')
glean['texCombine4'] = GleanTest('texCombine4')
glean['texSwizzle'] = GleanTest('texSwizzle')
glean['texture_srgb'] = GleanTest('texture_srgb')
glean['texUnits'] = GleanTest('texUnits')
glean['vertArrayBGRA'] = GleanTest('vertArrayBGRA')
glean['vertattrib'] = GleanTest('vertattrib')

def add_glsl1(name):
	testname = 'glsl1-' + name
	glean[testname] = GleanTest('glsl1')
	glean[testname].env['PIGLIT_TEST'] = name
execfile(testsDir + '/glean-glsl1.tests')

def add_fp1(name):
	testname = 'fp1-' + name
	glean[testname] = GleanTest('fragProg1')
	glean[testname].env['PIGLIT_TEST'] = name
execfile(testsDir + '/glean-fragProg1.tests')

def add_vp1(name):
	testname = 'vp1-' + name
	glean[testname] = GleanTest('vertProg1')
	glean[testname].env['PIGLIT_TEST'] = name
execfile(testsDir + '/glean-vertProg1.tests')

def add_fbo_formats_tests(path, extension, suffix=''):
	profile.tests[path + '/fbo-generatemipmap-formats' + suffix] = PlainExecTest('fbo-generatemipmap-formats -auto ' + extension)
	profile.tests[path + '/fbo-clear-formats' + suffix] = PlainExecTest('fbo-clear-formats -auto ' + extension)
	profile.tests[path + '/get-renderbuffer-internalformat' + suffix] = concurrent_test('get-renderbuffer-internalformat ' + extension)
	if 'depth' not in extension:
		profile.tests[path + '/fbo-blending-formats' + suffix] = PlainExecTest('fbo-blending-formats -auto ' + extension)
		profile.tests[path + '/fbo-alphatest-formats' + suffix] = PlainExecTest('fbo-alphatest-formats -auto ' + extension)
		profile.tests[path + '/fbo-colormask-formats' + suffix] = PlainExecTest('fbo-colormask-formats -auto ' + extension)

def add_msaa_formats_tests(group, extension):
        for num_samples in MSAA_SAMPLE_COUNTS:
                args = [str(num_samples), extension]
                test_name = ' '.join(['multisample-formats'] + args)
                group[test_name] = PlainExecTest(
                        ['ext_framebuffer_multisample-formats', '-auto']
                        + args)

def add_fbo_generatemipmap_extension(group, extension, name):
	group[name] = PlainExecTest(['fbo-generatemipmap-formats', '-auto',
				     extension])

def add_fbo_clear_extension(group, extension, name):
	group[name] = PlainExecTest(['fbo-clear-formats', '-auto', extension])

def add_fbo_blending_extension(group, extension, name):
	group[name] = PlainExecTest(['fbo-blending-formats', '-auto', extension])

def add_fbo_alphatest_extension(group, extension, name):
	group[name] = PlainExecTest(['fbo-alphatest-formats', '-auto', extension])


def add_fbo_rg(group, format):
	name = "fbo-rg-" + format
	group[name] = PlainExecTest(['fbo-rg', '-auto', format])

security = Group()
add_plain_test(security, 'initialized-texmemory')
add_plain_test(security, 'initialized-fbo')
add_plain_test(security, 'initialized-vbo')


shaders = Group()

def add_getactiveuniform_count(group, name, expected):
	path = 'shaders/'
	group['glsl-getactiveuniform-count: ' + name] = PlainExecTest(['glsl-getactiveuniform-count',
								   '-auto',
								   path + name + '.vert',
								   expected])

add_shader_test_dir(shaders,
                    testsDir + '/shaders',
                    recursive=True)
add_plain_test(shaders, 'activeprogram-bad-program')
add_plain_test(shaders, 'activeprogram-get')
add_plain_test(shaders, 'attribute0')
add_plain_test(shaders, 'createshaderprogram-bad-type')
add_plain_test(shaders, 'createshaderprogram-attached-shaders')
add_plain_test(shaders, 'glsl-arb-fragment-coord-conventions')
add_plain_test(shaders, 'glsl-arb-fragment-coord-conventions-define')
add_plain_test(shaders, 'glsl-bug-22603')
add_plain_test(shaders, 'glsl-bindattriblocation')
add_plain_test(shaders, 'glsl-dlist-getattriblocation')
add_plain_test(shaders, 'glsl-getactiveuniform-array-size')
add_getactiveuniform_count(shaders, 'glsl-getactiveuniform-length', '1')
add_getactiveuniform_count(shaders, 'glsl-getactiveuniform-ftransform', '2')
add_getactiveuniform_count(shaders, 'glsl-getactiveuniform-mvp', '2')
add_plain_test(shaders, 'glsl-getactiveuniform-length')
add_plain_test(shaders, 'glsl-getattriblocation')
add_plain_test(shaders, 'getuniform-01')
add_plain_test(shaders, 'getuniform-02')
add_plain_test(shaders, 'glsl-invalid-asm-01')
add_plain_test(shaders, 'glsl-invalid-asm-02')
add_plain_test(shaders, 'glsl-novertexdata')
add_plain_test(shaders, 'glsl-preprocessor-comments')
add_plain_test(shaders, 'glsl-reload-source')
add_plain_test(shaders, 'glsl-uniform-out-of-bounds')
add_concurrent_test(shaders, 'glsl-uniform-out-of-bounds-2')
add_plain_test(shaders, 'glsl-uniform-update')
add_plain_test(shaders, 'glsl-unused-varying')
add_plain_test(shaders, 'glsl-fs-bug25902')
add_plain_test(shaders, 'glsl-fs-color-matrix')
add_plain_test(shaders, 'glsl-fs-discard-02')
add_plain_test(shaders, 'glsl-fs-exp2')
add_plain_test(shaders, 'glsl-fs-flat-color')
add_plain_test(shaders, 'glsl-fs-fogcolor-statechange')
add_plain_test(shaders, 'glsl-fs-fragcoord')
add_plain_test(shaders, 'glsl-fs-fragcoord-zw-ortho')
add_plain_test(shaders, 'glsl-fs-fragcoord-zw-perspective')
add_plain_test(shaders, 'glsl-fs-loop')
add_plain_test(shaders, 'glsl-fs-loop-nested')
add_plain_test(shaders, 'glsl-fs-pointcoord')
add_plain_test(shaders, 'glsl-fs-raytrace-bug27060')
add_plain_test(shaders, 'glsl-fs-sampler-numbering')
add_plain_test(shaders, 'glsl-fs-shader-stencil-export')
add_plain_test(shaders, 'glsl-fs-sqrt-branch')
shaders['glsl-fs-texturecube'] = PlainExecTest(['glsl-fs-texturecube',
					       '-auto'])
shaders['glsl-fs-texturecube-bias'] = PlainExecTest(['glsl-fs-texturecube',
						    '-auto', '-bias'])
shaders['glsl-fs-texturecube-2'] = PlainExecTest(['glsl-fs-texturecube-2',
						 '-auto'])
shaders['glsl-fs-texturecube-2-bias'] = PlainExecTest(['glsl-fs-texturecube-2',
						      '-auto', '-bias'])
add_plain_test(shaders, 'glsl-fs-textureenvcolor-statechange')
shaders['glsl-fs-texture2drect'] = PlainExecTest(['glsl-fs-texture2drect',
					       '-auto'])
shaders['glsl-fs-texture2drect-proj3'] = PlainExecTest(['glsl-fs-texture2drect',
							'-auto', '-proj3'])
shaders['glsl-fs-texture2drect-proj4'] = PlainExecTest(['glsl-fs-texture2drect',
							'-auto', '-proj4'])
add_plain_test(shaders, 'glsl-fs-user-varying-ff')
add_plain_test(shaders, 'glsl-mat-attribute')
shaders['glsl-max-varyings'] = concurrent_test('glsl-max-varyings')
shaders['glsl-max-varyings >MAX_VARYING_COMPONENTS'] = concurrent_test('glsl-max-varyings --exceed-limits')
add_plain_test(shaders, 'glsl-orangebook-ch06-bump')
add_plain_test(shaders, 'glsl-routing')
add_plain_test(shaders, 'glsl-vs-arrays')
add_plain_test(shaders, 'glsl-vs-normalscale')
add_plain_test(shaders, 'glsl-vs-functions')
add_plain_test(shaders, 'glsl-vs-user-varying-ff')
add_plain_test(shaders, 'glsl-vs-texturematrix-1')
add_plain_test(shaders, 'glsl-vs-texturematrix-2')
add_plain_test(shaders, 'glsl-sin')
add_plain_test(shaders, 'glsl-cos')
add_plain_test(shaders, 'glsl-vs-if-bool')
add_plain_test(shaders, 'glsl-vs-loop')
add_plain_test(shaders, 'glsl-vs-loop-nested')
add_plain_test(shaders, 'glsl-vs-mov-after-deref')
add_plain_test(shaders, 'glsl-vs-mvp-statechange')
add_plain_test(shaders, 'glsl-vs-raytrace-bug26691')
add_plain_test(shaders, 'glsl-vs-statechange-1')
add_plain_test(shaders, 'vp-combined-image-units')
add_plain_test(shaders, 'glsl-derivs')
add_plain_test(shaders, 'glsl-deriv-varyings')
add_plain_test(shaders, 'glsl-fwidth')
add_plain_test(shaders, 'glsl-lod-bias')
add_plain_test(shaders, 'vp-ignore-input')
add_plain_test(shaders, 'glsl-empty-vs-no-fs')
add_plain_test(shaders, 'glsl-useprogram-displaylist')
add_plain_test(shaders, 'glsl-vs-point-size')
add_plain_test(shaders, 'glsl-light-model')
add_plain_test(shaders, 'glsl-link-bug30552')
add_plain_test(shaders, 'glsl-link-bug38015')
add_plain_test(shaders, 'glsl-link-empty-prog-01')
add_plain_test(shaders, 'glsl-link-empty-prog-02')
shaders['GLSL link single global initializer, 2 shaders'] = concurrent_test('glsl-link-test shaders/glsl-link-initializer-01a.vert shaders/glsl-link-initializer-01b.vert pass')
shaders['GLSL link matched global initializer, 2 shaders'] = concurrent_test('glsl-link-test shaders/glsl-link-initializer-01c.vert shaders/glsl-link-initializer-01d.vert pass')
shaders['GLSL link mismatched global initializer, 2 shaders'] = concurrent_test('glsl-link-test shaders/glsl-link-initializer-01b.vert shaders/glsl-link-initializer-01d.vert fail')
shaders['GLSL link mismatched global initializer, 3 shaders'] = concurrent_test('glsl-link-test shaders/glsl-link-initializer-01a.vert shaders/glsl-link-initializer-01b.vert shaders/glsl-link-initializer-01c.vert fail')
shaders['GLSL link mismatched global const initializer'] = concurrent_test('glsl-link-test shaders/glsl-link-initializer-02a.vert shaders/glsl-link-initializer-02b.vert fail')
shaders['GLSL link two programs, global initializer'] = concurrent_test('glsl-link-initializer-03')
shaders['GLSL link matched global initializer expression'] = concurrent_test('glsl-link-test shaders/glsl-link-initializer-05a.vert shaders/glsl-link-initializer-05b.vert fail')
shaders['GLSL link mismatched global initializer expression'] = concurrent_test('glsl-link-test shaders/glsl-link-initializer-06a.vert shaders/glsl-link-initializer-06b.vert fail')
shaders['GLSL link mismatched invariant'] = concurrent_test('glsl-link-test shaders/glsl-link-invariant-01a.vert shaders/glsl-link-invariant-01b.vert fail')
shaders['GLSL link mismatched centroid'] = concurrent_test('glsl-link-test shaders/glsl-link-centroid-01a.vert shaders/glsl-link-centroid-01b.vert fail')
shaders['GLSL link array-of-struct-of-array'] = concurrent_test('glsl-link-test shaders/glsl-link-struct-array.frag pass')
add_plain_test(shaders, 'glsl-max-vertex-attrib')
add_plain_test(shaders, 'glsl-kwin-blur-1')
add_plain_test(shaders, 'glsl-kwin-blur-2')
add_plain_test(shaders, 'gpu_shader4_attribs')
add_plain_test(shaders, 'link-mismatch-layout-01')
add_plain_test(shaders, 'link-mismatch-layout-02')
add_plain_test(shaders, 'link-mismatch-layout-03')
add_plain_test(shaders, 'link-unresolved-function')
add_plain_test(shaders, 'sso-simple')
add_plain_test(shaders, 'sso-uniforms-01')
add_plain_test(shaders, 'sso-uniforms-02')
add_plain_test(shaders, 'sso-user-varying-01')
add_plain_test(shaders, 'sso-user-varying-02')
add_plain_test(shaders, 'useprogram-flushverts-1')
add_plain_test(shaders, 'useprogram-flushverts-2')
add_plain_test(shaders, 'useprogram-inside-begin')
add_plain_test(shaders, 'useprogram-refcount-1')
add_plain_test(shaders, 'useshaderprogram-bad-type')
add_plain_test(shaders, 'useshaderprogram-bad-program')
add_plain_test(shaders, 'useshaderprogram-flushverts-1')

def add_vpfpgeneric(group, name):
	group[name] = PlainExecTest(['vpfp-generic', '-auto', testsDir + '/shaders/generic/' + name + '.vpfp'])

glx = Group()
add_plain_test(glx, 'glx-copy-sub-buffer')
add_plain_test(glx, 'glx-destroycontext-1')
add_plain_test(glx, 'glx-destroycontext-2')
add_plain_test(glx, 'glx-dont-care-mask')
add_plain_test(glx, 'glx-close-display')
add_plain_test(glx, 'glx-fbconfig-sanity')
glx['glx-fbconfig-sanity'].runConcurrent = True
add_plain_test(glx, 'glx-fbconfig-compliance')
glx['glx-fbconfig-compliance'].runConcurrent = True
add_plain_test(glx, 'glx-fbo-binding')
add_plain_test(glx, 'glx-multi-context-ib-1')
add_plain_test(glx, 'glx-multithread')
add_plain_test(glx, 'glx-multithread-makecurrent-1')
add_plain_test(glx, 'glx-multithread-makecurrent-2')
add_plain_test(glx, 'glx-multithread-makecurrent-3')
add_plain_test(glx, 'glx-multithread-makecurrent-4')
add_plain_test(glx, 'glx-shader-sharing')
add_plain_test(glx, 'glx-swap-exchange')
glx['glx-swap-event_event'] = PlainExecTest(['glx-swap-event', '-auto', '--event'])
glx['glx-swap-event_async'] = PlainExecTest(['glx-swap-event', '-auto', '--async'])
glx['glx-swap-event_interval'] = PlainExecTest(['glx-swap-event', '-auto', '--interval'])
add_plain_test(glx, 'glx-swap-pixmap')
add_plain_test(glx, 'glx-swap-pixmap-bad')
add_plain_test(glx, 'glx-swap-singlebuffer')
add_plain_test(glx, 'glx-make-current')
add_plain_test(glx, 'glx-make-glxdrawable-current')
add_plain_test(glx, 'glx-pixmap-life')
glx['glx-pixmap-life'].runConcurrent = True
add_plain_test(glx, 'glx-pixmap13-life')
glx['glx-pixmap13-life'].runConcurrent = True
add_plain_test(glx, 'glx-pixmap-multi')
glx['glx-pixmap-multi'].runConcurrent = True
add_plain_test(glx, 'glx-tfp')
add_plain_test(glx, 'glx-visuals-depth')
add_concurrent_test(glx, 'glx-visuals-depth -pixmap')
add_plain_test(glx, 'glx-visuals-stencil')
add_concurrent_test(glx, 'glx-visuals-stencil -pixmap')
add_plain_test(glx, 'glx-window-life')
glx['glx-window-life'].runConcurrent = True
add_plain_test(glx, 'glx-pixmap-crosscheck')
glx['glx-pixmap-crosscheck'].runConcurrent = True
glx['glx-query-drawable-GLXWINDOW-GLX_WIDTH'] = PlainExecTest(['glx-query-drawable', '-auto', '--attr=GLX_WIDTH', "--type=GLXWINDOW"])
glx['glx-query-drawable-GLXWINDOW-GLX_HEIGHT'] = PlainExecTest(['glx-query-drawable', '-auto', '--attr=GLX_HEIGHT', "--type=GLXWINDOW"])
glx['glx-query-drawable-GLXPIXMAP-GLX_WIDTH'] = PlainExecTest(['glx-query-drawable', '-auto', '--attr=GLX_WIDTH', "--type=GLXPIXMAP"])
glx['glx-query-drawable-GLXPIXMAP-GLX_HEIGHT'] = PlainExecTest(['glx-query-drawable', '-auto', '--attr=GLX_HEIGHT', "--type=GLXPIXMAP"])
glx['glx-query-drawable-GLXPBUFFER-GLX_WIDTH'] = PlainExecTest(['glx-query-drawable', '-auto', '--attr=GLX_WIDTH', "--type=GLXPBUFFER"])
glx['glx-query-drawable-GLXPBUFFER-GLX_HEIGHT'] = PlainExecTest(['glx-query-drawable', '-auto', '--attr=GLX_HEIGHT', "--type=GLXPBUFFER"])
glx['glx-query-drawable-GLX_WIDTH'] = PlainExecTest(['glx-query-drawable', '-auto', '--attr=GLX_WIDTH', "--type=WINDOW"])
glx['glx-query-drawable-GLX_HEIGHT'] = PlainExecTest(['glx-query-drawable', '-auto', '--attr=GLX_HEIGHT', "--type=WINDOW"])
glx['glx-query-drawable-GLXBadDrawable'] = PlainExecTest(['glx-query-drawable', '-auto', '--bad-drawable'])
glx['extension string sanity'] = PlainExecTest(['glx-string-sanity'])
glx['extension string sanity'].runConcurrent = True

import_context = Group();
glx['GLX_EXT_import_context'] = import_context
import_context['free context'] = PlainExecTest(['glx-free-context'])
import_context['get context ID'] = PlainExecTest(['glx-get-context-id'])
import_context['get current display'] = PlainExecTest(['glx-get-current-display-ext'])
import_context['imported context has same context ID'] = PlainExecTest(['glx-import-context-has-same-context-id'])
import_context['import context, multi process'] = PlainExecTest(['glx-import-context-multi-process'])
import_context['import context, single process'] = PlainExecTest(['glx-import-context-single-process'])
import_context['make current, multi process'] = PlainExecTest(['glx-make-current-multi-process'])
import_context['make current, single process'] = PlainExecTest(['glx-make-current-single-process'])
import_context['query context info'] = PlainExecTest(['glx-query-context-info-ext'])

create_context = Group();
glx['GLX_ARB_create_context'] = create_context
create_context['current with no framebuffer'] = concurrent_test('glx-create-context-current-no-framebuffer')
create_context['default major version'] = concurrent_test('glx-create-context-default-major-version')
create_context['default minor version'] = concurrent_test('glx-create-context-default-minor-version')
create_context['invalid attribute'] = concurrent_test('glx-create-context-invalid-attribute')
create_context['invalid flag'] = concurrent_test('glx-create-context-invalid-flag')
create_context['forward-compatible flag with pre-3.0'] = concurrent_test('glx-create-context-invalid-flag-forward-compatible')
create_context['invalid OpenGL version'] = concurrent_test('glx-create-context-invalid-gl-version')
create_context['invalid render type'] = concurrent_test('glx-create-context-invalid-render-type')
create_context['color-index render type with 3.0'] = concurrent_test('glx-create-context-invalid-render-type-color-index')
create_context['empty attribute list'] = concurrent_test('glx-create-context-valid-attribute-empty')
create_context['NULL attribute list'] = concurrent_test('glx-create-context-valid-attribute-null')
create_context['forward-compatible flag with 3.0'] = concurrent_test('glx-create-context-valid-flag-forward-compatible')

create_context_profile = Group();
glx['GLX_ARB_create_context_profile'] = create_context_profile
create_context_profile['3.2 core profile required'] = concurrent_test('glx-create-context-core-profile')
create_context_profile['invalid profile'] = concurrent_test('glx-create-context-invalid-profile')
create_context_profile['pre-GL3.2 profile'] = concurrent_test('glx-create-context-pre-GL32-profile')

create_context_robustness = Group();
glx['GLX_ARB_create_context_robustness'] = create_context_robustness
create_context_robustness['invalid reset notification strategy'] = concurrent_test('glx-create-context-invalid-reset-strategy')
create_context_robustness['require GL_ARB_robustness'] = concurrent_test('glx-create-context-require-robustness')

create_context_es2_profile = Group();
glx['GLX_EXT_create_context_es2_profile'] = create_context_es2_profile
create_context_es2_profile['indirect rendering ES2 profile'] = concurrent_test('glx-create-context-indirect-es2-profile')
create_context_es2_profile['invalid OpenGL ES version'] = concurrent_test('glx-create-context-invalid-es-version')

oml_sync_control = Group();
glx['GLX_OML_sync_control'] = oml_sync_control
oml_sync_control['swapbuffersmsc-divisor-zero'] = concurrent_test('glx-oml-sync-control-swapbuffersmsc-divisor-zero')
oml_sync_control['swapbuffersmsc-return'] = concurrent_test('glx-oml-sync-control-swapbuffersmsc-return')
oml_sync_control['swapbuffersmsc-return swap_interval 0'] = concurrent_test('glx-oml-sync-control-swapbuffersmsc-return 0')
oml_sync_control['swapbuffersmsc-return swap_interval 1'] = concurrent_test('glx-oml-sync-control-swapbuffersmsc-return 1')
oml_sync_control['waitformsc'] = concurrent_test('glx-oml-sync-control-waitformsc')

def texwrap_test(args):
	test = PlainExecTest(['texwrap', '-fbo', '-auto'] + args)
	test.runConcurrent = True
	return test

def add_texwrap_target_tests(group, target):
	group['texwrap ' + target] = texwrap_test([target, 'GL_RGBA8'])
	group['texwrap ' + target + ' bordercolor'] = texwrap_test([target, 'GL_RGBA8', 'bordercolor'])
	group['texwrap ' + target + ' proj'] = texwrap_test([target, 'GL_RGBA8', 'proj'])
	group['texwrap ' + target + ' proj bordercolor'] = texwrap_test([target, 'GL_RGBA8', 'proj', 'bordercolor'])

def add_texwrap_format_tests(group, ext = '', suffix = ''):
	args = [] if ext == '' else [ext]
	group['texwrap formats' + suffix] = texwrap_test(args)
	group['texwrap formats' + suffix + ' bordercolor'] = texwrap_test(args + ['bordercolor'])
	group['texwrap formats' + suffix + ' bordercolor-swizzled'] = texwrap_test(args + ['bordercolor', 'swizzled'])

def add_fbo_depth_tests(group, format):
	group['fbo-depth-' + format + '-tex1d'] = PlainExecTest(['fbo-depth-tex1d', '-auto', format])
	group['fbo-depth-' + format + '-clear'] = PlainExecTest(['fbo-depth', '-auto', 'clear', format])
	group['fbo-depth-' + format + '-readpixels'] = PlainExecTest(['fbo-depth', '-auto', 'readpixels', format])
	group['fbo-depth-' + format + '-drawpixels'] = PlainExecTest(['fbo-depth', '-auto', 'drawpixels', format])
	group['fbo-depth-' + format + '-copypixels'] = PlainExecTest(['fbo-depth', '-auto', 'copypixels', format])
	group['fbo-depth-' + format + '-blit'] = PlainExecTest(['fbo-depth', '-auto', 'blit', format])

def add_fbo_stencil_tests(group, format):
	group['fbo-stencil-' + format + '-clear'] = PlainExecTest(['fbo-stencil', '-auto', 'clear', format])
	group['fbo-stencil-' + format + '-readpixels'] = PlainExecTest(['fbo-stencil', '-auto', 'readpixels', format])
	group['fbo-stencil-' + format + '-drawpixels'] = PlainExecTest(['fbo-stencil', '-auto', 'drawpixels', format])
	group['fbo-stencil-' + format + '-copypixels'] = PlainExecTest(['fbo-stencil', '-auto', 'copypixels', format])
	group['fbo-stencil-' + format + '-blit'] = PlainExecTest(['fbo-stencil', '-auto', 'blit', format])

spec = Group()

gl11 = Group()
spec['!OpenGL 1.1'] = gl11
add_texwrap_target_tests(gl11, '1D')
add_texwrap_target_tests(gl11, '2D')
add_texwrap_format_tests(gl11)
gl11['copyteximage 1D'] = PlainExecTest(['copyteximage', '-auto', '1D'])
gl11['copyteximage 2D'] = PlainExecTest(['copyteximage', '-auto', '2D'])
add_plain_test(gl11, 'drawbuffer-modes')
add_plain_test(gl11, 'fdo10370')
add_plain_test(gl11, 'fdo23489')
add_plain_test(gl11, 'fdo23670-depth_test')
add_plain_test(gl11, 'fdo23670-drawpix_stencil')
add_plain_test(gl11, 'r300-readcache')
add_plain_test(gl11, 'tri-tex-crash')
add_plain_test(gl11, 'vbo-buffer-unmap')
add_plain_test(gl11, 'array-stride')
add_plain_test(gl11, 'clear-accum')
add_concurrent_test(gl11, 'clipflat')
add_plain_test(gl11, 'copypixels-draw-sync')
add_plain_test(gl11, 'copypixels-sync')
add_plain_test(gl11, 'degenerate-prims')
add_plain_test(gl11, 'depthfunc')
add_plain_test(gl11, 'depthrange-clear')
add_plain_test(gl11, 'dlist-clear')
add_plain_test(gl11, 'dlist-color-material')
add_plain_test(gl11, 'dlist-fdo3129-01')
add_plain_test(gl11, 'dlist-fdo3129-02')
add_plain_test(gl11, 'dlist-fdo31590')
add_plain_test(gl11, 'draw-arrays-colormaterial')
add_plain_test(gl11, 'draw-copypixels-sync')
add_concurrent_test(gl11, 'draw-pixel-with-texture')
add_plain_test(gl11, 'draw-pixels')
add_concurrent_test(gl11, 'drawpix-z')
add_plain_test(gl11, 'fog-modes')
add_plain_test(gl11, 'fragment-center')
add_fbo_depthstencil_tests(gl11, 'default_fb')
add_plain_test(gl11, 'geterror-invalid-enum')
add_plain_test(gl11, 'geterror-inside-begin')
add_concurrent_test(gl11, 'glinfo')
add_plain_test(gl11, 'hiz')
add_plain_test(gl11, 'infinite-spot-light')
add_plain_test(gl11, 'line-aa-width')
add_plain_test(gl11, 'linestipple')
add_plain_test(gl11, 'longprim')
add_concurrent_test(gl11, 'masked-clear')
add_plain_test(gl11, 'point-line-no-cull')
add_plain_test(gl11, 'polygon-mode')
add_concurrent_test(gl11, 'polygon-mode-offset')
add_concurrent_test(gl11, 'push-pop-texture-state')
add_concurrent_test(gl11, 'quad-invariance')
add_plain_test(gl11, 'read-front')
add_concurrent_test(gl11, 'readpix-z')
add_plain_test(gl11, 'roundmode-getintegerv')
add_plain_test(gl11, 'roundmode-pixelstore')
add_plain_test(gl11, 'scissor-bitmap')
add_plain_test(gl11, 'scissor-clear')
add_plain_test(gl11, 'scissor-copypixels')
add_plain_test(gl11, 'scissor-depth-clear')
add_plain_test(gl11, 'scissor-many')
add_plain_test(gl11, 'scissor-offscreen')
add_concurrent_test(gl11, 'scissor-polygon')
add_plain_test(gl11, 'scissor-stencil-clear')
gl11['GL_SELECT - no test function'] = PlainExecTest(['select', 'gl11'])
gl11['GL_SELECT - depth-test enabled'] = PlainExecTest(['select', 'depth'])
gl11['GL_SELECT - stencil-test enabled'] = PlainExecTest(['select', 'stencil'])
gl11['GL_SELECT - alpha-test enabled'] = PlainExecTest(['select', 'alpha'])
gl11['GL_SELECT - scissor-test enabled'] = PlainExecTest(['select', 'scissor'])
add_plain_test(gl11, 'stencil-drawpixels')
add_plain_test(gl11, 'texgen')
add_plain_test(gl11, 'two-sided-lighting')
add_plain_test(gl11, 'user-clip')
add_plain_test(gl11, 'varray-disabled')
add_plain_test(gl11, 'windowoverlap')
add_plain_test(gl11, 'copyteximage-border')
add_plain_test(gl11, 'copyteximage-clipping')
add_plain_test(gl11, 'copytexsubimage')
add_plain_test(gl11, 'getteximage-formats')
add_plain_test(gl11, 'getteximage-luminance')
add_plain_test(gl11, 'getteximage-simple')
gl11['incomplete-texture-fixed'] = concurrent_test('incomplete-texture -auto fixed')
add_plain_test(gl11, 'max-texture-size')
add_concurrent_test(gl11, 'max-texture-size-level')
add_concurrent_test(gl11, 'proxy-texture')
add_concurrent_test(gl11, 'sized-texture-format-channels')
add_plain_test(gl11, 'streaming-texture-leak')
add_plain_test(gl11, 'texredefine')
add_plain_test(gl11, 'texsubimage')
add_plain_test(gl11, 'texture-al')
add_concurrent_test(gl11, 'triangle-guardband-viewport')
add_concurrent_test(gl11, 'getteximage-targets 1D')
add_concurrent_test(gl11, 'getteximage-targets 2D')

gl10 = Group()
spec['!OpenGL 1.0'] = gl10
add_concurrent_test(gl10, 'gl-1.0-beginend-coverage')
add_concurrent_test(gl10, 'gl-1.0-edgeflag')
add_concurrent_test(gl10, 'gl-1.0-edgeflag-quads')

gl12 = Group()
spec['!OpenGL 1.2'] = gl12
add_texwrap_target_tests(gl12, '3D')
gl12['copyteximage 3D'] = PlainExecTest(['copyteximage', '-auto', '3D'])
add_plain_test(gl12, 'crash-texparameter-before-teximage')
add_plain_test(gl12, 'draw-elements-vs-inputs')
add_plain_test(gl12, 'two-sided-lighting-separate-specular')
add_plain_test(gl12, 'levelclamp')
add_plain_test(gl12, 'lodclamp')
add_plain_test(gl12, 'lodclamp-between')
add_plain_test(gl12, 'lodclamp-between-max')
add_plain_test(gl12, 'mipmap-setup')
add_plain_test(gl12, 'tex-skipped-unit')
add_plain_test(gl12, 'tex3d')
add_plain_test(gl12, 'tex3d-maxsize')
add_plain_test(gl12, 'teximage-errors')
add_plain_test(gl12, 'texture-packed-formats')
add_concurrent_test(gl12, 'getteximage-targets 3D')

gl13 = Group()
spec['!OpenGL 1.3'] = gl13
add_plain_test(gl13, 'texunits')
add_plain_test(gl13, 'tex-border-1')
add_concurrent_test(gl13, 'tex3d-depth1')

gl14 = Group()
spec['!OpenGL 1.4'] = gl14
add_plain_test(gl14, 'fdo25614-genmipmap')
add_plain_test(gl14, 'tex1d-2dborder')
add_plain_test(gl14, 'blendminmax')
add_plain_test(gl14, 'blendsquare')
add_plain_test(gl14, 'copy-pixels')
add_plain_test(gl14, 'draw-batch')
add_plain_test(gl14, 'stencil-wrap')
add_plain_test(gl14, 'triangle-rasterization')
gl14['triangle-rasterization-fbo'] = PlainExecTest(['triangle-rasterization', '-auto', '-use_fbo'])
add_plain_test(gl14, 'triangle-rasterization-overdraw')
gl14['tex-miplevel-selection'] = PlainExecTest(['tex-miplevel-selection', '-auto', '-nobias', '-nolod'])
gl14['tex-miplevel-selection-lod'] = PlainExecTest(['tex-miplevel-selection', '-auto', '-nobias'])
gl14['tex-miplevel-selection-lod-bias'] = PlainExecTest(['tex-miplevel-selection', '-auto'])

gl15 = Group()
spec['!OpenGL 1.5'] = gl15
add_plain_test(gl15, 'draw-elements')
gl15['draw-elements-user'] = PlainExecTest(['draw-elements', '-auto', 'user'])
add_plain_test(gl15, 'draw-vertices')
gl15['draw-vertices-user'] = PlainExecTest(['draw-vertices', '-auto', 'user'])
add_plain_test(gl15, 'isbufferobj')
add_plain_test(gl15, 'depth-tex-compare')

gl20 = Group()
spec['!OpenGL 2.0'] = gl20
add_concurrent_test(gl20, 'attribs')
add_concurrent_test(gl20, 'gl-2.0-edgeflag')
add_plain_test(gl20, 'getattriblocation-conventional')
add_plain_test(gl20, 'clip-flag-behavior')
add_concurrent_test(gl20, 'vertex-program-two-side enabled front back front2 back2')
add_concurrent_test(gl20, 'vertex-program-two-side enabled front back front2')
add_concurrent_test(gl20, 'vertex-program-two-side enabled front back back2')
add_concurrent_test(gl20, 'vertex-program-two-side enabled front back')
add_concurrent_test(gl20, 'vertex-program-two-side enabled front front2 back2')
add_concurrent_test(gl20, 'vertex-program-two-side enabled front front2')
add_concurrent_test(gl20, 'vertex-program-two-side enabled front back2')
add_concurrent_test(gl20, 'vertex-program-two-side enabled front')
add_concurrent_test(gl20, 'vertex-program-two-side enabled back front2 back2')
add_concurrent_test(gl20, 'vertex-program-two-side enabled back front2')
add_concurrent_test(gl20, 'vertex-program-two-side enabled back back2')
add_concurrent_test(gl20, 'vertex-program-two-side enabled back')
add_concurrent_test(gl20, 'vertex-program-two-side enabled front2 back2')
add_concurrent_test(gl20, 'vertex-program-two-side enabled front2')
add_concurrent_test(gl20, 'vertex-program-two-side enabled back2')
add_concurrent_test(gl20, 'vertex-program-two-side enabled')
add_concurrent_test(gl20, 'vertex-program-two-side front back front2 back2')
add_concurrent_test(gl20, 'vertex-program-two-side front back front2')
add_concurrent_test(gl20, 'vertex-program-two-side front back back2')
add_concurrent_test(gl20, 'vertex-program-two-side front back')
add_concurrent_test(gl20, 'vertex-program-two-side front front2 back2')
add_concurrent_test(gl20, 'vertex-program-two-side front front2')
add_concurrent_test(gl20, 'vertex-program-two-side front back2')
add_concurrent_test(gl20, 'vertex-program-two-side front')
add_concurrent_test(gl20, 'vertex-program-two-side back front2 back2')
add_concurrent_test(gl20, 'vertex-program-two-side back front2')
add_concurrent_test(gl20, 'vertex-program-two-side back back2')
add_concurrent_test(gl20, 'vertex-program-two-side back')
add_concurrent_test(gl20, 'vertex-program-two-side front2 back2')
add_concurrent_test(gl20, 'vertex-program-two-side front2')
add_concurrent_test(gl20, 'vertex-program-two-side back2')
add_concurrent_test(gl20, 'vertex-program-two-side')
add_plain_test(gl20, 'clear-varray-2.0')
add_plain_test(gl20, 'early-z')
add_plain_test(gl20, 'occlusion-query-discard')
add_plain_test(gl20, 'stencil-twoside')
add_plain_test(gl20, 'vs-point_size-zero')
add_plain_test(gl20, 'depth-tex-modes-glsl')
add_plain_test(gl20, 'fragment-and-vertex-texturing')
gl20['incomplete-texture-glsl'] = concurrent_test('incomplete-texture -auto glsl')
add_plain_test(gl20, 'tex3d-npot')

gl21 = Group()
spec['!OpenGL 2.1'] = gl21
gl21['minmax'] = concurrent_test('gl-2.1-minmax')

gl30 = Group()
spec['!OpenGL 3.0'] = gl30
gl30['attribs'] = concurrent_test('attribs GL3')
add_concurrent_test(gl30, 'bindfragdata-invalid-parameters')
add_concurrent_test(gl30, 'bindfragdata-link-error')
add_concurrent_test(gl30, 'bindfragdata-nonexistent-variable')
add_concurrent_test(gl30, 'clearbuffer-depth')
add_concurrent_test(gl30, 'clearbuffer-depth-stencil')
add_plain_test(gl30, 'clearbuffer-display-lists')
add_concurrent_test(gl30, 'clearbuffer-invalid-drawbuffer')
add_concurrent_test(gl30, 'clearbuffer-invalid-buffer')
add_concurrent_test(gl30, 'clearbuffer-mixed-format')
add_concurrent_test(gl30, 'clearbuffer-stencil')
add_concurrent_test(gl30, 'genmipmap-errors')
add_concurrent_test(gl30, 'getfragdatalocation')
add_concurrent_test(gl30, 'integer-errors')
gl30['minmax'] = concurrent_test('gl-3.0-minmax')
add_concurrent_test(gl30, 'gl-3.0-required-sized-texture-formats')
add_concurrent_test(gl30, 'gl-3.0-required-renderbuffer-attachment-formats')
add_concurrent_test(gl30, 'gl-3.0-required-texture-attachment-formats')
add_concurrent_test(gl30, 'gl-3.0-texture-integer')
add_plain_test(gl30, 'gl30basic')
add_plain_test(gl30, 'array-depth-roundtrip')
add_plain_test(gl30, 'depth-cube-map')
add_plain_test(gl30, 'sampler-cube-shadow')

gl31 = Group()
spec['!OpenGL 3.1'] = gl31
gl31['genned-names'] = concurrent_test('gl-3.1-genned-names')
gl31['minmax'] = concurrent_test('gl-3.1-minmax')
for subtest in ['generated', 'written', 'flush']:
        cmdline = 'primitive-restart-xfb {0}'.format(subtest)
        gl31[cmdline] = concurrent_test('gl-3.1-' + cmdline)

# Group spec/glsl-es-1.00
spec['glsl-es-1.00'] = Group()
import_glsl_parser_tests(spec['glsl-es-1.00'],
			 os.path.join(testsDir, 'spec', 'glsl-es-1.00'),
			 ['compiler'])
spec['glsl-es-1.00']['execution'] = Group()
add_shader_test_dir(spec['glsl-es-1.00']['execution'],
			 os.path.join(testsDir, 'spec', 'glsl-es-1.00', 'execution'),
			 recursive=True)

# Group spec/glsl-1.10
spec['glsl-1.10'] = Group()
import_glsl_parser_tests(spec['glsl-1.10'],
			 os.path.join(testsDir, 'spec', 'glsl-1.10'),
			 ['preprocessor', 'compiler'])
spec['glsl-1.10']['linker'] = Group()
add_shader_test_dir(spec['glsl-1.10']['linker'],
	            os.path.join(testsDir, 'spec', 'glsl-1.10', 'linker'),
		    recursive=True)
spec['glsl-1.10']['execution'] = Group()
add_shader_test_dir(spec['glsl-1.10']['execution'],
	            os.path.join(testsDir, 'spec', 'glsl-1.10', 'execution'),
		    recursive=True)
add_concurrent_test(spec['glsl-1.10']['execution'], 'glsl-render-after-bad-attach')
spec['glsl-1.10']['execution']['clipping'] = Group()
for mode in ['fixed', 'pos_clipvert', 'clipvert_pos']:
	cmdline = 'clip-plane-transformation ' + mode
	spec['glsl-1.10']['execution']['clipping'][cmdline] = concurrent_test(cmdline)
spec['glsl-1.10']['execution']['varying-packing'] = Group()
for type in ['int', 'uint', 'float', 'vec2', 'vec3', 'vec4', 'ivec2', 'ivec3',
             'ivec4', 'uvec2', 'uvec3', 'uvec4', 'mat2', 'mat3', 'mat4',
             'mat2x3', 'mat2x4', 'mat3x2', 'mat3x4', 'mat4x2', 'mat4x3']:
        for arrayspec in ['array', 'separate']:
                cmdline = 'simple {0} {1}'.format(type, arrayspec)
                spec['glsl-1.10']['execution']['varying-packing'][cmdline] = \
                    concurrent_test('varying-packing-' + cmdline)

spec['glsl-1.10']['api'] = Group()
add_concurrent_test(spec['glsl-1.10']['api'], 'getactiveattrib 110');

# Group spec/glsl-1.20
spec['glsl-1.20'] = Group()
import_glsl_parser_tests(spec['glsl-1.20'],
			 os.path.join(testsDir, 'spec', 'glsl-1.20'),
			 ['preprocessor', 'compiler'])
spec['glsl-1.20']['execution'] = Group()
add_shader_test_dir(spec['glsl-1.20']['execution'],
	            os.path.join(testsDir, 'spec', 'glsl-1.20', 'execution'),
		    recursive=True)

def add_recursion_test(group, name):
	# When the recursion tests fail it is usually because the GLSL
	# compiler tries to recursively inline the function until the process
	# runs out of stack or the system runs out of memory.  Run the test
	# with a low rlimit to (hopefully) avoid having the test adversely
	# affect the rest of the system.  This is especially important since
	# there may be other tests running in parallel.
	#
	# This may cause false negatives on systems that map the framebuffer
	# into the processes address space.  This happens on X with DRI1 based
	# drivers, for example.
	group[name] = PlainExecTest(['recursion', '-auto', '-rlimit', '268435456', name])

rec = Group()
spec['glsl-1.20']['recursion'] = rec
add_recursion_test(rec, 'simple')
add_recursion_test(rec, 'unreachable')
add_recursion_test(rec, 'unreachable-constant-folding')
add_recursion_test(rec, 'indirect')
add_recursion_test(rec, 'indirect-separate')
add_recursion_test(rec, 'indirect-complex')
add_recursion_test(rec, 'indirect-complex-separate')

spec['glsl-1.20']['api'] = Group()
add_concurrent_test(spec['glsl-1.20']['api'], 'getactiveattrib 120');


# Group spec/glsl-1.30
spec['glsl-1.30'] = Group()
import_glsl_parser_tests(spec['glsl-1.30'],
			 os.path.join(testsDir, 'spec', 'glsl-1.30'),
			 ['preprocessor', 'compiler'])
spec['glsl-1.30']['execution'] = Group()

textureSize_samplers_130 = ['sampler1D', 'sampler2D', 'sampler3D', 'samplerCube', 'sampler1DShadow', 'sampler2DShadow', 'samplerCubeShadow', 'sampler1DArray', 'sampler2DArray', 'sampler1DArrayShadow', 'sampler2DArrayShadow', 'isampler1D', 'isampler2D', 'isampler3D', 'isamplerCube', 'isampler1DArray', 'isampler2DArray', 'usampler1D', 'usampler2D', 'usampler3D', 'usamplerCube', 'usampler1DArray', 'usampler2DArray']
for stage in ['vs', 'fs']:
	# textureSize():
	for sampler in textureSize_samplers_130:
		spec['glsl-1.30/execution/textureSize/' + stage + '-textureSize-' + sampler] = concurrent_test('textureSize ' + stage + ' ' + sampler)
	# texelFetch():
	for sampler in ['sampler1D', 'sampler2D', 'sampler3D', 'sampler1DArray', 'sampler2DArray', 'isampler1D', 'isampler2D', 'isampler3D', 'isampler1DArray', 'isampler2DArray', 'usampler1D', 'usampler2D', 'usampler3D', 'usampler1DArray', 'usampler2DArray']:
		spec['glsl-1.30/execution/texelFetch/' + stage + '-texelFetch-' + sampler] = concurrent_test('texelFetch ' + stage + ' ' + sampler)
		spec['glsl-1.30/execution/texelFetchOffset/' + stage + '-' + sampler] = concurrent_test('texelFetch offset ' + stage + ' ' + sampler)
	# texelFetch() with EXT_texture_swizzle mode "b0r1":
	for type in ['i', 'u', '']:
		spec['glsl-1.30/execution/texelFetch/' + stage + '-texelFetch-' + type + 'sampler2DArray-swizzle'] = concurrent_test('texelFetch ' + stage + ' ' + type + 'sampler2DArray b0r1')

add_plain_test(spec['glsl-1.30']['execution'], 'fs-texelFetch-2D')
add_plain_test(spec['glsl-1.30']['execution'], 'fs-texelFetchOffset-2D')
add_shader_test_dir(spec['glsl-1.30']['execution'],
	            os.path.join(testsDir, 'spec', 'glsl-1.30', 'execution'),
		    recursive=True)
spec['glsl-1.30']['linker'] = Group()
spec['glsl-1.30']['linker']['clipping'] = Group()
add_plain_test(spec['glsl-1.30']['linker']['clipping'], 'mixing-clip-distance-and-clip-vertex-disallowed')
add_plain_test(spec['glsl-1.30']['execution']['clipping'], 'max-clip-distances')
for arg in ['vs_basic', 'vs_xfb', 'vs_fbo', 'fs_basic', 'fs_fbo']:
	test_name = 'isinf-and-isnan ' + arg
	spec['glsl-1.30']['execution'][test_name] = PlainExecTest(test_name + ' -auto')
spec['glsl-1.30']['execution']['clipping']['clip-plane-transformation pos'] = \
    concurrent_test('clip-plane-transformation pos')
spec['glsl-1.30']['texel-offset-limits'] = concurrent_test('glsl-1.30-texel-offset-limits')
add_concurrent_test(spec['glsl-1.30']['execution'], 'fs-discard-exit-2')
add_concurrent_test(spec['glsl-1.30']['execution'], 'vertexid-beginend')
add_concurrent_test(spec['glsl-1.30']['execution'], 'vertexid-drawarrays')
add_concurrent_test(spec['glsl-1.30']['execution'], 'vertexid-drawelements')
add_concurrent_test(spec['glsl-1.30']['execution'], 'fs-execution-ordering')

spec['glsl-1.30']['api'] = Group()
add_concurrent_test(spec['glsl-1.30']['api'], 'getactiveattrib 130');

# Group spec/glsl-1.40
spec['glsl-1.40'] = Group()
import_glsl_parser_tests(spec['glsl-1.40'],
			 os.path.join(testsDir, 'spec', 'glsl-1.40'),
			 ['compiler'])
add_shader_test_dir(spec['glsl-1.40'],
	            os.path.join(testsDir, 'spec', 'glsl-1.40'),
		    recursive=True)
spec['glsl-1.40']['execution']['tf-no-position'] = concurrent_test('glsl-1.40-tf-no-position')

textureSize_samplers_140 = textureSize_samplers_130 + ['sampler2DRect', 'isampler2DRect', 'sampler2DRectShadow', 'samplerBuffer', 'isamplerBuffer', 'usamplerBuffer']
for stage in ['vs', 'fs']:
	# textureSize():
	for sampler in textureSize_samplers_140:
		spec['glsl-1.40/execution/textureSize/' + stage + '-textureSize-' + sampler] = concurrent_test('textureSize 140 ' + stage + ' ' + sampler)
	# texelFetch():
	for sampler in ['sampler2DRect', 'usampler2DRect', 'isampler2DRect']:
		spec['glsl-1.40/execution/texelFetch/' + stage + '-texelFetch-' + sampler] = concurrent_test('texelFetch 140 ' + stage + ' ' + sampler)
		spec['glsl-1.40/execution/texelFetchOffset/' + stage + '-' + sampler] = concurrent_test('texelFetch offset 140 ' + stage + ' ' + sampler)

spec['glsl-1.50'] = Group()
import_glsl_parser_tests(spec['glsl-1.50'],
			 os.path.join(testsDir, 'spec', 'glsl-1.50'),
			 ['compiler'])
add_shader_test_dir(spec['glsl-1.50'],
		    os.path.join(testsDir, 'spec', 'glsl-1.50'),
		    recursive=True)

# Group spec/glsl-es-3.00
spec['glsl-es-3.00'] = Group()
import_glsl_parser_tests(spec['glsl-es-3.00'],
			 os.path.join(testsDir, 'spec', 'glsl-es-3.00'),
			 ['compiler'])
add_shader_test_dir(spec['glsl-es-3.00'],
		    os.path.join(testsDir, 'spec', 'glsl-es-3.00'),
		    recursive=True)
add_concurrent_test(spec['glsl-es-3.00']['execution'], 'varying-struct-centroid_gles3')

# AMD_performance_monitor
profile.test_list['AMD_performance_monitor/api'] = PlainExecTest('amd_performance_monitor_api -auto')
profile.test_list['AMD_performance_monitor/measure'] = PlainExecTest('amd_performance_monitor_measure -auto')

# Group AMD_conservative_depth
spec['AMD_conservative_depth'] = Group()
import_glsl_parser_tests(spec['AMD_conservative_depth'],
			 os.path.join(testsDir, 'spec', 'amd_conservative_depth'),
			 [''])

# Group ARB_point_sprite
arb_point_sprite = Group()
spec['ARB_point_sprite'] = arb_point_sprite
add_plain_test(arb_point_sprite, 'point-sprite')

# Group ARB_texture_multisample
samplers_atm = ['sampler2DMS', 'isampler2DMS', 'usampler2DMS',
				'sampler2DMSArray', 'isampler2DMSArray', 'usampler2DMSArray']
arb_texture_multisample = Group()
spec['ARB_texture_multisample'] = arb_texture_multisample
add_concurrent_test(arb_texture_multisample, 'arb_texture_multisample-minmax')
for sample_count in MSAA_SAMPLE_COUNTS:
    # fb-completeness
    spec['ARB_texture_multisample/fb-completeness/%d' % (sample_count,)] = \
        concurrent_test('arb_texture_multisample-fb-completeness %d' % (sample_count,))
    # texel-fetch execution
    for stage in ['vs','fs']:
        for sampler in samplers_atm:
                spec['ARB_texture_multisample/texelFetch/%d-%s-%s' % (
                    sample_count, stage, sampler)] = \
                    concurrent_test('texelFetch %s %s %d' % (stage, sampler, sample_count))
    # sample positions
    spec['ARB_texture_multisample/sample-position/%d' % (sample_count,)] = \
        concurrent_test('arb_texture_multisample-sample-position %d' % (sample_count,))
add_concurrent_test(arb_texture_multisample, 'arb_texture_multisample-texstate')
add_concurrent_test(arb_texture_multisample, 'arb_texture_multisample-errors')
add_concurrent_test(arb_texture_multisample, 'arb_texture_multisample-sample-mask')
add_concurrent_test(arb_texture_multisample, 'arb_texture_multisample-sample-mask-value')
add_concurrent_test(arb_texture_multisample, 'arb_texture_multisample-sample-mask-execution')
add_concurrent_test(arb_texture_multisample, 'arb_texture_multisample-sample-mask-execution -tex')
add_concurrent_test(arb_texture_multisample, 'arb_texture_multisample-negative-max-samples')
for stage in ['vs', 'fs']:
	# textureSize():
	for sampler in samplers_atm:
		spec['ARB_texture_multisample/textureSize/' + stage + '-textureSize-' + sampler] = concurrent_test('textureSize ' + stage + ' ' + sampler)

# Group AMD_shader_stencil_export
spec['AMD_shader_stencil_export'] = Group()
import_glsl_parser_tests(spec['AMD_shader_stencil_export'],
			 os.path.join(testsDir, 'spec', 'amd_shader_stencil_export'),
			 [''])

# Group ARB_shader_stencil_export
spec['ARB_shader_stencil_export'] = Group()
import_glsl_parser_tests(spec['ARB_shader_stencil_export'],
			 os.path.join(testsDir, 'spec', 'arb_shader_stencil_export'),
			 [''])

# Group ARB_sync
arb_sync = Group()
spec['ARB_sync'] = arb_sync
arb_sync['repeat-wait'] = concurrent_test('arb_sync-repeat-wait')
arb_sync['timeout-zero'] = concurrent_test('arb_sync-timeout-zero')
add_plain_test(arb_sync, 'sync_api')

# Group ARB_ES2_compatibility
arb_es2_compatibility = Group()
spec['ARB_ES2_compatibility'] = arb_es2_compatibility
add_plain_test(arb_es2_compatibility, 'arb_es2_compatibility-depthrangef')
add_plain_test(arb_es2_compatibility, 'arb_es2_compatibility-drawbuffers')
add_plain_test(arb_es2_compatibility, 'arb_es2_compatibility-getshaderprecisionformat')
add_plain_test(arb_es2_compatibility, 'arb_es2_compatibility-maxvectors')
add_plain_test(arb_es2_compatibility, 'arb_es2_compatibility-shadercompiler')
add_plain_test(arb_es2_compatibility, 'arb_es2_compatibility-releaseshadercompiler')
add_plain_test(arb_es2_compatibility, 'arb_es2_compatibility-fixed-type')
add_plain_test(arb_es2_compatibility, 'fbo-missing-attachment-clear')
arb_es2_compatibility['FBO blit to missing attachment (ES2 completeness rules)'] = PlainExecTest(['fbo-missing-attachment-blit', '-auto', 'es2', 'to'])
arb_es2_compatibility['FBO blit from missing attachment (ES2 completeness rules)'] = PlainExecTest(['fbo-missing-attachment-blit', '-auto', 'es2', 'from'])
add_fbo_formats_tests('spec/ARB_ES2_compatibility', 'GL_ARB_ES2_compatibility')
add_texwrap_format_tests(arb_es2_compatibility, 'GL_ARB_ES2_compatibility')

arb_depth_clamp = Group()
spec['ARB_depth_clamp'] = arb_depth_clamp
add_plain_test(arb_depth_clamp, 'depth_clamp')
add_plain_test(arb_depth_clamp, 'depth-clamp-range')

# Group ARB_draw_elements_base_vertex
arb_draw_elements_base_vertex = Group()
spec['ARB_draw_elements_base_vertex'] = arb_draw_elements_base_vertex
arb_draw_elements_base_vertex['dlist-arb_draw_instanced'] = concurrent_test('arb_draw_elements_base_vertex-dlist-arb_draw_instanced')
add_plain_test(arb_draw_elements_base_vertex, 'draw-elements-base-vertex')
arb_draw_elements_base_vertex['draw-elements-base-vertex-user_varrays'] = PlainExecTest(['draw-elements-base-vertex', '-auto', 'user_varrays'])
add_plain_test(arb_draw_elements_base_vertex, 'draw-elements-base-vertex-neg')
add_plain_test(arb_draw_elements_base_vertex, 'draw-elements-base-vertex-bounds')
arb_draw_elements_base_vertex['draw-elements-base-vertex-neg-user_varrays'] = PlainExecTest(['draw-elements-base-vertex-neg', '-auto', 'user_varrays'])
add_plain_test(arb_draw_elements_base_vertex, 'draw-elements-instanced-base-vertex')
arb_draw_elements_base_vertex['draw-elements-instanced-base-vertex-user_varrays'] = PlainExecTest(['draw-elements-instanced-base-vertex', '-auto', 'user_varrays'])

# Group ARB_draw_instanced
arb_draw_instanced = Group()
spec['ARB_draw_instanced'] = arb_draw_instanced
import_glsl_parser_tests(arb_draw_instanced,
                        testsDir + '/spec/arb_draw_instanced',
                        [''])

add_shader_test_dir(arb_draw_instanced,
                    testsDir + '/spec/arb_draw_instanced/execution',
                    recursive=True)
arb_draw_instanced['dlist'] = concurrent_test('arb_draw_instanced-dlist')
arb_draw_instanced['elements'] = concurrent_test('arb_draw_instanced-elements')
arb_draw_instanced['negative-arrays-first-negative'] = concurrent_test('arb_draw_instanced-negative-arrays-first-negative')
arb_draw_instanced['negative-elements-type'] = concurrent_test('arb_draw_instanced-negative-elements-type')
add_plain_test(arb_draw_instanced, 'draw-instanced')
add_plain_test(arb_draw_instanced, 'draw-instanced-divisor')

# Group ARB_fragment_program
arb_fragment_program = Group()
spec['ARB_fragment_program'] = arb_fragment_program
add_shader_test_dir(spec['ARB_fragment_program'],
	            os.path.join(testsDir, 'spec', 'arb_fragment_program'),
		    recursive=True)
arb_fragment_program['minmax'] = concurrent_test('arb_fragment_program-minmax')
add_vpfpgeneric(arb_fragment_program, 'fdo30337a')
add_vpfpgeneric(arb_fragment_program, 'fdo30337b')
add_vpfpgeneric(arb_fragment_program, 'fdo38145')
add_vpfpgeneric(arb_fragment_program, 'fp-cmp')
add_vpfpgeneric(arb_fragment_program, 'fp-dst-aliasing-1')
add_vpfpgeneric(arb_fragment_program, 'fp-dst-aliasing-2')
add_vpfpgeneric(arb_fragment_program, 'fp-ex2-sat')
add_vpfpgeneric(arb_fragment_program, 'fp-two-constants')
add_plain_test(arb_fragment_program, 'fp-abs-01')
add_plain_test(arb_fragment_program, 'fp-fog')
add_plain_test(arb_fragment_program, 'fp-formats')
add_plain_test(arb_fragment_program, 'fp-fragment-position')
add_plain_test(arb_fragment_program, 'fp-incomplete-tex')
add_plain_test(arb_fragment_program, 'fp-indirections')
add_plain_test(arb_fragment_program, 'fp-indirections2')
add_plain_test(arb_fragment_program, 'fp-kil')
add_plain_test(arb_fragment_program, 'fp-lit-mask')
add_plain_test(arb_fragment_program, 'fp-lit-src-equals-dst')
add_plain_test(arb_fragment_program, 'fp-long-alu')
add_plain_test(arb_fragment_program, 'fp-set-01')
arb_fragment_program['sparse-samplers'] = concurrent_test('arb_fragment_program-sparse-samplers')
add_plain_test(arb_fragment_program, 'trinity-fp1')
arb_fragment_program['incomplete-texture-arb_fp'] = concurrent_test('incomplete-texture -auto arb_fp')

# Group ARB_fragment_program_shadow
arb_fragment_program_shadow = Group()
spec['ARB_fragment_program_shadow'] = arb_fragment_program_shadow
add_shader_test_dir(spec['ARB_fragment_program_shadow'],
	            os.path.join(testsDir, 'spec', 'arb_fragment_program_shadow'),
		    recursive=True)

nv_fragment_program_option = Group()
spec['NV_fragment_program_option'] = nv_fragment_program_option
add_plain_test(nv_fragment_program_option, 'fp-abs-02')
add_plain_test(nv_fragment_program_option, 'fp-condition_codes-01')
add_plain_test(nv_fragment_program_option, 'fp-rfl')
add_plain_test(nv_fragment_program_option, 'fp-set-02')
add_plain_test(nv_fragment_program_option, 'fp-unpack-01')

arb_fragment_coord_conventions = Group()
spec['ARB_fragment_coord_conventions'] = arb_fragment_coord_conventions
add_vpfpgeneric(arb_fragment_coord_conventions, 'fp-arb-fragment-coord-conventions-none')
add_vpfpgeneric(arb_fragment_coord_conventions, 'fp-arb-fragment-coord-conventions-integer')

ati_fragment_shader = Group()
spec['ATI_fragment_shader'] = ati_fragment_shader
add_plain_test(ati_fragment_shader, 'ati-fs-bad-delete')

# Group ARB_framebuffer_object
arb_framebuffer_object = Group()
spec['ARB_framebuffer_object'] = arb_framebuffer_object
add_concurrent_test(arb_framebuffer_object, 'same-attachment-glFramebufferTexture2D-GL_DEPTH_STENCIL_ATTACHMENT')
add_concurrent_test(arb_framebuffer_object, 'same-attachment-glFramebufferRenderbuffer-GL_DEPTH_STENCIL_ATTACHMENT')
add_plain_test(arb_framebuffer_object, 'fdo28551')
for format in ('rgba', 'depth', 'stencil'):
    for test_mode in ('draw', 'read'):
        test_name = ' '.join(['framebuffer-blit-levels', test_mode, format])
        arb_framebuffer_object[test_name] = PlainExecTest(test_name + ' -auto')
add_plain_test(arb_framebuffer_object, 'fbo-alpha')
add_plain_test(arb_framebuffer_object, 'fbo-blit-stretch')
add_plain_test(arb_framebuffer_object, 'fbo-deriv')
add_plain_test(arb_framebuffer_object, 'fbo-luminance-alpha')
add_plain_test(arb_framebuffer_object, 'fbo-getframebufferattachmentparameter-01')
add_plain_test(arb_framebuffer_object, 'fbo-gl_pointcoord')
add_plain_test(arb_framebuffer_object, 'fbo-incomplete-texture-01')
add_plain_test(arb_framebuffer_object, 'fbo-incomplete-texture-02')
add_plain_test(arb_framebuffer_object, 'fbo-incomplete-texture-03')
add_plain_test(arb_framebuffer_object, 'fbo-incomplete-texture-04')
add_concurrent_test(arb_framebuffer_object, 'fbo-mipmap-copypix')
add_plain_test(arb_framebuffer_object, 'fbo-viewport')
arb_framebuffer_object['FBO blit to missing attachment'] = PlainExecTest(['fbo-missing-attachment-blit', '-auto', 'to'])
arb_framebuffer_object['FBO blit from missing attachment'] = PlainExecTest(['fbo-missing-attachment-blit', '-auto', 'from'])
arb_framebuffer_object['fbo-scissor-blit fbo'] = PlainExecTest(['fbo-scissor-blit', 'fbo', '-auto'])
arb_framebuffer_object['fbo-scissor-blit window'] = PlainExecTest(['fbo-scissor-blit', 'window', '-auto'])
arb_framebuffer_object['negative-readpixels-no-rb'] = concurrent_test('arb_framebuffer_object-negative-readpixels-no-rb')

# Group ARB_framebuffer_sRGB
arb_framebuffer_srgb = Group()
spec['ARB_framebuffer_sRGB'] = arb_framebuffer_srgb
for backing_type in ('texture', 'renderbuffer'):
        for srgb_types in ('linear', 'srgb', 'linear_to_srgb',
                           'srgb_to_linear'):
                for blit_type in ('single_sampled', 'upsample', 'downsample',
                                  'msaa', 'scaled'):
                        for framebuffer_srgb_setting in ('enabled',
                                                         'disabled'):
                                test_name = ' '.join(
                                        ['blit', backing_type, srgb_types,
                                         blit_type, framebuffer_srgb_setting])
                                arb_framebuffer_srgb[test_name] = concurrent_test(
                                        'arb_framebuffer_srgb-' + test_name)
add_plain_test(arb_framebuffer_srgb, 'framebuffer-srgb')

arb_occlusion_query = Group()
spec['ARB_occlusion_query'] = arb_occlusion_query
add_concurrent_test(arb_occlusion_query, 'occlusion_query')
add_concurrent_test(arb_occlusion_query, 'occlusion_query_lifetime')
add_concurrent_test(arb_occlusion_query, 'occlusion_query_meta_fragments')
add_concurrent_test(arb_occlusion_query, 'occlusion_query_meta_no_fragments')
add_concurrent_test(arb_occlusion_query, 'occlusion_query_order')

# Group ARB_sampler_objects
arb_sampler_objects = Group()
spec['ARB_sampler_objects'] = arb_sampler_objects
arb_sampler_objects['sampler-objects'] = concurrent_test('arb_sampler_objects-sampler-objects')
arb_sampler_objects['sampler-incomplete'] = concurrent_test('arb_sampler_objects-sampler-incomplete')
arb_sampler_objects['GL_EXT_texture_sRGB_decode'] = concurrent_test('arb_sampler_objects-srgb-decode')
arb_sampler_objects['framebufferblit'] = plain_test('arb_sampler_objects-framebufferblit')

# Group ARB_debug_output
arb_debug_output = Group()
spec['ARB_debug_output'] = arb_debug_output
add_plain_test(arb_debug_output, 'arb_debug_output-api_error')

# Group ARB_occlusion_query2
arb_occlusion_query2 = Group()
spec['ARB_occlusion_query2'] = arb_occlusion_query2
arb_occlusion_query2['api'] = concurrent_test('arb_occlusion_query2-api')
arb_occlusion_query2['render'] = concurrent_test('arb_occlusion_query2-render')

arb_pixel_buffer_object = Group()
spec['ARB_pixel_buffer_object'] = arb_pixel_buffer_object
add_plain_test(arb_pixel_buffer_object, 'fbo-pbo-readpixels-small')
add_plain_test(arb_pixel_buffer_object, 'pbo-drawpixels')
add_plain_test(arb_pixel_buffer_object, 'pbo-read-argb8888')
add_plain_test(arb_pixel_buffer_object, 'pbo-readpixels-small')
add_plain_test(arb_pixel_buffer_object, 'pbo-teximage')
add_plain_test(arb_pixel_buffer_object, 'pbo-teximage-tiling')
add_plain_test(arb_pixel_buffer_object, 'pbo-teximage-tiling-2')

# Group ARB_robustness
arb_robustness = Group()
spec['ARB_robustness'] = arb_robustness
add_plain_test(arb_robustness, 'arb_robustness_client-mem-bounds')
# TODO: robust vertex buffer access
#add_plain_test(arb_robustness, 'arb_robustness_draw-vbo-bounds')

# Group ARB_shader_texture_lod
arb_shader_texture_lod = Group()
spec['ARB_shader_texture_lod'] = arb_shader_texture_lod
import_glsl_parser_tests(arb_shader_texture_lod,
			 os.path.join(testsDir, 'spec', 'arb_shader_texture_lod'),
			 ['compiler'])
arb_shader_texture_lod['execution'] = Group()
add_shader_test_dir(arb_shader_texture_lod['execution'],
	            os.path.join(testsDir, 'spec', 'arb_shader_texture_lod', 'execution'),
		    recursive=True)
add_plain_test(arb_shader_texture_lod['execution'], 'arb_shader_texture_lod-texgrad')
arb_shader_texture_lod['execution']['tex-miplevel-selection-texture2DLod'] = PlainExecTest(['tex-miplevel-selection', '-auto', '-nobias', '-nolod', '-GL_ARB_shader_texture_lod'])
arb_shader_texture_lod['execution']['tex-miplevel-selection-texture2DLod-lod'] = PlainExecTest(['tex-miplevel-selection', '-auto', '-nobias', '-GL_ARB_shader_texture_lod'])
arb_shader_texture_lod['execution']['tex-miplevel-selection-texture2DLod-lod-bias'] = PlainExecTest(['tex-miplevel-selection', '-auto', '-GL_ARB_shader_texture_lod'])

# Group ARB_shader_objects
arb_shader_objects = Group()
spec['ARB_shader_objects'] = arb_shader_objects
arb_shader_objects['getuniform'] = PlainExecTest(['arb_shader_objects-getuniform', '-auto'])
arb_shader_objects['getuniform'].runConcurrent = True
arb_shader_objects['bindattriblocation-scratch-name'] = concurrent_test('arb_shader_objects-bindattriblocation-scratch-name')
arb_shader_objects['getactiveuniform-beginend'] = concurrent_test('arb_shader_objects-getactiveuniform-beginend')
arb_shader_objects['getuniformlocation-array-of-struct-of-array'] = concurrent_test('arb_shader_objects-getuniformlocation-array-of-struct-of-array')
arb_shader_objects['clear-with-deleted'] = concurrent_test('arb_shader_objects-clear-with-deleted')
arb_shader_objects['delete-repeat'] = concurrent_test('arb_shader_objects-delete-repeat')

# Group ARB_explicit_attrib_location
arb_explicit_attrib_location = Group()
spec['ARB_explicit_attrib_location'] = arb_explicit_attrib_location
import_glsl_parser_tests(arb_explicit_attrib_location,
			 os.path.join(testsDir,
			 'spec', 'arb_explicit_attrib_location'),
			 [''])
add_plain_test(arb_explicit_attrib_location, 'glsl-explicit-location-01')
add_plain_test(arb_explicit_attrib_location, 'glsl-explicit-location-02')
add_plain_test(arb_explicit_attrib_location, 'glsl-explicit-location-03')
add_plain_test(arb_explicit_attrib_location, 'glsl-explicit-location-04')
add_plain_test(arb_explicit_attrib_location, 'glsl-explicit-location-05')

arb_texture_buffer_object = Group()
spec['ARB_texture_buffer_object'] = arb_texture_buffer_object
arb_texture_buffer_object['dlist'] = concurrent_test('arb_texture_buffer_object-dlist')
arb_texture_buffer_object['formats (FS, 3.1 core)'] = concurrent_test('arb_texture_buffer_object-formats fs core')
arb_texture_buffer_object['formats (VS, 3.1 core)'] = concurrent_test('arb_texture_buffer_object-formats vs core')
arb_texture_buffer_object['formats (FS, ARB)'] = concurrent_test('arb_texture_buffer_object-formats fs arb')
arb_texture_buffer_object['formats (VS, ARB)'] = concurrent_test('arb_texture_buffer_object-formats vs arb')
arb_texture_buffer_object['get'] = concurrent_test('arb_texture_buffer_object-get')
arb_texture_buffer_object['fetch-outside-bounds'] = concurrent_test('arb_texture_buffer_object-fetch-outside-bounds')
arb_texture_buffer_object['minmax'] = concurrent_test('arb_texture_buffer_object-minmax')
arb_texture_buffer_object['negative-bad-bo'] = concurrent_test('arb_texture_buffer_object-negative-bad-bo')
arb_texture_buffer_object['negative-bad-format'] = concurrent_test('arb_texture_buffer_object-negative-bad-format')
arb_texture_buffer_object['negative-bad-target'] = concurrent_test('arb_texture_buffer_object-negative-bad-target')
arb_texture_buffer_object['unused-name'] = concurrent_test('arb_texture_buffer_object-unused-name')

arb_texture_buffer_range = Group()
spec['ARB_texture_buffer_range'] = arb_texture_buffer_range
arb_texture_buffer_range['dlist'] = concurrent_test('arb_texture_buffer_range-dlist')
arb_texture_buffer_range['errors'] = concurrent_test('arb_texture_buffer_range-errors')
arb_texture_buffer_range['ranges'] = concurrent_test('arb_texture_buffer_range-ranges')

arb_texture_query_lod = Group()
spec['ARB_texture_query_lod'] = arb_texture_query_lod
add_shader_test_dir(arb_texture_query_lod,
                    testsDir + '/spec/arb_texture_query_lod',
                    recursive=True)

arb_texture_rectangle = Group()
spec['ARB_texture_rectangle'] = arb_texture_rectangle
add_texwrap_target_tests(arb_texture_rectangle, 'RECT')
add_shader_test_dir(arb_texture_rectangle,
                    testsDir + '/spec/arb_texture_rectangle',
                    recursive=True)
arb_texture_rectangle['copyteximage RECT'] = PlainExecTest(['copyteximage', '-auto', 'RECT'])
add_concurrent_test(arb_texture_rectangle, '1-1-linear-texture')
add_plain_test(arb_texture_rectangle, 'texrect-many')
add_concurrent_test(arb_texture_rectangle, 'getteximage-targets RECT')
add_plain_test(arb_texture_rectangle, 'texrect_simple_arb_texrect')
add_plain_test(arb_texture_rectangle, 'fbo-blit rect')

arb_texture_storage = Group()
spec['ARB_texture_storage'] = arb_texture_storage
arb_texture_storage['texture-storage'] = plain_test('arb_texture_storage-texture-storage')

tdfx_texture_compression_fxt1 = Group()
spec['3DFX_texture_compression_FXT1'] = tdfx_texture_compression_fxt1
add_concurrent_test(tdfx_texture_compression_fxt1, 'compressedteximage GL_COMPRESSED_RGB_FXT1_3DFX')
add_concurrent_test(tdfx_texture_compression_fxt1, 'compressedteximage GL_COMPRESSED_RGBA_FXT1_3DFX')
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
add_plain_test(tdfx_texture_compression_fxt1, 'fxt1-teximage')

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])

arb_color_buffer_float = Group()
spec['ARB_color_buffer_float'] = arb_color_buffer_float
add_color_buffer_float_test('mrt', 'mixed', '', '')

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('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_RGBA8_SNORM', '', '')
add_color_buffer_float_test('queries', 'GL_RGBA8_SNORM', '', '')
add_color_buffer_float_test('readpixels', 'GL_RGBA8_SNORM', '', '')
add_color_buffer_float_test('probepixel', 'GL_RGBA8_SNORM', '', '')
add_color_buffer_float_test('drawpixels', 'GL_RGBA8_SNORM', '', '')
add_color_buffer_float_test('clear', 'GL_RGBA8_SNORM', '', '')
add_color_buffer_float_test('render', 'GL_RGBA8_SNORM', '', '')
add_color_buffer_float_test('render', 'GL_RGBA8_SNORM', 'fog', '')
add_color_buffer_float_test('render', 'GL_RGBA8_SNORM', 'sanity', '')
add_color_buffer_float_test('render', 'GL_RGBA8_SNORM', '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('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('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
add_fbo_formats_tests('spec/ARB_depth_texture', 'GL_ARB_depth_texture')
add_texwrap_format_tests(arb_depth_texture, 'GL_ARB_depth_texture')
add_fbo_depth_tests(arb_depth_texture, 'GL_DEPTH_COMPONENT16')
add_fbo_depth_tests(arb_depth_texture, 'GL_DEPTH_COMPONENT24')
add_fbo_depth_tests(arb_depth_texture, 'GL_DEPTH_COMPONENT32')
add_plain_test(arb_depth_texture, 'depth-level-clamp')
add_plain_test(arb_depth_texture, 'depth-tex-modes')
add_plain_test(arb_depth_texture, 'texdepth')
add_depthstencil_render_miplevels_tests(arb_depth_texture, ('d=z24', 'd=z16'))

arb_depth_buffer_float = Group()
spec['ARB_depth_buffer_float'] = arb_depth_buffer_float
add_fbo_depth_tests(arb_depth_buffer_float, 'GL_DEPTH_COMPONENT32F')
add_fbo_depth_tests(arb_depth_buffer_float, 'GL_DEPTH32F_STENCIL8')
add_fbo_stencil_tests(arb_depth_buffer_float, 'GL_DEPTH32F_STENCIL8')
add_fbo_depthstencil_tests(arb_depth_buffer_float, 'GL_DEPTH32F_STENCIL8')
add_fbo_formats_tests('spec/ARB_depth_buffer_float', 'GL_ARB_depth_buffer_float')
add_texwrap_format_tests(arb_depth_buffer_float, 'GL_ARB_depth_buffer_float')
add_depthstencil_render_miplevels_tests(
        arb_depth_buffer_float,
        ('d=z32f_s8', 'd=z32f', 'd=z32f_s8_s=z24_s8', 'd=z32f_s=z24_s8',
         's=z24_s8_d=z32f_s8', 's=z24_s8_d=z32f', 'd=s=z32f_s8', 's=d=z32f_s8',
         'ds=z32f_s8'))
arb_depth_buffer_float['fbo-clear-formats stencil'] = PlainExecTest(['fbo-clear-formats', 'GL_ARB_depth_buffer_float', 'stencil', '-auto'])

arb_texture_env_crossbar = Group()
spec['ARB_texture_env_crossbar'] = arb_texture_env_crossbar
add_plain_test(arb_texture_env_crossbar, 'crossbar')

arb_texture_compression = Group()
spec['ARB_texture_compression'] = arb_texture_compression
add_fbo_generatemipmap_extension(arb_texture_compression, 'GL_ARB_texture_compression', 'fbo-generatemipmap-formats')
add_texwrap_format_tests(arb_texture_compression, 'GL_ARB_texture_compression')
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

ext_vertex_array_bgra = Group()
spec['EXT_vertex_array_bgra'] = ext_vertex_array_bgra
add_plain_test(ext_vertex_array_bgra, 'bgra-sec-color-pointer')
add_plain_test(ext_vertex_array_bgra, 'bgra-vert-attrib-pointer')

apple_vertex_array_object = Group()
spec['APPLE_vertex_array_object'] = apple_vertex_array_object
add_plain_test(apple_vertex_array_object, 'vao-01')
add_plain_test(apple_vertex_array_object, 'vao-02')
apple_vertex_array_object['isvertexarray'] = concurrent_test('arb_vertex_array-isvertexarray apple')

arb_vertex_array_object = Group()
spec['ARB_vertex_array_object'] = arb_vertex_array_object
add_concurrent_test(arb_vertex_array_object, 'vao-element-array-buffer')
arb_vertex_array_object['isvertexarray'] = concurrent_test('arb_vertex_array-isvertexarray')

arb_vertex_buffer_object = Group()
spec['ARB_vertex_buffer_object'] = arb_vertex_buffer_object
arb_vertex_buffer_object['elements-negative-offset'] = PlainExecTest(['arb_vertex_buffer_object-elements-negative-offset', '-auto'])
arb_vertex_buffer_object['mixed-immediate-and-vbo'] = PlainExecTest(['arb_vertex_buffer_object-mixed-immediate-and-vbo', '-auto'])
add_plain_test(arb_vertex_buffer_object, 'fdo14575')
add_plain_test(arb_vertex_buffer_object, 'fdo22540')
add_plain_test(arb_vertex_buffer_object, 'fdo31934')
add_plain_test(arb_vertex_buffer_object, 'pos-array')
add_plain_test(arb_vertex_buffer_object, 'vbo-bufferdata')
add_plain_test(arb_vertex_buffer_object, 'vbo-map-remap')
add_concurrent_test(arb_vertex_buffer_object, 'vbo-map-unsync')
add_plain_test(arb_vertex_buffer_object, 'vbo-subdata-sync')
add_plain_test(arb_vertex_buffer_object, 'vbo-subdata-zero')

arb_vertex_program = Group()
spec['ARB_vertex_program'] = arb_vertex_program
arb_vertex_program['getenv4d-with-error'] = PlainExecTest(['arb_vertex_program-getenv4d-with-error', '-auto'])
arb_vertex_program['getlocal4d-with-error'] = PlainExecTest(['arb_vertex_program-getlocal4d-with-error', '-auto'])
arb_vertex_program['clip-plane-transformation arb'] = concurrent_test('clip-plane-transformation arb')
arb_vertex_program['minmax'] = concurrent_test('arb_vertex_program-minmax')
add_plain_test(arb_vertex_program, 'fdo24066')
add_vpfpgeneric(arb_vertex_program, 'arl')
add_vpfpgeneric(arb_vertex_program, 'big-param')
add_vpfpgeneric(arb_vertex_program, 'dataflow-bug')
add_vpfpgeneric(arb_vertex_program, 'fogcoord-dp3')
add_vpfpgeneric(arb_vertex_program, 'fogcoord-dph')
add_vpfpgeneric(arb_vertex_program, 'fogcoord-dp4')
add_vpfpgeneric(arb_vertex_program, 'vp-arl-constant-array')
add_vpfpgeneric(arb_vertex_program, 'vp-arl-constant-array-huge')
add_vpfpgeneric(arb_vertex_program, 'vp-arl-constant-array-huge-varying')
add_vpfpgeneric(arb_vertex_program, 'vp-arl-constant-array-huge-offset')
add_vpfpgeneric(arb_vertex_program, 'vp-arl-constant-array-huge-offset-neg')
add_vpfpgeneric(arb_vertex_program, 'vp-arl-constant-array-huge-overwritten')
add_vpfpgeneric(arb_vertex_program, 'vp-arl-constant-array-huge-relative-offset')
add_vpfpgeneric(arb_vertex_program, 'vp-arl-constant-array-varying')
add_vpfpgeneric(arb_vertex_program, 'vp-arl-env-array')
add_vpfpgeneric(arb_vertex_program, 'vp-arl-local-array')
add_vpfpgeneric(arb_vertex_program, 'vp-arl-neg-array')
add_vpfpgeneric(arb_vertex_program, 'vp-arl-neg-array-2')
add_vpfpgeneric(arb_vertex_program, 'vp-constant-array')
add_vpfpgeneric(arb_vertex_program, 'vp-constant-array-huge')
add_vpfpgeneric(arb_vertex_program, 'vp-constant-negate')
add_vpfpgeneric(arb_vertex_program, 'vp-exp-alias')
add_vpfpgeneric(arb_vertex_program, 'vp-max')
add_vpfpgeneric(arb_vertex_program, 'vp-min')
add_vpfpgeneric(arb_vertex_program, 'vp-sge-alias')
add_vpfpgeneric(arb_vertex_program, 'vp-two-constants')
add_plain_test(arb_vertex_program, 'vp-address-01')
add_plain_test(arb_vertex_program, 'vp-address-02')
add_plain_test(arb_vertex_program, 'vp-address-04')
add_plain_test(arb_vertex_program, 'vp-bad-program')
add_plain_test(arb_vertex_program, 'vp-max-array')

nv_vertex_program = Group()
spec['NV_vertex_program'] = nv_vertex_program
add_vpfpgeneric(nv_vertex_program, 'nv-mov')
add_vpfpgeneric(nv_vertex_program, 'nv-add')
add_vpfpgeneric(nv_vertex_program, 'nv-arl')
add_vpfpgeneric(nv_vertex_program, 'nv-init-zero-reg')
add_vpfpgeneric(nv_vertex_program, 'nv-init-zero-addr')

nv_vertex_program2_option = Group()
spec['NV_vertex_program2_option'] = nv_vertex_program2_option
add_plain_test(nv_vertex_program2_option, 'vp-address-03')
add_plain_test(nv_vertex_program2_option, 'vp-address-05')
add_plain_test(nv_vertex_program2_option, 'vp-address-06')
add_plain_test(nv_vertex_program2_option, 'vp-clipdistance-01')
add_plain_test(nv_vertex_program2_option, 'vp-clipdistance-02')
add_plain_test(nv_vertex_program2_option, 'vp-clipdistance-03')
add_plain_test(nv_vertex_program2_option, 'vp-clipdistance-04')

ext_framebuffer_blit = Group()
spec['EXT_framebuffer_blit'] = ext_framebuffer_blit
add_plain_test(ext_framebuffer_blit, 'fbo-blit')
add_plain_test(ext_framebuffer_blit, 'fbo-copypix')
add_plain_test(ext_framebuffer_blit, 'fbo-readdrawpix')
add_plain_test(ext_framebuffer_blit, 'fbo-srgb-blit')
add_plain_test(ext_framebuffer_blit, 'fbo-sys-blit')
add_plain_test(ext_framebuffer_blit, 'fbo-sys-sub-blit')

ext_framebuffer_multisample = Group()
spec['EXT_framebuffer_multisample'] = ext_framebuffer_multisample
ext_framebuffer_multisample['blit-mismatched-samples'] = concurrent_test('ext_framebuffer_multisample-blit-mismatched-samples')
ext_framebuffer_multisample['blit-mismatched-sizes'] = concurrent_test('ext_framebuffer_multisample-blit-mismatched-sizes')
ext_framebuffer_multisample['blit-mismatched-formats'] = concurrent_test('ext_framebuffer_multisample-blit-mismatched-formats')
ext_framebuffer_multisample['dlist'] = concurrent_test('ext_framebuffer_multisample-dlist')
ext_framebuffer_multisample['enable-flag'] = PlainExecTest('ext_framebuffer_multisample-enable-flag -auto')
ext_framebuffer_multisample['minmax'] = concurrent_test('ext_framebuffer_multisample-minmax')
ext_framebuffer_multisample['negative-copypixels'] = concurrent_test('ext_framebuffer_multisample-negative-copypixels')
ext_framebuffer_multisample['negative-copyteximage'] = concurrent_test('ext_framebuffer_multisample-negative-copyteximage')
ext_framebuffer_multisample['negative-max-samples'] = concurrent_test('ext_framebuffer_multisample-negative-max-samples')
ext_framebuffer_multisample['negative-mismatched-samples'] = concurrent_test('ext_framebuffer_multisample-negative-mismatched-samples')
ext_framebuffer_multisample['negative-readpixels'] = concurrent_test('ext_framebuffer_multisample-negative-readpixels')
ext_framebuffer_multisample['renderbufferstorage-samples'] = concurrent_test('ext_framebuffer_multisample-renderbufferstorage-samples')
ext_framebuffer_multisample['renderbuffer-samples'] = concurrent_test('ext_framebuffer_multisample-renderbuffer-samples')
ext_framebuffer_multisample['samples'] = concurrent_test('ext_framebuffer_multisample-samples')
ext_framebuffer_multisample['alpha-blending'] = PlainExecTest('ext_framebuffer_multisample-alpha-blending -auto')

for num_samples in MSAA_SAMPLE_COUNTS:
        for test_type in ('color', 'srgb', 'stencil_draw', 'stencil_resolve',
                          'depth_draw', 'depth_resolve'):
                for options in power_set(('small', 'depthstencil')):
                        test_name = ' '.join(['accuracy', str(num_samples), test_type]
                                             + options)
                        executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                                test_name)
                        ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        test_name = ' '.join(['turn-on-off', str(num_samples)])
        executable = 'ext_framebuffer_multisample-{0} -auto'.format(test_name)
        ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        for buffer_type in ('color', 'depth', 'stencil'):
                test_name = ' '.join(['upsample', str(num_samples), buffer_type])
                executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                        test_name)
                ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        for buffer_type in ('color', 'depth', 'stencil'):
                test_name = ' ' .join(['multisample-blit', str(num_samples), buffer_type])
                executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                        test_name)
                ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        for buffer_type in ('color', 'depth', 'stencil'):
                for blit_type in ('msaa', 'upsample', 'downsample'):
                        test_name = ' '.join(['unaligned-blit', str(num_samples), buffer_type, blit_type])
                        executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                                test_name)
                        ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
	test_name = ' ' .join(['line-smooth', str(num_samples)])
	executable = 'ext_framebuffer_multisample-{0} -auto'.format(
	        test_name)
	ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
	test_name = ' ' .join(['point-smooth', str(num_samples)])
	executable = 'ext_framebuffer_multisample-{0} -auto'.format(
	        test_name)
	ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
	test_name = ' ' .join(['polygon-smooth', str(num_samples)])
	executable = 'ext_framebuffer_multisample-{0} -auto'.format(
	        test_name)
	ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        test_name = ' '.join(['formats', str(num_samples)])
        executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                test_name)
        ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        for test_mode in ('inverted', 'non-inverted'):
                test_name = ' '.join(['sample-coverage', str(num_samples), test_mode])
                executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                        test_name)
                ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        for buffer_type in ('color', 'depth'):
                test_name = ' '.join(['sample-alpha-to-coverage', str(num_samples), buffer_type])
                executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                        test_name)
                ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        test_name = ' '.join(['sample-alpha-to-one', str(num_samples)])
        executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                test_name)
        ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        test_name = ' '.join(['draw-buffers-alpha-to-one', str(num_samples)])
        executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                test_name)
        ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        test_name = ' '.join(['draw-buffers-alpha-to-coverage', str(num_samples)])
        executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                test_name)
        ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        test_name = ' '.join(['alpha-to-coverage-no-draw-buffer-zero', str(num_samples)])
        executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                test_name)
        ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        test_name = ' '.join(['alpha-to-coverage-dual-src-blend', str(num_samples)])
        executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                test_name)
        ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        test_name = ' '.join(['alpha-to-one-dual-src-blend', str(num_samples)])
        executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                test_name)
        ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        test_name = ' '.join(['int-draw-buffers-alpha-to-one', str(num_samples)])
        executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                test_name)
        ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        test_name = ' '.join(['int-draw-buffers-alpha-to-coverage', str(num_samples)])
        executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                test_name)
        ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        test_name = ' '.join(['alpha-to-one-msaa-disabled', str(num_samples)])
        executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                test_name)
        ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        test_name = ' '.join(['alpha-to-one-single-sample-buffer', str(num_samples)])
        executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                test_name)
        ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        test_name = ' '.join(['bitmap', str(num_samples)])
        executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                test_name)
        ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        test_name = ' '.join(['polygon-stipple', str(num_samples)])
        executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                test_name)
        ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        for blit_type in ('msaa', 'upsample', 'downsample', 'normal'):
                test_name = ' '.join(['clip-and-scissor-blit',
                                      str(num_samples), blit_type])
                executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                        test_name)
                ext_framebuffer_multisample[test_name] = PlainExecTest(
                        executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        for flip_direction in ('x', 'y'):
                test_name = ' '.join(['blit-flipped', str(num_samples),
                                      flip_direction])
                executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                        test_name)
                ext_framebuffer_multisample[test_name] = PlainExecTest(
                        executable)

# Note: the interpolation tests also check for sensible behaviour with
# non-multisampled framebuffers, so go ahead and test them with
# num_samples==0 as well.
for num_samples in (0,) + MSAA_SAMPLE_COUNTS:
        for test_type in ('non-centroid-disabled', 'centroid-disabled',
                          'centroid-edges', 'non-centroid-deriv',
                          'non-centroid-deriv-disabled', 'centroid-deriv',
                          'centroid-deriv-disabled'):
                test_name = ' '.join(['interpolation', str(num_samples),
                                      test_type])
                executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                        test_name)
                ext_framebuffer_multisample[test_name] = PlainExecTest(
                        executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        for buffer_type in ('color', 'depth', 'stencil'):
                test_name = ' '.join(['clear', str(num_samples), buffer_type])
                executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                        test_name)
                ext_framebuffer_multisample[test_name] = PlainExecTest(
                        executable)

for num_samples in MSAA_SAMPLE_COUNTS:
        for test_type in ('depth', 'depth-computed', 'stencil'):
                for buffer_config in ('combined', 'separate', 'single'):
                        test_name = ' '.join(['no-color', str(num_samples),
                                              test_type, buffer_config])
                        executable = 'ext_framebuffer_multisample-{0} -auto'.format(
                                test_name)
                        ext_framebuffer_multisample[test_name] = PlainExecTest(executable)

ext_framebuffer_object = Group()
spec['EXT_framebuffer_object'] = ext_framebuffer_object
add_fbo_stencil_tests(ext_framebuffer_object, 'GL_STENCIL_INDEX1')
add_fbo_stencil_tests(ext_framebuffer_object, 'GL_STENCIL_INDEX4')
add_fbo_stencil_tests(ext_framebuffer_object, 'GL_STENCIL_INDEX8')
add_fbo_stencil_tests(ext_framebuffer_object, 'GL_STENCIL_INDEX16')
add_concurrent_test(ext_framebuffer_object, 'fbo-generatemipmap-noimage')
add_plain_test(ext_framebuffer_object, 'fdo20701')
add_plain_test(ext_framebuffer_object, 'fbo-1d')
add_plain_test(ext_framebuffer_object, 'fbo-3d')
add_plain_test(ext_framebuffer_object, 'fbo-alphatest-formats')
add_plain_test(ext_framebuffer_object, 'fbo-alphatest-nocolor')
add_plain_test(ext_framebuffer_object, 'fbo-alphatest-nocolor-ff')
add_plain_test(ext_framebuffer_object, 'fbo-blending-formats')
add_plain_test(ext_framebuffer_object, 'fbo-bind-renderbuffer')
add_plain_test(ext_framebuffer_object, 'fbo-clearmipmap')
add_plain_test(ext_framebuffer_object, 'fbo-clear-formats')
add_plain_test(ext_framebuffer_object, 'fbo-copyteximage')
add_plain_test(ext_framebuffer_object, 'fbo-copyteximage-simple')
add_plain_test(ext_framebuffer_object, 'fbo-cubemap')
add_plain_test(ext_framebuffer_object, 'fbo-depthtex')
add_plain_test(ext_framebuffer_object, 'fbo-depth-sample-compare')
add_plain_test(ext_framebuffer_object, 'fbo-drawbuffers')
add_plain_test(ext_framebuffer_object, 'fbo-drawbuffers masked-clear')
add_plain_test(ext_framebuffer_object, 'fbo-drawbuffers-arbfp')
add_plain_test(ext_framebuffer_object, 'fbo-drawbuffers-blend-add')
add_plain_test(ext_framebuffer_object, 'fbo-drawbuffers-fragcolor')
add_plain_test(ext_framebuffer_object, 'fbo-drawbuffers-maxtargets')
add_plain_test(ext_framebuffer_object, 'fbo-finish-deleted')
add_plain_test(ext_framebuffer_object, 'fbo-flushing')
add_plain_test(ext_framebuffer_object, 'fbo-flushing-2')
add_plain_test(ext_framebuffer_object, 'fbo-fragcoord')
add_plain_test(ext_framebuffer_object, 'fbo-fragcoord2')
add_plain_test(ext_framebuffer_object, 'fbo-generatemipmap')
add_plain_test(ext_framebuffer_object, 'fbo-generatemipmap-filtering')
add_plain_test(ext_framebuffer_object, 'fbo-generatemipmap-formats')
add_plain_test(ext_framebuffer_object, 'fbo-generatemipmap-scissor')
add_plain_test(ext_framebuffer_object, 'fbo-generatemipmap-nonsquare')
add_plain_test(ext_framebuffer_object, 'fbo-generatemipmap-npot')
add_plain_test(ext_framebuffer_object, 'fbo-generatemipmap-viewport')
add_plain_test(ext_framebuffer_object, 'fbo-maxsize')
add_plain_test(ext_framebuffer_object, 'fbo-nodepth-test')
add_plain_test(ext_framebuffer_object, 'fbo-nostencil-test')
add_plain_test(ext_framebuffer_object, 'fbo-readpixels')
add_plain_test(ext_framebuffer_object, 'fbo-readpixels-depth-formats')
add_plain_test(ext_framebuffer_object, 'fbo-scissor-bitmap')
add_plain_test(ext_framebuffer_object, 'fbo-storage-completeness')
add_plain_test(ext_framebuffer_object, 'fbo-storage-formats')
add_plain_test(ext_framebuffer_object, 'getteximage-formats init-by-rendering')


ext_packed_depth_stencil = Group()
spec['EXT_packed_depth_stencil'] = ext_packed_depth_stencil
add_fbo_depth_tests(ext_packed_depth_stencil, 'GL_DEPTH24_STENCIL8')
add_fbo_stencil_tests(ext_packed_depth_stencil, 'GL_DEPTH24_STENCIL8')
add_fbo_depthstencil_tests(ext_packed_depth_stencil, 'GL_DEPTH24_STENCIL8')
add_fbo_formats_tests('spec/EXT_packed_depth_stencil', 'GL_EXT_packed_depth_stencil')
add_texwrap_format_tests(ext_packed_depth_stencil, 'GL_EXT_packed_depth_stencil')
ext_packed_depth_stencil['readpixels-24_8'] = PlainExecTest(['ext_packed_depth_stencil-readpixels-24_8', '-auto'])
add_plain_test(ext_packed_depth_stencil, 'fbo-blit-d24s8')
add_depthstencil_render_miplevels_tests(
        ext_packed_depth_stencil,
        ('s=z24_s8', 'd=z24_s8', 'd=z24_s8_s=z24_s8', 'd=z24_s=z24_s8',
         's=z24_s8_d=z24_s8', 's=z24_s8_d=z24', 'd=s=z24_s8', 's=d=z24_s8',
         'ds=z24_s8'))
ext_packed_depth_stencil['fbo-clear-formats stencil'] = PlainExecTest(['fbo-clear-formats', 'GL_EXT_packed_depth_stencil', 'stencil', '-auto'])

ext_texture_array = Group()
spec['EXT_texture_array'] = ext_texture_array
add_plain_test(ext_texture_array, 'fbo-generatemipmap-array')
spec['EXT_texture_array']['maxlayers'] = concurrent_test('ext_texture_array-maxlayers')
add_shader_test_dir(ext_texture_array,
                    testsDir + '/spec/ext_texture_array',
                    recursive=True)
ext_texture_array['copyteximage 1D_ARRAY'] = PlainExecTest(['copyteximage', '-auto', '1D_ARRAY'])
ext_texture_array['copyteximage 2D_ARRAY'] = PlainExecTest(['copyteximage', '-auto', '2D_ARRAY'])
add_plain_test(ext_texture_array, 'fbo-array')
add_plain_test(ext_texture_array, 'fbo-depth-array')
add_plain_test(ext_texture_array, 'array-texture')
add_concurrent_test(ext_texture_array, 'getteximage-targets 1D_ARRAY')
add_concurrent_test(ext_texture_array, 'getteximage-targets 2D_ARRAY')
for test_mode in ['teximage', 'texsubimage']:
        test_name = 'compressed {0}'.format(test_mode)
        ext_texture_array[test_name] = PlainExecTest('ext_texture_array-' + test_name + ' -auto -fbo')

arb_texture_cube_map = Group()
spec['ARB_texture_cube_map'] = arb_texture_cube_map
arb_texture_cube_map['copyteximage CUBE'] = PlainExecTest(['copyteximage', '-auto', 'CUBE'])
add_plain_test(arb_texture_cube_map, 'crash-cubemap-order')
add_plain_test(arb_texture_cube_map, 'cubemap')
arb_texture_cube_map['cubemap npot'] = PlainExecTest(['cubemap', '-auto', 'npot'])
add_plain_test(arb_texture_cube_map, 'cubemap-shader')
arb_texture_cube_map['cubemap-shader lod'] = PlainExecTest(['cubemap-shader', '-auto', 'lod'])
arb_texture_cube_map['cubemap-shader bias'] = PlainExecTest(['cubemap-shader', '-auto', 'bias'])
add_concurrent_test(arb_texture_cube_map, 'getteximage-targets CUBE')

arb_texture_cube_map_array = Group()
spec['ARB_texture_cube_map_array'] = arb_texture_cube_map_array
add_plain_test(arb_texture_cube_map_array, 'arb_texture_cube_map_array-get')
add_plain_test(arb_texture_cube_map_array, 'arb_texture_cube_map_array-teximage3d-invalid-values')
add_plain_test(arb_texture_cube_map_array, 'arb_texture_cube_map_array-cubemap')
add_plain_test(arb_texture_cube_map_array, 'arb_texture_cube_map_array-cubemap-lod')
add_plain_test(arb_texture_cube_map_array, 'arb_texture_cube_map_array-fbo-cubemap-array')
add_plain_test(arb_texture_cube_map_array, 'arb_texture_cube_map_array-sampler-cube-array-shadow')
add_concurrent_test(arb_texture_cube_map_array, 'getteximage-targets CUBE_ARRAY')
textureSize_samplers_atcma = ['samplerCubeArray', 'isamplerCubeArray', 'usamplerCubeArray', 'samplerCubeArrayShadow' ];

import_glsl_parser_tests(arb_texture_cube_map_array,
			 os.path.join(testsDir, 'spec', 'arb_texture_cube_map_array'),
			 ['compiler'])
for stage in ['vs', 'fs']:
	# textureSize():
	for sampler in textureSize_samplers_atcma:
		spec['ARB_texture_cube_map_array/textureSize/' + stage + '-textureSize-' + sampler] = concurrent_test('textureSize ' + stage + ' ' + sampler)

ext_texture_swizzle = Group()
spec['EXT_texture_swizzle'] = ext_texture_swizzle
add_plain_test(ext_texture_swizzle, 'tex-swizzle')
ext_texture_swizzle['depth_texture_mode_and_swizzle'] = concurrent_test('depth_texture_mode_and_swizzle')

ext_texture_compression_latc = Group()
spec['EXT_texture_compression_latc'] = ext_texture_compression_latc
add_fbo_generatemipmap_extension(ext_texture_compression_latc, 'GL_EXT_texture_compression_latc', 'fbo-generatemipmap-formats')
add_fbo_generatemipmap_extension(ext_texture_compression_latc, 'GL_EXT_texture_compression_latc-signed', 'fbo-generatemipmap-formats-signed')
add_texwrap_format_tests(ext_texture_compression_latc, 'GL_EXT_texture_compression_latc')
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
add_concurrent_test(ext_texture_compression_rgtc, 'compressedteximage GL_COMPRESSED_RED_RGTC1_EXT')
add_concurrent_test(ext_texture_compression_rgtc, 'compressedteximage GL_COMPRESSED_RED_GREEN_RGTC2_EXT')
add_concurrent_test(ext_texture_compression_rgtc, 'compressedteximage GL_COMPRESSED_SIGNED_RED_RGTC1_EXT')
add_concurrent_test(ext_texture_compression_rgtc, 'compressedteximage GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT')
add_fbo_generatemipmap_extension(ext_texture_compression_rgtc, 'GL_EXT_texture_compression_rgtc', 'fbo-generatemipmap-formats')
add_fbo_generatemipmap_extension(ext_texture_compression_rgtc, 'GL_EXT_texture_compression_rgtc-signed', 'fbo-generatemipmap-formats-signed')
add_texwrap_format_tests(ext_texture_compression_rgtc, 'GL_EXT_texture_compression_rgtc')
ext_texture_compression_rgtc['invalid formats'] = PlainExecTest(['arb_texture_compression-invalid-formats', 'rgtc'])
ext_texture_compression_rgtc['invalid formats'].runConcurrent = True
add_plain_test(ext_texture_compression_rgtc, 'rgtc-teximage-01')
add_plain_test(ext_texture_compression_rgtc, 'rgtc-teximage-02')

ext_texture_compression_s3tc = Group()
spec['EXT_texture_compression_s3tc'] = ext_texture_compression_s3tc
add_concurrent_test(ext_texture_compression_s3tc, 'compressedteximage GL_COMPRESSED_RGB_S3TC_DXT1_EXT')
add_concurrent_test(ext_texture_compression_s3tc, 'compressedteximage GL_COMPRESSED_RGBA_S3TC_DXT1_EXT')
add_concurrent_test(ext_texture_compression_s3tc, 'compressedteximage GL_COMPRESSED_RGBA_S3TC_DXT3_EXT')
add_concurrent_test(ext_texture_compression_s3tc, 'compressedteximage GL_COMPRESSED_RGBA_S3TC_DXT5_EXT')
add_fbo_generatemipmap_extension(ext_texture_compression_s3tc, 'GL_EXT_texture_compression_s3tc', 'fbo-generatemipmap-formats')
add_texwrap_format_tests(ext_texture_compression_s3tc, 'GL_EXT_texture_compression_s3tc')
ext_texture_compression_s3tc['invalid formats'] = PlainExecTest(['arb_texture_compression-invalid-formats', 's3tc'])
ext_texture_compression_s3tc['invalid formats'].runConcurrent = True
add_plain_test(ext_texture_compression_s3tc, 'gen-compressed-teximage')
add_concurrent_test(ext_texture_compression_s3tc, 's3tc-errors')
add_plain_test(ext_texture_compression_s3tc, 's3tc-teximage')
add_plain_test(ext_texture_compression_s3tc, 's3tc-texsubimage')
add_concurrent_test(ext_texture_compression_s3tc, 'getteximage-targets S3TC 2D')
add_concurrent_test(ext_texture_compression_s3tc, 'getteximage-targets S3TC 2D_ARRAY')
add_concurrent_test(ext_texture_compression_s3tc, 'getteximage-targets S3TC CUBE')
add_concurrent_test(ext_texture_compression_s3tc, 'getteximage-targets S3TC CUBE_ARRAY')

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_format_tests(ati_texture_compression_3dc, 'GL_ATI_texture_compression_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
add_fbo_formats_tests('spec/EXT_packed_float', 'GL_EXT_packed_float')
add_texwrap_format_tests(ext_packed_float, 'GL_EXT_packed_float')
ext_packed_float['pack'] = concurrent_test('ext_packed_float-pack')
ext_packed_float['getteximage-invalid-format-for-packed-type'] = concurrent_test('getteximage-invalid-format-for-packed-type')
add_msaa_formats_tests(ext_packed_float, 'GL_EXT_packed_float')

arb_texture_float = Group()
spec['ARB_texture_float'] = arb_texture_float
add_fbo_formats_tests('spec/ARB_texture_float', 'GL_ARB_texture_float')
add_texwrap_format_tests(arb_texture_float, 'GL_ARB_texture_float')
add_plain_test(arb_texture_float, 'arb_texture_float-texture-float-formats')
add_msaa_formats_tests(arb_texture_float, 'GL_ARB_texture_float')

ext_texture_integer = Group()
spec['EXT_texture_integer'] = ext_texture_integer
# unsupported for int yet
#add_fbo_clear_extension(ext_texture_integer, 'GL_EXT_texture_integer', 'fbo-clear-formats')
ext_texture_integer['api-drawpixels'] = concurrent_test('ext_texture_integer-api-drawpixels')
ext_texture_integer['api-teximage'] = concurrent_test('ext_texture_integer-api-teximage')
ext_texture_integer['api-readpixels'] = concurrent_test('ext_texture_integer-api-readpixels')
ext_texture_integer['fbo-blending'] = concurrent_test('ext_texture_integer-fbo-blending')
ext_texture_integer['fbo-blending GL_ARB_texture_rg'] = concurrent_test('ext_texture_integer-fbo-blending GL_ARB_texture_rg')
ext_texture_integer['fbo_integer_precision_clear'] = plain_test('ext_texture_integer-fbo_integer_precision_clear')
ext_texture_integer['fbo_integer_readpixels_sint_uint'] = plain_test('ext_texture_integer-fbo_integer_readpixels_sint_uint')
ext_texture_integer['getteximage-clamping'] = concurrent_test('ext_texture_integer-getteximage-clamping')
ext_texture_integer['getteximage-clamping GL_ARB_texture_rg'] = concurrent_test('ext_texture_integer-getteximage-clamping GL_ARB_texture_rg')
ext_texture_integer['texture_integer_glsl130'] = concurrent_test('ext_texture_integer-texture_integer_glsl130')
add_msaa_formats_tests(ext_texture_integer, 'GL_EXT_texture_integer')
add_texwrap_format_tests(ext_texture_integer, 'GL_EXT_texture_integer')
add_plain_test(ext_texture_integer, 'fbo-integer')

arb_texture_rg = Group()
spec['ARB_texture_rg'] = arb_texture_rg
add_shader_test_dir(arb_texture_rg,
                    testsDir + '/spec/arb_texture_rg/execution',
                    recursive=True)
add_fbo_formats_tests('spec/ARB_texture_rg', 'GL_ARB_texture_rg')
add_fbo_formats_tests('spec/ARB_texture_rg', 'GL_ARB_texture_rg-float', '-float')
# unsupported for int yet
#add_fbo_clear_extension(arb_texture_rg, 'GL_ARB_texture_rg-int', 'fbo-clear-formats-int')
add_msaa_formats_tests(arb_texture_rg, 'GL_ARB_texture_rg')
add_msaa_formats_tests(arb_texture_rg, 'GL_ARB_texture_rg-int')
add_msaa_formats_tests(arb_texture_rg, 'GL_ARB_texture_rg-float')
add_texwrap_format_tests(arb_texture_rg, 'GL_ARB_texture_rg')
add_texwrap_format_tests(arb_texture_rg, 'GL_ARB_texture_rg-float', '-float')
add_texwrap_format_tests(arb_texture_rg, 'GL_ARB_texture_rg-int', '-int')
add_fbo_rg(arb_texture_rg, 'GL_RED')
add_fbo_rg(arb_texture_rg, 'GL_R8')
add_fbo_rg(arb_texture_rg, 'GL_R16')
add_fbo_rg(arb_texture_rg, 'GL_RG')
add_fbo_rg(arb_texture_rg, 'GL_RG8')
add_fbo_rg(arb_texture_rg, 'GL_RG16')
add_plain_test(arb_texture_rg, 'depth-tex-modes-rg')
add_plain_test(arb_texture_rg, 'rg-draw-pixels')
add_plain_test(arb_texture_rg, 'rg-teximage-01')
add_plain_test(arb_texture_rg, 'rg-teximage-02')
add_plain_test(arb_texture_rg, 'texture-rg')

arb_texture_rgb10_a2ui = Group()
spec['ARB_texture_rgb10_a2ui'] = arb_texture_rgb10_a2ui
arb_texture_rgb10_a2ui['fbo-blending'] = concurrent_test('ext_texture_integer-fbo-blending GL_ARB_texture_rgb10_a2ui')
add_texwrap_format_tests(arb_texture_rgb10_a2ui, 'GL_ARB_texture_rgb10_a2ui')

ext_texture_shared_exponent = Group()
spec['EXT_texture_shared_exponent'] = ext_texture_shared_exponent
add_fbo_formats_tests('spec/EXT_texture_shared_exponent', 'GL_EXT_texture_shared_exponent')
add_texwrap_format_tests(ext_texture_shared_exponent, 'GL_EXT_texture_shared_exponent')

ext_texture_snorm = Group()
spec['EXT_texture_snorm'] = ext_texture_snorm
add_fbo_formats_tests('spec/EXT_texture_snorm', 'GL_EXT_texture_snorm')
add_msaa_formats_tests(ext_texture_snorm, 'GL_EXT_texture_snorm')
add_texwrap_format_tests(ext_texture_snorm, 'GL_EXT_texture_snorm')

ext_texture_srgb = Group()
spec['EXT_texture_sRGB'] = ext_texture_srgb
add_concurrent_test(ext_texture_compression_s3tc, 'compressedteximage GL_COMPRESSED_SRGB_S3TC_DXT1_EXT')
add_concurrent_test(ext_texture_compression_s3tc, 'compressedteximage GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT')
add_concurrent_test(ext_texture_compression_s3tc, 'compressedteximage GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT')
add_concurrent_test(ext_texture_compression_s3tc, 'compressedteximage GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT')
add_fbo_generatemipmap_extension(ext_texture_srgb, 'GL_EXT_texture_sRGB', 'fbo-generatemipmap-formats')
# TODO: also use GL_ARB_framebuffer_sRGB:
#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
add_msaa_formats_tests(ext_texture_srgb, 'GL_EXT_texture_sRGB')
add_texwrap_format_tests(ext_texture_srgb, 'GL_EXT_texture_sRGB')
add_texwrap_format_tests(ext_texture_srgb, 'GL_EXT_texture_sRGB-s3tc', '-s3tc')
add_plain_test(ext_texture_srgb, 'fbo-srgb')
add_plain_test(ext_texture_srgb, 'tex-srgb')

ext_timer_query = Group()
spec['EXT_timer_query'] = ext_timer_query
ext_timer_query['time-elapsed'] = concurrent_test('ext_timer_query-time-elapsed')
add_plain_test(ext_timer_query, 'timer_query')

arb_timer_query = Group()
spec['ARB_timer_query'] = arb_timer_query
arb_timer_query['query GL_TIMESTAMP'] = concurrent_test('ext_timer_query-time-elapsed timestamp')
arb_timer_query['query-lifetime'] = concurrent_test('ext_timer_query-lifetime')
arb_timer_query['timestamp-get'] = concurrent_test('arb_timer_query-timestamp-get')

ext_transform_feedback = Group()
spec['EXT_transform_feedback'] = ext_transform_feedback
for mode in ['interleaved_ok_base', 'interleaved_ok_range',
             'interleaved_ok_offset', 'interleaved_unbound',
             'interleaved_no_varyings', 'separate_ok_1',
             'separate_unbound_0_1', 'separate_ok_2', 'separate_unbound_0_2',
             'separate_unbound_1_2', 'separate_no_varyings', 'no_prog_active',
             'begin_active', 'useprog_active', 'link_current_active',
             'link_other_active', 'bind_base_active', 'bind_range_active',
             'bind_offset_active', 'end_inactive', 'bind_base_max',
             'bind_range_max', 'bind_offset_max', 'bind_range_size_m4',
             'bind_range_size_0', 'bind_range_size_1', 'bind_range_size_2',
             'bind_range_size_3', 'bind_range_size_5', 'bind_range_offset_1',
             'bind_range_offset_2', 'bind_range_offset_3',
             'bind_range_offset_5', 'bind_offset_offset_1',
             'bind_offset_offset_2', 'bind_offset_offset_3',
             'bind_offset_offset_5', 'not_a_program']:
        test_name = 'api-errors {0}'.format(mode)
        ext_transform_feedback[test_name] = concurrent_test(
                'ext_transform_feedback-{0}'.format(test_name))
for varying in ['gl_Color', 'gl_SecondaryColor', 'gl_TexCoord',
                'gl_FogFragCoord', 'gl_Position', 'gl_PointSize',
                'gl_ClipVertex', 'gl_ClipDistance',
                'gl_ClipDistance[1]-no-subscript',
                'gl_ClipDistance[2]-no-subscript',
                'gl_ClipDistance[3]-no-subscript',
                'gl_ClipDistance[4]-no-subscript',
                'gl_ClipDistance[5]-no-subscript',
                'gl_ClipDistance[6]-no-subscript',
                'gl_ClipDistance[7]-no-subscript',
                'gl_ClipDistance[8]-no-subscript']:
        test_name = 'builtin-varyings {0}'.format(varying)
        ext_transform_feedback[test_name] = concurrent_test(
                'ext_transform_feedback-{0}'.format(test_name))
ext_transform_feedback['buffer-usage'] = concurrent_test('ext_transform_feedback-buffer-usage')
ext_transform_feedback['discard-api'] = concurrent_test('ext_transform_feedback-discard-api')
ext_transform_feedback['discard-bitmap'] = concurrent_test('ext_transform_feedback-discard-bitmap')
ext_transform_feedback['discard-clear'] = concurrent_test('ext_transform_feedback-discard-clear')
ext_transform_feedback['discard-copypixels'] = concurrent_test('ext_transform_feedback-discard-copypixels')
ext_transform_feedback['discard-drawarrays'] = concurrent_test('ext_transform_feedback-discard-drawarrays')
ext_transform_feedback['discard-drawpixels'] = concurrent_test('ext_transform_feedback-discard-drawpixels')
for mode in ['main_binding', 'indexed_binding', 'buffer_start', 'buffer_size']:
        test_name = 'get-buffer-state {0}'.format(mode)
        ext_transform_feedback[test_name] = concurrent_test(
                'ext_transform_feedback-{0}'.format(test_name))
ext_transform_feedback['immediate-reuse'] = concurrent_test('ext_transform_feedback-immediate-reuse')
for mode in ['output', 'prims_generated', 'prims_written']:
        test_name = 'intervening-read {0}'.format(mode)
        ext_transform_feedback[test_name] = concurrent_test(
                'ext_transform_feedback-{0}'.format(test_name))
ext_transform_feedback['max-varyings'] = concurrent_test('ext_transform_feedback-max-varyings')
ext_transform_feedback['nonflat-integral'] = concurrent_test('ext_transform_feedback-nonflat-integral')
ext_transform_feedback['overflow-edge-cases'] = concurrent_test('ext_transform_feedback-overflow-edge-cases')
ext_transform_feedback['position-readback-bufferbase'] = 		concurrent_test('ext_transform_feedback-position')
ext_transform_feedback['position-readback-bufferbase-discard'] = 	concurrent_test('ext_transform_feedback-position discard')
ext_transform_feedback['position-readback-bufferoffset'] = 		concurrent_test('ext_transform_feedback-position offset')
ext_transform_feedback['position-readback-bufferoffset-discard'] = 	concurrent_test('ext_transform_feedback-position offset discard')
ext_transform_feedback['position-readback-bufferrange'] = 		concurrent_test('ext_transform_feedback-position range')
ext_transform_feedback['position-readback-bufferrange-discard'] = 	concurrent_test('ext_transform_feedback-position range discard')

ext_transform_feedback['negative-prims'] = 				concurrent_test('ext_transform_feedback-negative-prims')
ext_transform_feedback['primgen-query transform-feedback-disabled'] = 	concurrent_test('ext_transform_feedback-primgen')

ext_transform_feedback['position-render-bufferbase'] = 			concurrent_test('ext_transform_feedback-position render')
ext_transform_feedback['position-render-bufferbase-discard'] = 		concurrent_test('ext_transform_feedback-position render discard')
ext_transform_feedback['position-render-bufferoffset'] = 		concurrent_test('ext_transform_feedback-position render offset')
ext_transform_feedback['position-render-bufferoffset-discard'] = 	concurrent_test('ext_transform_feedback-position render offset discard')
ext_transform_feedback['position-render-bufferrange'] = 		concurrent_test('ext_transform_feedback-position render range')
ext_transform_feedback['position-render-bufferrange-discard'] = 	concurrent_test('ext_transform_feedback-position render range discard')

ext_transform_feedback['query-primitives_generated-bufferbase'] = 		concurrent_test('ext_transform_feedback-position primgen')
ext_transform_feedback['query-primitives_generated-bufferbase-discard'] = 	concurrent_test('ext_transform_feedback-position primgen discard')
ext_transform_feedback['query-primitives_generated-bufferoffset'] = 		concurrent_test('ext_transform_feedback-position primgen offset')
ext_transform_feedback['query-primitives_generated-bufferoffset-discard'] = 	concurrent_test('ext_transform_feedback-position primgen offset discard')
ext_transform_feedback['query-primitives_generated-bufferrange'] = 		concurrent_test('ext_transform_feedback-position primgen range')
ext_transform_feedback['query-primitives_generated-bufferrange-discard'] = 	concurrent_test('ext_transform_feedback-position primgen range discard')

ext_transform_feedback['query-primitives_written-bufferbase'] = 		concurrent_test('ext_transform_feedback-position primwritten')
ext_transform_feedback['query-primitives_written-bufferbase-discard'] = 	concurrent_test('ext_transform_feedback-position primwritten discard')
ext_transform_feedback['query-primitives_written-bufferoffset'] = 		concurrent_test('ext_transform_feedback-position primwritten offset')
ext_transform_feedback['query-primitives_written-bufferoffset-discard'] = 	concurrent_test('ext_transform_feedback-position primwritten offset discard')
ext_transform_feedback['query-primitives_written-bufferrange'] = 		concurrent_test('ext_transform_feedback-position primwritten range')
ext_transform_feedback['query-primitives_written-bufferrange-discard'] = 	concurrent_test('ext_transform_feedback-position primwritten range discard')

ext_transform_feedback['interleaved-attribs'] = concurrent_test('ext_transform_feedback-interleaved')
ext_transform_feedback['separate-attribs'] = concurrent_test('ext_transform_feedback-separate')
for drawcall in ['arrays', 'elements']:
        for mode in ['triangles', 'lines', 'points']:
                test_name = 'order {0} {1}'.format(drawcall, mode)
                ext_transform_feedback[test_name] = concurrent_test(
                        'ext_transform_feedback-{0}'.format(test_name))
for draw_mode in ['points', 'lines', 'line_loop', 'line_strip',
                  'triangles', 'triangle_strip', 'triangle_fan',
                  'quads', 'quad_strip', 'polygon']:
        for shade_mode in ['monochrome', 'smooth', 'flat_first', 'flat_last', 'wireframe']:
                if shade_mode == 'wireframe' and \
                            draw_mode in ['points', 'lines', 'line_loop', 'line_strip']:
                        continue
                test_name = 'tessellation {0} {1}'.format(
                        draw_mode, shade_mode)
                ext_transform_feedback[test_name] = concurrent_test(
                        'ext_transform_feedback-{0}'.format(test_name))
for alignment in [0, 4, 8, 12]:
        test_name = 'alignment {0}'.format(alignment)
        ext_transform_feedback[test_name] = concurrent_test(
                'ext_transform_feedback-{0}'.format(test_name))

for output_type in ['float', 'vec2', 'vec3', 'vec4', 'mat2', 'mat2x3',
                    'mat2x4', 'mat3x2', 'mat3', 'mat3x4', 'mat4x2', 'mat4x3',
                    'mat4', 'int', 'ivec2', 'ivec3', 'ivec4', 'uint', 'uvec2',
                    'uvec3', 'uvec4']:
        for suffix in ['', '[2]', '[2]-no-subscript']:
                test_name = 'output-type {0}{1}'.format(output_type, suffix)
                ext_transform_feedback[test_name] = concurrent_test(
                        'ext_transform_feedback-{0}'.format(test_name))

for mode in ['discard', 'buffer', 'prims_generated', 'prims_written']:
        test_name = 'generatemipmap {0}'.format(mode)
        ext_transform_feedback[test_name] = concurrent_test(
                'ext_transform_feedback-{0}'.format(test_name))

for test_case in ['base-shrink', 'base-grow', 'offset-shrink', 'offset-grow',
                  'range-shrink', 'range-grow']:
        test_name = 'change-size {0}'.format(test_case)
        ext_transform_feedback[test_name] = concurrent_test(
                'ext_transform_feedback-{0}'.format(test_name))
for api_suffix, possible_options in [('', [[], ['interface']]),
                                     ('_gles3', [[]])]:
        for subtest in ['basic-struct', 'struct-whole-array',
                        'struct-array-elem', 'array-struct',
                        'array-struct-whole-array', 'array-struct-array-elem',
                        'struct-struct', 'array-struct-array-struct']:
                for mode in ['error', 'get', 'run', 'run-no-fs']:
                        for options in possible_options:
                                args = [subtest, mode] + options
                                test_name = 'structs{0} {1}'.format(
                                        api_suffix, ' '.join(args))
                                ext_transform_feedback[test_name] = concurrent_test(
                                        'ext_transform_feedback-{0}'.format(test_name))

arb_transform_feedback2 = Group()
spec['ARB_transform_feedback2'] = arb_transform_feedback2
arb_transform_feedback2['draw-auto'] = PlainExecTest(['arb_transform_feedback2-draw-auto', '-auto'])
arb_transform_feedback2['istranformfeedback'] = PlainExecTest(['arb_transform_feedback2-istransformfeedback', '-auto'])

arb_transform_feedback_instanced = Group()
spec['ARB_transform_feedback_instanced'] = arb_transform_feedback_instanced
arb_transform_feedback_instanced['draw-auto instanced'] = PlainExecTest(['arb_transform_feedback2-draw-auto', '-auto', 'instanced'])

arb_transform_feedback3 = Group()
spec['ARB_transform_feedback3'] = arb_transform_feedback3

for param in ['gl_NextBuffer-1', 'gl_NextBuffer-2', 'gl_SkipComponents1-1',
              'gl_SkipComponents1-2', 'gl_SkipComponents1-3', 'gl_SkipComponents2',
              'gl_SkipComponents3', 'gl_SkipComponents4',
              'gl_NextBuffer-gl_SkipComponents1-gl_NextBuffer',
              'gl_NextBuffer-gl_NextBuffer', 'gl_SkipComponents1234']:
        arb_transform_feedback3[param] = concurrent_test(
                'ext_transform_feedback-output-type {0}'.format(param))

arb_uniform_buffer_object = Group()
spec['ARB_uniform_buffer_object'] = arb_uniform_buffer_object
import_glsl_parser_tests(spec['ARB_uniform_buffer_object'],
			 os.path.join(testsDir, 'spec', 'arb_uniform_buffer_object'),
			 [''])
add_shader_test_dir(spec['ARB_uniform_buffer_object'],
	            os.path.join(testsDir, 'spec', 'arb_uniform_buffer_object'),
		    recursive=True)
arb_uniform_buffer_object['bindbuffer-general-point'] = concurrent_test('arb_uniform_buffer_object-bindbuffer-general-point')
arb_uniform_buffer_object['buffer-targets'] = concurrent_test('arb_uniform_buffer_object-buffer-targets')
arb_uniform_buffer_object['deletebuffers'] = concurrent_test('arb_uniform_buffer_object-deletebuffers')
arb_uniform_buffer_object['dlist'] = concurrent_test('arb_uniform_buffer_object-dlist')
arb_uniform_buffer_object['getactiveuniformblockiv-uniform-block-data-size'] = concurrent_test('arb_uniform_buffer_object-getactiveuniformblockiv-uniform-block-data-size')
arb_uniform_buffer_object['getactiveuniformblockname'] = concurrent_test('arb_uniform_buffer_object-getactiveuniformblockname')
arb_uniform_buffer_object['getactiveuniformname'] = concurrent_test('arb_uniform_buffer_object-getactiveuniformname')
arb_uniform_buffer_object['getactiveuniformsiv-uniform-array-stride'] = concurrent_test('arb_uniform_buffer_object-getactiveuniformsiv-uniform-array-stride')
arb_uniform_buffer_object['getactiveuniformsiv-uniform-block-index'] = concurrent_test('arb_uniform_buffer_object-getactiveuniformsiv-uniform-block-index')
arb_uniform_buffer_object['getactiveuniformsiv-uniform-matrix-stride'] = concurrent_test('arb_uniform_buffer_object-getactiveuniformsiv-uniform-matrix-stride')
arb_uniform_buffer_object['getactiveuniformsiv-uniform-type'] = concurrent_test('arb_uniform_buffer_object-getactiveuniformsiv-uniform-type')
arb_uniform_buffer_object['getintegeri_v'] = concurrent_test('arb_uniform_buffer_object-getintegeri_v')
arb_uniform_buffer_object['getprogramiv'] = concurrent_test('arb_uniform_buffer_object-getprogramiv')
arb_uniform_buffer_object['getuniformblockindex'] = concurrent_test('arb_uniform_buffer_object-getuniformblockindex')
arb_uniform_buffer_object['getuniformindices'] = concurrent_test('arb_uniform_buffer_object-getuniformindices')
arb_uniform_buffer_object['getuniformlocation'] = concurrent_test('arb_uniform_buffer_object-getuniformlocation')
arb_uniform_buffer_object['layout-std140'] = concurrent_test('arb_uniform_buffer_object-layout-std140')
arb_uniform_buffer_object['layout-std140-base-size-and-alignment'] = concurrent_test('arb_uniform_buffer_object-layout-std140-base-size-and-alignment')
arb_uniform_buffer_object['link-mismatch-blocks'] = concurrent_test('arb_uniform_buffer_object-link-mismatch-blocks')
arb_uniform_buffer_object['maxblocks'] = concurrent_test('arb_uniform_buffer_object-maxblocks')
arb_uniform_buffer_object['maxuniformblocksize/vs'] = concurrent_test('arb_uniform_buffer_object-maxuniformblocksize vs')
arb_uniform_buffer_object['maxuniformblocksize/vsexceed'] = concurrent_test('arb_uniform_buffer_object-maxuniformblocksize vsexceed')
arb_uniform_buffer_object['maxuniformblocksize/fs'] = concurrent_test('arb_uniform_buffer_object-maxuniformblocksize fs')
arb_uniform_buffer_object['maxuniformblocksize/fsexceed'] = concurrent_test('arb_uniform_buffer_object-maxuniformblocksize fsexceed')
arb_uniform_buffer_object['minmax'] = concurrent_test('arb_uniform_buffer_object-minmax')
arb_uniform_buffer_object['negative-bindbuffer-index'] = concurrent_test('arb_uniform_buffer_object-negative-bindbuffer-index')
arb_uniform_buffer_object['negative-bindbuffer-target'] = concurrent_test('arb_uniform_buffer_object-negative-bindbuffer-target')
arb_uniform_buffer_object['negative-bindbufferrange-range'] = concurrent_test('arb_uniform_buffer_object-negative-bindbufferrange-range')
arb_uniform_buffer_object['negative-getactiveuniformblockiv'] = concurrent_test('arb_uniform_buffer_object-negative-getactiveuniformblockiv')
arb_uniform_buffer_object['negative-getactiveuniformsiv'] = concurrent_test('arb_uniform_buffer_object-negative-getactiveuniformsiv')
arb_uniform_buffer_object['referenced-by-shader'] = concurrent_test('arb_uniform_buffer_object-referenced-by-shader')
arb_uniform_buffer_object['row-major'] = concurrent_test('arb_uniform_buffer_object-row-major')
arb_uniform_buffer_object['uniformblockbinding'] = concurrent_test('arb_uniform_buffer_object-uniformblockbinding')

ati_draw_buffers = Group()
spec['ATI_draw_buffers'] = ati_draw_buffers
add_plain_test(ati_draw_buffers, 'ati_draw_buffers-arbfp')
ati_draw_buffers['arbfp-no-index'] = PlainExecTest(['ati_draw_buffers-arbfp-no-index', '-auto'])
ati_draw_buffers['arbfp-no-option'] = PlainExecTest(['ati_draw_buffers-arbfp-no-option', '-auto'])

ati_envmap_bumpmap = Group()
spec['ATI_envmap_bumpmap'] = ati_envmap_bumpmap
add_plain_test(ati_envmap_bumpmap, 'ati_envmap_bumpmap-bump')

arb_instanced_arrays = Group()
spec['ARB_instanced_arrays'] = arb_instanced_arrays
add_plain_test(arb_instanced_arrays, 'instanced_arrays')
add_single_param_test_set(arb_instanced_arrays, 'instanced_arrays', 'vbo')

arb_internalformat_query = Group()
spec['ARB_internalformat_query'] = arb_internalformat_query
arb_internalformat_query['misc. API error checks'] = concurrent_test('arb_internalformat_query-api-errors')
arb_internalformat_query['buffer over-run checks'] = concurrent_test('arb_internalformat_query-overrun')
arb_internalformat_query['minmax'] = concurrent_test('arb_internalformat_query-minmax')

arb_map_buffer_range = Group()
spec['ARB_map_buffer_range'] = arb_map_buffer_range
add_plain_test(arb_map_buffer_range, 'map_buffer_range_error_check')
add_plain_test(arb_map_buffer_range, 'map_buffer_range_test')
arb_map_buffer_range['MAP_INVALIDATE_RANGE_BIT offset=0'] = concurrent_test('map_buffer_range-invalidate MAP_INVALIDATE_RANGE_BIT offset=0')
arb_map_buffer_range['MAP_INVALIDATE_RANGE_BIT increment-offset'] = concurrent_test('map_buffer_range-invalidate MAP_INVALIDATE_RANGE_BIT increment-offset')
arb_map_buffer_range['MAP_INVALIDATE_RANGE_BIT decrement-offset'] = concurrent_test('map_buffer_range-invalidate MAP_INVALIDATE_RANGE_BIT decrement-offset')
arb_map_buffer_range['MAP_INVALIDATE_BUFFER_BIT offset=0'] = concurrent_test('map_buffer_range-invalidate MAP_INVALIDATE_BUFFER_BIT offset=0')
arb_map_buffer_range['MAP_INVALIDATE_BUFFER_BIT increment-offset'] = concurrent_test('map_buffer_range-invalidate MAP_INVALIDATE_BUFFER_BIT increment-offset')
arb_map_buffer_range['MAP_INVALIDATE_BUFFER_BIT decrement-offset'] = concurrent_test('map_buffer_range-invalidate MAP_INVALIDATE_BUFFER_BIT decrement-offset')

arb_multisample = Group()
spec['ARB_multisample'] = arb_multisample
arb_multisample['beginend'] = concurrent_test('arb_multisample-beginend')
arb_multisample['pushpop'] = concurrent_test('arb_multisample-pushpop')

arb_seamless_cube_map = Group()
spec['ARB_seamless_cube_map'] = arb_seamless_cube_map
add_plain_test(arb_seamless_cube_map, 'arb_seamless_cubemap')

amd_seamless_cubemap_per_texture = Group()
spec['AMD_seamless_cubemap_per_texture'] = amd_seamless_cubemap_per_texture
add_plain_test(amd_seamless_cubemap_per_texture, 'amd_seamless_cubemap_per_texture')

ext_fog_coord = Group()
spec['EXT_fog_coord'] = ext_fog_coord
add_plain_test(ext_fog_coord, 'ext_fog_coord-modes')

nv_texture_barrier = Group()
spec['NV_texture_barrier'] = nv_texture_barrier
add_plain_test(nv_texture_barrier, 'blending-in-shader')

nv_conditional_render = Group()
spec['NV_conditional_render'] = nv_conditional_render
nv_conditional_render['begin-while-active'] = concurrent_test('nv_conditional_render-begin-while-active')
nv_conditional_render['begin-zero'] = concurrent_test('nv_conditional_render-begin-zero')
nv_conditional_render['bitmap'] = PlainExecTest(['nv_conditional_render-bitmap', '-auto'])
nv_conditional_render['blitframebuffer'] = PlainExecTest(['nv_conditional_render-blitframebuffer', '-auto'])
nv_conditional_render['clear'] = PlainExecTest(['nv_conditional_render-clear', '-auto'])
nv_conditional_render['copypixels'] = PlainExecTest(['nv_conditional_render-copypixels', '-auto'])
nv_conditional_render['copyteximage'] = PlainExecTest(['nv_conditional_render-copyteximage', '-auto'])
nv_conditional_render['copytexsubimage'] = PlainExecTest(['nv_conditional_render-copytexsubimage', '-auto'])
nv_conditional_render['dlist'] = PlainExecTest(['nv_conditional_render-dlist', '-auto'])
nv_conditional_render['drawpixels'] = PlainExecTest(['nv_conditional_render-drawpixels', '-auto'])
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

spec['OES_standard_derivatives'] = Group()
import_glsl_parser_tests(spec['OES_standard_derivatives'],
			 os.path.join(testsDir, 'spec', 'oes_standard_derivatives'),
			 ['compiler'])

arb_copy_buffer = Group()
spec['ARB_copy_buffer'] = arb_copy_buffer
add_plain_test(arb_copy_buffer, 'copy_buffer_coherency')
add_plain_test(arb_copy_buffer, 'copybuffersubdata')
arb_copy_buffer['dlist'] = concurrent_test('arb_copy_buffer-dlist')
arb_copy_buffer['get'] = concurrent_test('arb_copy_buffer-get')
arb_copy_buffer['negative-bound-zero'] = concurrent_test('arb_copy_buffer-negative-bound-zero')
arb_copy_buffer['negative-bounds'] = concurrent_test('arb_copy_buffer-negative-bounds')
arb_copy_buffer['negative-mapped'] = concurrent_test('arb_copy_buffer-negative-mapped')
arb_copy_buffer['overlap'] = concurrent_test('arb_copy_buffer-overlap')
arb_copy_buffer['targets'] = concurrent_test('arb_copy_buffer-targets')

arb_half_float_vertex = Group()
spec['ARB_half_float_vertex'] = arb_half_float_vertex
add_plain_test(arb_half_float_vertex, 'draw-vertices-half-float')
arb_half_float_vertex['draw-vertices-half-float-user'] = PlainExecTest(['draw-vertices-half-float', '-auto', 'user'])

arb_vertex_type_2_10_10_10_rev = Group()
spec['ARB_vertex_type_2_10_10_10_rev'] = arb_vertex_type_2_10_10_10_rev
add_plain_test(arb_vertex_type_2_10_10_10_rev, 'draw-vertices-2101010')
arb_vertex_type_2_10_10_10_rev['attribs'] = concurrent_test('attribs GL_ARB_vertex_type_2_10_10_10_rev')

arb_draw_buffers = Group()
spec['ARB_draw_buffers'] = arb_draw_buffers
add_plain_test(arb_draw_buffers, 'arb_draw_buffers-state_change')

ext_draw_buffers2 = Group()
spec['EXT_draw_buffers2'] = ext_draw_buffers2
add_plain_test(ext_draw_buffers2, 'fbo-drawbuffers2-blend')
add_plain_test(ext_draw_buffers2, 'fbo-drawbuffers2-colormask')
add_plain_test(ext_draw_buffers2, 'fbo-drawbuffers2-colormask clear')

arb_draw_buffers_blend = Group()
spec['ARB_draw_buffers_blend'] = arb_draw_buffers_blend
add_plain_test(arb_draw_buffers_blend, 'fbo-draw-buffers-blend')

arb_blend_func_extended = Group()
spec['ARB_blend_func_extended'] = arb_blend_func_extended
add_plain_test(arb_blend_func_extended, 'arb_blend_func_extended-bindfragdataindexed-invalid-parameters')
add_plain_test(arb_blend_func_extended, 'arb_blend_func_extended-blend-api')
add_plain_test(arb_blend_func_extended, 'arb_blend_func_extended-error-at-begin')
add_plain_test(arb_blend_func_extended, 'arb_blend_func_extended-getfragdataindex')
add_plain_test(arb_blend_func_extended, 'arb_blend_func_extended-fbo-extended-blend')
add_plain_test(arb_blend_func_extended, 'arb_blend_func_extended-fbo-extended-blend-explicit')

apple_object_purgeable = Group()
spec['APPLE_object_purgeable'] = apple_object_purgeable
add_plain_test(apple_object_purgeable, 'object_purgeable-api-pbo')
add_plain_test(apple_object_purgeable, 'object_purgeable-api-texture')
add_plain_test(apple_object_purgeable, 'object_purgeable-api-vbo')

oes_read_format = Group()
spec['OES_read_format'] = oes_read_format
add_plain_test(oes_read_format, 'oes-read-format')

nv_primitive_restart = Group()
spec['NV_primitive_restart'] = nv_primitive_restart
add_single_param_test_set(
    nv_primitive_restart,
    'primitive-restart',
    "DISABLE_VBO",
    "VBO_VERTEX_ONLY", "VBO_INDEX_ONLY",
    "VBO_SEPARATE_VERTEX_AND_INDEX", "VBO_COMBINED_VERTEX_AND_INDEX")

ext_provoking_vertex = Group()
spec['EXT_provoking_vertex'] = ext_provoking_vertex
add_plain_test(ext_provoking_vertex, 'provoking-vertex')

ext_texture_lod_bias = Group()
spec['EXT_texture_lod_bias'] = ext_texture_lod_bias
add_plain_test(ext_texture_lod_bias, 'lodbias')

sgis_generate_mipmap = Group()
spec['SGIS_generate_mipmap'] = sgis_generate_mipmap
add_plain_test(sgis_generate_mipmap, 'gen-nonzero-unit')
add_plain_test(sgis_generate_mipmap, 'gen-teximage')
add_plain_test(sgis_generate_mipmap, 'gen-texsubimage')

arb_map_buffer_alignment = Group()
spec['ARB_map_buffer_alignment'] = arb_map_buffer_alignment
add_plain_test(arb_map_buffer_alignment, 'arb_map_buffer_alignment-sanity_test')

arb_geometry_shader4 = Group()
spec['ARB_geometry_shader4'] = arb_geometry_shader4
add_shader_test_dir(spec['ARB_geometry_shader4'],
                    os.path.join(testsDir, 'spec', 'arb_geometry_shader4'),
                    recursive=True)
import_glsl_parser_tests(spec['ARB_geometry_shader4'],
                         os.path.join(testsDir, 'spec', 'arb_geometry_shader4'),
                         ['compiler'])

# group glslparsertest ------------------------------------------------------
glslparsertest = Group()
# Add all shader source files in the directories below.
for filename in os.listdir(testsDir + '/glslparsertest/shaders'):
	ext = filename.rsplit('.')[-1]
	if ext in ['vert', 'geo', 'frag']:
		add_glsl_parser_test(glslparsertest, path.join(testsDir, 'glslparsertest/shaders', filename), filename)
del glslparsertest['CorrectPreprocess11.frag']
for filename in os.listdir(testsDir + '/glslparsertest/glsl2'):
	ext = filename.rsplit('.')[-1]
	if ext in ['vert', 'geo', 'frag']:
		add_glsl_parser_test(glslparsertest, path.join(testsDir, 'glslparsertest/glsl2', filename), 'glsl2/' + filename)
# end group glslparsertest ---------------------------------------------------

hiz = Group()
add_plain_test(hiz, 'hiz-depth-stencil-test-fbo-d0-s8')
add_plain_test(hiz, 'hiz-depth-stencil-test-fbo-d24-s0')
add_plain_test(hiz, 'hiz-depth-stencil-test-fbo-d24-s8')
add_plain_test(hiz, 'hiz-depth-stencil-test-fbo-d24s8')
add_plain_test(hiz, 'hiz-depth-read-fbo-d24-s0')
add_plain_test(hiz, 'hiz-depth-read-fbo-d24-s8')
add_plain_test(hiz, 'hiz-depth-read-fbo-d24s8')
add_plain_test(hiz, 'hiz-depth-read-window-stencil0')
add_plain_test(hiz, 'hiz-depth-read-window-stencil1')
add_plain_test(hiz, 'hiz-depth-test-fbo-d24-s0')
add_plain_test(hiz, 'hiz-depth-test-fbo-d24-s8')
add_plain_test(hiz, 'hiz-depth-test-fbo-d24s8')
add_plain_test(hiz, 'hiz-depth-test-window-stencil0')
add_plain_test(hiz, 'hiz-depth-test-window-stencil1')
add_plain_test(hiz, 'hiz-stencil-read-fbo-d0-s8')
add_plain_test(hiz, 'hiz-stencil-read-fbo-d24-s8')
add_plain_test(hiz, 'hiz-stencil-read-fbo-d24s8')
add_plain_test(hiz, 'hiz-stencil-read-window-depth0')
add_plain_test(hiz, 'hiz-stencil-read-window-depth1')
add_plain_test(hiz, 'hiz-stencil-test-fbo-d0-s8')
add_plain_test(hiz, 'hiz-stencil-test-fbo-d24-s8')
add_plain_test(hiz, 'hiz-stencil-test-fbo-d24s8')
add_plain_test(hiz, 'hiz-stencil-test-window-depth0')
add_plain_test(hiz, 'hiz-stencil-test-window-depth1')

asmparsertest = Group()
def add_asmparsertest(group, shader):
	test = PlainExecTest(['asmparsertest', '-auto', group, testsDir + '/asmparsertest/shaders/' + group + '/' + shader])
	test.runConcurrent = True
	asmparsertest[group + '/' + shader] = test

add_asmparsertest('ARBfp1.0', 'abs-01.txt')
add_asmparsertest('ARBfp1.0', 'abs-02.txt')
add_asmparsertest('ARBfp1.0', 'abs-03.txt')
add_asmparsertest('ARBfp1.0', 'condition_code-01.txt')
add_asmparsertest('ARBfp1.0', 'cos-01.txt')
add_asmparsertest('ARBfp1.0', 'cos-02.txt')
add_asmparsertest('ARBfp1.0', 'cos-03.txt')
add_asmparsertest('ARBfp1.0', 'cos-04.txt')
add_asmparsertest('ARBfp1.0', 'cos-05.txt')
add_asmparsertest('ARBfp1.0', 'ddx-01.txt')
add_asmparsertest('ARBfp1.0', 'ddx-02.txt')
add_asmparsertest('ARBfp1.0', 'ddy-01.txt')
add_asmparsertest('ARBfp1.0', 'ddy-02.txt')
add_asmparsertest('ARBfp1.0', 'depth_range-01.txt')
add_asmparsertest('ARBfp1.0', 'fog-01.txt')
add_asmparsertest('ARBfp1.0', 'fog-02.txt')
add_asmparsertest('ARBfp1.0', 'fog-03.txt')
add_asmparsertest('ARBfp1.0', 'fog-04.txt')
add_asmparsertest('ARBfp1.0', 'option-01.txt')
add_asmparsertest('ARBfp1.0', 'precision_hint-01.txt')
add_asmparsertest('ARBfp1.0', 'precision_hint-02.txt')
add_asmparsertest('ARBfp1.0', 'precision_hint-03.txt')
add_asmparsertest('ARBfp1.0', 'precision_hint-04.txt')
add_asmparsertest('ARBfp1.0', 'precision_hint-05.txt')
add_asmparsertest('ARBfp1.0', 'reserved_words-01.txt')
add_asmparsertest('ARBfp1.0', 'result-01.txt')
add_asmparsertest('ARBfp1.0', 'result-02.txt')
add_asmparsertest('ARBfp1.0', 'result-03.txt')
add_asmparsertest('ARBfp1.0', 'result-04.txt')
add_asmparsertest('ARBfp1.0', 'result-05.txt')
add_asmparsertest('ARBfp1.0', 'result-06.txt')
add_asmparsertest('ARBfp1.0', 'result-07.txt')
add_asmparsertest('ARBfp1.0', 'result-08.txt')
add_asmparsertest('ARBfp1.0', 'result-09.txt')
add_asmparsertest('ARBfp1.0', 'result-10.txt')
add_asmparsertest('ARBfp1.0', 'result-11.txt')
add_asmparsertest('ARBfp1.0', 'shadow-01.txt')
add_asmparsertest('ARBfp1.0', 'shadow-02.txt')
add_asmparsertest('ARBfp1.0', 'shadow-03.txt')
add_asmparsertest('ARBfp1.0', 'sincos-01.txt')
add_asmparsertest('ARBfp1.0', 'sincos-02.txt')
add_asmparsertest('ARBfp1.0', 'sincos-03.txt')
add_asmparsertest('ARBfp1.0', 'sincos-04.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-01.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-02.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-03.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-04.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-05.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-06.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-07.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-08.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-09.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-10.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-11.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-12.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-13.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-14.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-15.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-16.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-17.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-18.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-19.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-20.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-21.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-22.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-23.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-24.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-25.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-26.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-27.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-28.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-29.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-30.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-31.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-32.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-33.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-34.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-35.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-36.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-37.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-38.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-39.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-40.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-41.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-42.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-43.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-44.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-45.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-46.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-47.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-48.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-49.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-50.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-51.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-52.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-53.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-54.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-55.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-56.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-57.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-58.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-59.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-60.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-61.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-62.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-63.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-64.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-65.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-66.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-67.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-68.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-69.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-70.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-71.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-72.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-73.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-74.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-75.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-76.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-77.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-78.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-79.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-80.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-81.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-82.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-83.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-84.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-85.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-86.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-87.txt')
add_asmparsertest('ARBfp1.0', 'size_specifier-88.txt')
add_asmparsertest('ARBfp1.0', 'swz-01.txt')
add_asmparsertest('ARBfp1.0', 'swz-02.txt')
add_asmparsertest('ARBfp1.0', 'swz-03.txt')
add_asmparsertest('ARBfp1.0', 'swz-04.txt')
add_asmparsertest('ARBfp1.0', 'swz-05.txt')
add_asmparsertest('ARBfp1.0', 'swz-06.txt')
add_asmparsertest('ARBfp1.0', 'swz-07.txt')
add_asmparsertest('ARBfp1.0', 'txd-01.txt')
add_asmparsertest('ARBfp1.0', 'txd-02.txt')
add_asmparsertest('ARBfp1.0', 'txd-03.txt')

add_asmparsertest('ARBvp1.0', 'abs-02.txt')
add_asmparsertest('ARBvp1.0', 'abs-03.txt')
add_asmparsertest('ARBvp1.0', 'abs.txt')
add_asmparsertest('ARBvp1.0', 'address-01.txt')
add_asmparsertest('ARBvp1.0', 'address-02.txt')
add_asmparsertest('ARBvp1.0', 'address-03.txt')
add_asmparsertest('ARBvp1.0', 'address-04.txt')
add_asmparsertest('ARBvp1.0', 'address-05.txt')
add_asmparsertest('ARBvp1.0', 'address-06.txt')
add_asmparsertest('ARBvp1.0', 'address-07.txt')
add_asmparsertest('ARBvp1.0', 'address-08.txt')
add_asmparsertest('ARBvp1.0', 'address-09.txt')
add_asmparsertest('ARBvp1.0', 'address-10.txt')
add_asmparsertest('ARBvp1.0', 'address-11.txt')
add_asmparsertest('ARBvp1.0', 'add.txt')
add_asmparsertest('ARBvp1.0', 'alias-01.txt')
add_asmparsertest('ARBvp1.0', 'alias-02.txt')
add_asmparsertest('ARBvp1.0', 'all_state-01.txt')
add_asmparsertest('ARBvp1.0', 'all_state-02.txt')
add_asmparsertest('ARBvp1.0', 'all_state-03.txt')
add_asmparsertest('ARBvp1.0', 'all_state-04.txt')
add_asmparsertest('ARBvp1.0', 'all_state-05.txt')
add_asmparsertest('ARBvp1.0', 'all_state-06.txt')
add_asmparsertest('ARBvp1.0', 'all_state-07.txt')
add_asmparsertest('ARBvp1.0', 'all_state-08.txt')
add_asmparsertest('ARBvp1.0', 'all_state-09.txt')
add_asmparsertest('ARBvp1.0', 'all_state-10.txt')
add_asmparsertest('ARBvp1.0', 'all_state-11.txt')
add_asmparsertest('ARBvp1.0', 'all_state-12.txt')
add_asmparsertest('ARBvp1.0', 'all_state-13.txt')
add_asmparsertest('ARBvp1.0', 'all_state-14.txt')
add_asmparsertest('ARBvp1.0', 'all_state-15.txt')
add_asmparsertest('ARBvp1.0', 'all_state-16.txt')
add_asmparsertest('ARBvp1.0', 'all_state-17.txt')
add_asmparsertest('ARBvp1.0', 'all_state-18.txt')
add_asmparsertest('ARBvp1.0', 'ara-01.txt')
add_asmparsertest('ARBvp1.0', 'ara-02.txt')
add_asmparsertest('ARBvp1.0', 'ara-03.txt')
add_asmparsertest('ARBvp1.0', 'ara-04.txt')
add_asmparsertest('ARBvp1.0', 'arbfp.txt')
add_asmparsertest('ARBvp1.0', 'arl-01.txt')
add_asmparsertest('ARBvp1.0', 'arl-02.txt')
add_asmparsertest('ARBvp1.0', 'arl-03.txt')
add_asmparsertest('ARBvp1.0', 'arl-04.txt')
add_asmparsertest('ARBvp1.0', 'arl-05.txt')
add_asmparsertest('ARBvp1.0', 'array_range-01.txt')
add_asmparsertest('ARBvp1.0', 'array_range-02.txt')
add_asmparsertest('ARBvp1.0', 'array_range-03.txt')
add_asmparsertest('ARBvp1.0', 'array_range-04.txt')
add_asmparsertest('ARBvp1.0', 'array_range-05.txt')
add_asmparsertest('ARBvp1.0', 'array_range-06.txt')
add_asmparsertest('ARBvp1.0', 'array_range-07.txt')
add_asmparsertest('ARBvp1.0', 'astack-01.txt')
add_asmparsertest('ARBvp1.0', 'astack-02.txt')
add_asmparsertest('ARBvp1.0', 'astack-03.txt')
add_asmparsertest('ARBvp1.0', 'astack-04.txt')
add_asmparsertest('ARBvp1.0', 'astack-05.txt')
add_asmparsertest('ARBvp1.0', 'astack-06.txt')
add_asmparsertest('ARBvp1.0', 'astack-07.txt')
add_asmparsertest('ARBvp1.0', 'astack-08.txt')
add_asmparsertest('ARBvp1.0', 'astack-09.txt')
add_asmparsertest('ARBvp1.0', 'attrib-01.txt')
add_asmparsertest('ARBvp1.0', 'attrib-02.txt')
add_asmparsertest('ARBvp1.0', 'attrib-03.txt')
add_asmparsertest('ARBvp1.0', 'attrib-04.txt')
add_asmparsertest('ARBvp1.0', 'bra-01.txt')
add_asmparsertest('ARBvp1.0', 'bra-02.txt')
add_asmparsertest('ARBvp1.0', 'bra-03.txt')
add_asmparsertest('ARBvp1.0', 'clipdistance-01.txt')
add_asmparsertest('ARBvp1.0', 'clipdistance-02.txt')
add_asmparsertest('ARBvp1.0', 'clipdistance-03.txt')
add_asmparsertest('ARBvp1.0', 'clipdistance-04.txt')
add_asmparsertest('ARBvp1.0', 'cos-01.txt')
add_asmparsertest('ARBvp1.0', 'cos-02.txt')
add_asmparsertest('ARBvp1.0', 'cos-03.txt')
add_asmparsertest('ARBvp1.0', 'dp3.txt')
add_asmparsertest('ARBvp1.0', 'dp4.txt')
add_asmparsertest('ARBvp1.0', 'dph.txt')
add_asmparsertest('ARBvp1.0', 'dst.txt')
add_asmparsertest('ARBvp1.0', 'ex2.txt')
add_asmparsertest('ARBvp1.0', 'flr.txt')
add_asmparsertest('ARBvp1.0', 'frc.txt')
add_asmparsertest('ARBvp1.0', 'issue-70.txt')
add_asmparsertest('ARBvp1.0', 'issue-74.txt')
add_asmparsertest('ARBvp1.0', 'issue-75.txt')
add_asmparsertest('ARBvp1.0', 'lg2.txt')
add_asmparsertest('ARBvp1.0', 'lit.txt')
add_asmparsertest('ARBvp1.0', 'mad.txt')
add_asmparsertest('ARBvp1.0', 'matrix-01.txt')
add_asmparsertest('ARBvp1.0', 'max.txt')
add_asmparsertest('ARBvp1.0', 'min.txt')
add_asmparsertest('ARBvp1.0', 'mov.txt')
add_asmparsertest('ARBvp1.0', 'mul.txt')
add_asmparsertest('ARBvp1.0', 'numbers-01.txt')
add_asmparsertest('ARBvp1.0', 'numbers-02.txt')
add_asmparsertest('ARBvp1.0', 'numbers-03.txt')
add_asmparsertest('ARBvp1.0', 'numbers-04.txt')
add_asmparsertest('ARBvp1.0', 'numbers-05.txt')
add_asmparsertest('ARBvp1.0', 'numbers-06.txt')
add_asmparsertest('ARBvp1.0', 'numbers-07.txt')
add_asmparsertest('ARBvp1.0', 'option-01.txt')
add_asmparsertest('ARBvp1.0', 'output-01.txt')
add_asmparsertest('ARBvp1.0', 'output-02.txt')
add_asmparsertest('ARBvp1.0', 'param-01.txt')
add_asmparsertest('ARBvp1.0', 'param-02.txt')
add_asmparsertest('ARBvp1.0', 'param-03.txt')
add_asmparsertest('ARBvp1.0', 'param-04.txt')
add_asmparsertest('ARBvp1.0', 'param-05.txt')
add_asmparsertest('ARBvp1.0', 'param-06.txt')
add_asmparsertest('ARBvp1.0', 'param-07.txt')
add_asmparsertest('ARBvp1.0', 'param-08.txt')
add_asmparsertest('ARBvp1.0', 'position_invariant-01.txt')
add_asmparsertest('ARBvp1.0', 'position_invariant-02.txt')
add_asmparsertest('ARBvp1.0', 'pow.txt')
add_asmparsertest('ARBvp1.0', 'rcp-01.txt')
add_asmparsertest('ARBvp1.0', 'rcp-02.txt')
add_asmparsertest('ARBvp1.0', 'rcp-03.txt')
add_asmparsertest('ARBvp1.0', 'rcp-04.txt')
add_asmparsertest('ARBvp1.0', 'rcp-05.txt')
add_asmparsertest('ARBvp1.0', 'rcp-06.txt')
add_asmparsertest('ARBvp1.0', 'rcp-07.txt')
add_asmparsertest('ARBvp1.0', 'reserved_word-01.txt')
add_asmparsertest('ARBvp1.0', 'result-01.txt')
add_asmparsertest('ARBvp1.0', 'result-02.txt')
add_asmparsertest('ARBvp1.0', 'rsq.txt')
add_asmparsertest('ARBvp1.0', 'seq-01.txt')
add_asmparsertest('ARBvp1.0', 'seq-02.txt')
add_asmparsertest('ARBvp1.0', 'sfl-01.txt')
add_asmparsertest('ARBvp1.0', 'sfl-02.txt')
add_asmparsertest('ARBvp1.0', 'sge.txt')
add_asmparsertest('ARBvp1.0', 'sgt-01.txt')
add_asmparsertest('ARBvp1.0', 'sgt-02.txt')
add_asmparsertest('ARBvp1.0', 'sin-01.txt')
add_asmparsertest('ARBvp1.0', 'sin-02.txt')
add_asmparsertest('ARBvp1.0', 'sin-03.txt')
add_asmparsertest('ARBvp1.0', 'sle-01.txt')
add_asmparsertest('ARBvp1.0', 'sle-02.txt')
add_asmparsertest('ARBvp1.0', 'slt.txt')
add_asmparsertest('ARBvp1.0', 'sne-01.txt')
add_asmparsertest('ARBvp1.0', 'sne-02.txt')
add_asmparsertest('ARBvp1.0', 'ssg-01.txt')
add_asmparsertest('ARBvp1.0', 'ssg-02.txt')
add_asmparsertest('ARBvp1.0', 'str-01.txt')
add_asmparsertest('ARBvp1.0', 'str-02.txt')
add_asmparsertest('ARBvp1.0', 'sub.txt')
add_asmparsertest('ARBvp1.0', 'swz-01.txt')
add_asmparsertest('ARBvp1.0', 'swz-02.txt')
add_asmparsertest('ARBvp1.0', 'swz-03.txt')
add_asmparsertest('ARBvp1.0', 'swz-04.txt')
add_asmparsertest('ARBvp1.0', 'swz-05.txt')
add_asmparsertest('ARBvp1.0', 'tex-01.txt')
add_asmparsertest('ARBvp1.0', 'tex-02.txt')
add_asmparsertest('ARBvp1.0', 'tex-03.txt')
add_asmparsertest('ARBvp1.0', 'tex-04.txt')
add_asmparsertest('ARBvp1.0', 'tex-05.txt')
add_asmparsertest('ARBvp1.0', 'tex-06.txt')
add_asmparsertest('ARBvp1.0', 'tex-07.txt')
add_asmparsertest('ARBvp1.0', 'tex-08.txt')
add_asmparsertest('ARBvp1.0', 'tex-09.txt')
add_asmparsertest('ARBvp1.0', 'tex-10.txt')
add_asmparsertest('ARBvp1.0', 'tex-11.txt')
add_asmparsertest('ARBvp1.0', 'tex-12.txt')
add_asmparsertest('ARBvp1.0', 'tex-13.txt')
add_asmparsertest('ARBvp1.0', 'tex-14.txt')
add_asmparsertest('ARBvp1.0', 'tex-15.txt')
add_asmparsertest('ARBvp1.0', 'tex-16.txt')
add_asmparsertest('ARBvp1.0', 'tex-17.txt')
add_asmparsertest('ARBvp1.0', 'tex-18.txt')
add_asmparsertest('ARBvp1.0', 'tex-19.txt')
add_asmparsertest('ARBvp1.0', 'tex-20.txt')
add_asmparsertest('ARBvp1.0', 'txb-01.txt')
add_asmparsertest('ARBvp1.0', 'txb-02.txt')
add_asmparsertest('ARBvp1.0', 'txb-03.txt')
add_asmparsertest('ARBvp1.0', 'txb-04.txt')
add_asmparsertest('ARBvp1.0', 'txb-05.txt')
add_asmparsertest('ARBvp1.0', 'txb-06.txt')
add_asmparsertest('ARBvp1.0', 'txb-07.txt')
add_asmparsertest('ARBvp1.0', 'txb-08.txt')
add_asmparsertest('ARBvp1.0', 'txb-09.txt')
add_asmparsertest('ARBvp1.0', 'txb-10.txt')
add_asmparsertest('ARBvp1.0', 'txb-11.txt')
add_asmparsertest('ARBvp1.0', 'txb-12.txt')
add_asmparsertest('ARBvp1.0', 'txb-13.txt')
add_asmparsertest('ARBvp1.0', 'txb-14.txt')
add_asmparsertest('ARBvp1.0', 'txb-15.txt')
add_asmparsertest('ARBvp1.0', 'txb-16.txt')
add_asmparsertest('ARBvp1.0', 'txb-17.txt')
add_asmparsertest('ARBvp1.0', 'txb-18.txt')
add_asmparsertest('ARBvp1.0', 'txb-19.txt')
add_asmparsertest('ARBvp1.0', 'txb-20.txt')
add_asmparsertest('ARBvp1.0', 'txd-01.txt')
add_asmparsertest('ARBvp1.0', 'txd-02.txt')
add_asmparsertest('ARBvp1.0', 'txd-03.txt')
add_asmparsertest('ARBvp1.0', 'txd-04.txt')
add_asmparsertest('ARBvp1.0', 'txd-05.txt')
add_asmparsertest('ARBvp1.0', 'txd-06.txt')
add_asmparsertest('ARBvp1.0', 'txd-07.txt')
add_asmparsertest('ARBvp1.0', 'txd-08.txt')
add_asmparsertest('ARBvp1.0', 'txd-09.txt')
add_asmparsertest('ARBvp1.0', 'txd-10.txt')
add_asmparsertest('ARBvp1.0', 'txd-11.txt')
add_asmparsertest('ARBvp1.0', 'txd-12.txt')
add_asmparsertest('ARBvp1.0', 'txd-13.txt')
add_asmparsertest('ARBvp1.0', 'txd-14.txt')
add_asmparsertest('ARBvp1.0', 'txd-15.txt')
add_asmparsertest('ARBvp1.0', 'txd-16.txt')
add_asmparsertest('ARBvp1.0', 'txd-17.txt')
add_asmparsertest('ARBvp1.0', 'txd-18.txt')
add_asmparsertest('ARBvp1.0', 'txd-19.txt')
add_asmparsertest('ARBvp1.0', 'txd-20.txt')
add_asmparsertest('ARBvp1.0', 'txf-01.txt')
add_asmparsertest('ARBvp1.0', 'txf-02.txt')
add_asmparsertest('ARBvp1.0', 'txf-03.txt')
add_asmparsertest('ARBvp1.0', 'txf-04.txt')
add_asmparsertest('ARBvp1.0', 'txf-05.txt')
add_asmparsertest('ARBvp1.0', 'txf-06.txt')
add_asmparsertest('ARBvp1.0', 'txf-07.txt')
add_asmparsertest('ARBvp1.0', 'txf-08.txt')
add_asmparsertest('ARBvp1.0', 'txf-09.txt')
add_asmparsertest('ARBvp1.0', 'txf-10.txt')
add_asmparsertest('ARBvp1.0', 'txf-11.txt')
add_asmparsertest('ARBvp1.0', 'txf-12.txt')
add_asmparsertest('ARBvp1.0', 'txf-13.txt')
add_asmparsertest('ARBvp1.0', 'txf-14.txt')
add_asmparsertest('ARBvp1.0', 'txf-15.txt')
add_asmparsertest('ARBvp1.0', 'txf-16.txt')
add_asmparsertest('ARBvp1.0', 'txf-17.txt')
add_asmparsertest('ARBvp1.0', 'txf-18.txt')
add_asmparsertest('ARBvp1.0', 'txf-19.txt')
add_asmparsertest('ARBvp1.0', 'txf-20.txt')
add_asmparsertest('ARBvp1.0', 'txl-01.txt')
add_asmparsertest('ARBvp1.0', 'txl-02.txt')
add_asmparsertest('ARBvp1.0', 'txl-03.txt')
add_asmparsertest('ARBvp1.0', 'txl-04.txt')
add_asmparsertest('ARBvp1.0', 'txl-05.txt')
add_asmparsertest('ARBvp1.0', 'txl-06.txt')
add_asmparsertest('ARBvp1.0', 'txl-07.txt')
add_asmparsertest('ARBvp1.0', 'txl-08.txt')
add_asmparsertest('ARBvp1.0', 'txl-09.txt')
add_asmparsertest('ARBvp1.0', 'txl-10.txt')
add_asmparsertest('ARBvp1.0', 'txl-11.txt')
add_asmparsertest('ARBvp1.0', 'txl-12.txt')
add_asmparsertest('ARBvp1.0', 'txl-13.txt')
add_asmparsertest('ARBvp1.0', 'txl-14.txt')
add_asmparsertest('ARBvp1.0', 'txl-15.txt')
add_asmparsertest('ARBvp1.0', 'txl-16.txt')
add_asmparsertest('ARBvp1.0', 'txl-17.txt')
add_asmparsertest('ARBvp1.0', 'txl-18.txt')
add_asmparsertest('ARBvp1.0', 'txl-19.txt')
add_asmparsertest('ARBvp1.0', 'txl-20.txt')
add_asmparsertest('ARBvp1.0', 'txp-01.txt')
add_asmparsertest('ARBvp1.0', 'txp-02.txt')
add_asmparsertest('ARBvp1.0', 'txp-03.txt')
add_asmparsertest('ARBvp1.0', 'txp-04.txt')
add_asmparsertest('ARBvp1.0', 'txp-05.txt')
add_asmparsertest('ARBvp1.0', 'txp-06.txt')
add_asmparsertest('ARBvp1.0', 'txp-07.txt')
add_asmparsertest('ARBvp1.0', 'txp-08.txt')
add_asmparsertest('ARBvp1.0', 'txp-09.txt')
add_asmparsertest('ARBvp1.0', 'txp-10.txt')
add_asmparsertest('ARBvp1.0', 'txp-11.txt')
add_asmparsertest('ARBvp1.0', 'txp-12.txt')
add_asmparsertest('ARBvp1.0', 'txp-13.txt')
add_asmparsertest('ARBvp1.0', 'txp-14.txt')
add_asmparsertest('ARBvp1.0', 'txp-15.txt')
add_asmparsertest('ARBvp1.0', 'txp-16.txt')
add_asmparsertest('ARBvp1.0', 'txp-17.txt')
add_asmparsertest('ARBvp1.0', 'txp-18.txt')
add_asmparsertest('ARBvp1.0', 'txp-19.txt')
add_asmparsertest('ARBvp1.0', 'txp-20.txt')
add_asmparsertest('ARBvp1.0', 'txq-01.txt')
add_asmparsertest('ARBvp1.0', 'txq-02.txt')
add_asmparsertest('ARBvp1.0', 'txq-03.txt')
add_asmparsertest('ARBvp1.0', 'txq-04.txt')
add_asmparsertest('ARBvp1.0', 'txq-05.txt')
add_asmparsertest('ARBvp1.0', 'txq-06.txt')
add_asmparsertest('ARBvp1.0', 'txq-07.txt')
add_asmparsertest('ARBvp1.0', 'txq-08.txt')
add_asmparsertest('ARBvp1.0', 'txq-09.txt')
add_asmparsertest('ARBvp1.0', 'txq-10.txt')
add_asmparsertest('ARBvp1.0', 'txq-11.txt')
add_asmparsertest('ARBvp1.0', 'txq-12.txt')
add_asmparsertest('ARBvp1.0', 'txq-13.txt')
add_asmparsertest('ARBvp1.0', 'txq-14.txt')
add_asmparsertest('ARBvp1.0', 'txq-15.txt')
add_asmparsertest('ARBvp1.0', 'txq-16.txt')
add_asmparsertest('ARBvp1.0', 'txq-17.txt')
add_asmparsertest('ARBvp1.0', 'txq-18.txt')
add_asmparsertest('ARBvp1.0', 'txq-19.txt')
add_asmparsertest('ARBvp1.0', 'txq-20.txt')
add_asmparsertest('ARBvp1.0', 'xpd.txt')

ext_unpack_subimage = Group()
spec['EXT_unpack_subimage'] = ext_unpack_subimage
ext_unpack_subimage['basic'] = concurrent_test('ext_unpack_subimage')

oes_draw_texture = Group()
spec['OES_draw_texture'] = oes_draw_texture
oes_draw_texture['oes_draw_texture'] = concurrent_test('oes_draw_texture')

oes_compressed_etc1_rgb8_texture = Group()
spec['OES_compressed_ETC1_RGB8_texture'] = oes_compressed_etc1_rgb8_texture
oes_compressed_etc1_rgb8_texture['basic'] = concurrent_test('oes_compressed_etc1_rgb8_texture-basic')
oes_compressed_etc1_rgb8_texture['miptree'] = concurrent_test('oes_compressed_etc1_rgb8_texture-miptree')

oes_compressed_paletted_texture = Group()
spec['OES_compressed_paletted_texture'] = oes_compressed_paletted_texture
oes_compressed_paletted_texture['basic API'] = concurrent_test('oes_compressed_paletted_texture-api')

egl14 = Group()
spec['EGL 1.4'] = egl14
egl14['eglCreateSurface'] = plain_test('egl-create-surface')
egl14['eglQuerySurface EGL_BAD_ATTRIBUTE'] = plain_test('egl-query-surface --bad-attr')
egl14['eglQuerySurface EGL_BAD_SURFACE'] = plain_test('egl-query-surface --bad-surface')
egl14['eglQuerySurface EGL_HEIGHT'] = plain_test('egl-query-surface --attr=EGL_HEIGHT')
egl14['eglQuerySurface EGL_WIDTH'] = plain_test('egl-query-surface --attr=EGL_WIDTH')

egl_nok_swap_region = Group()
spec['EGL_NOK_swap_region'] = egl_nok_swap_region
egl_nok_swap_region['basic']  = plain_test('egl-nok-swap-region')

egl_nok_texture_from_pixmap = Group()
spec['EGL_NOK_texture_from_pixmap'] = egl_nok_texture_from_pixmap
egl_nok_texture_from_pixmap['basic'] = plain_test('egl-nok-texture-from-pixmap')

egl_khr_create_context = Group();
spec['EGL_KHR_create_context'] = egl_khr_create_context
egl_khr_create_context['default major version GLES'] = plain_test('egl-create-context-default-major-version-gles')
egl_khr_create_context['default major version GL'] = plain_test('egl-create-context-default-major-version-gl')
egl_khr_create_context['default minor version GLES'] = plain_test('egl-create-context-default-minor-version-gles')
egl_khr_create_context['default minor version GL'] = plain_test('egl-create-context-default-minor-version-gl')
egl_khr_create_context['valid attribute empty GLES'] = plain_test('egl-create-context-valid-attribute-empty-gles')
egl_khr_create_context['valid attribute empty GL'] = plain_test('egl-create-context-valid-attribute-empty-gl')
egl_khr_create_context['NULL valid attribute GLES'] = plain_test('egl-create-context-valid-attribute-null-gles')
egl_khr_create_context['NULL valid attribute GL'] = plain_test('egl-create-context-valid-attribute-null-gl')
egl_khr_create_context['invalid OpenGL version'] = plain_test('egl-create-context-invalid-gl-version')
egl_khr_create_context['invalid attribute GLES'] = plain_test('egl-create-context-invalid-attribute-gles')
egl_khr_create_context['invalid attribute GL'] = plain_test('egl-create-context-invalid-attribute-gl')
egl_khr_create_context['invalid flag GLES'] = plain_test('egl-create-context-invalid-flag-gles')
egl_khr_create_context['invalid flag GL'] = plain_test('egl-create-context-invalid-flag-gl')
egl_khr_create_context['valid forward-compatible flag GL'] = plain_test('egl-create-context-valid-flag-forward-compatible-gl')
egl_khr_create_context['invalid profile'] = plain_test('egl-create-context-invalid-profile')
egl_khr_create_context['3.2 core profile required'] = plain_test('egl-create-context-core-profile')
egl_khr_create_context['pre-GL3.2 profile'] = plain_test('egl-create-context-pre-GL32-profile')
egl_khr_create_context['verify GL flavor'] = plain_test('egl-create-context-verify-gl-flavor')

gles20 = Group()
spec['!OpenGL ES 2.0'] = gles20
gles20['glsl-fs-pointcoord'] = concurrent_test('glsl-fs-pointcoord_gles2')
add_concurrent_test(gles20, 'invalid-es3-queries_gles2')
add_concurrent_test(gles20, 'minmax_gles2')
add_concurrent_test(gles20, 'multiple-shader-objects_gles2')
add_concurrent_test(gles20, 'fbo_discard_gles2')

gles30 = Group()
spec['!OpenGL ES 3.0'] = gles30
for tex_format in ('rgb8', 'srgb8', 'rgba8', 'srgb8-alpha8', 'r11', 'rg11', 'rgb8-punchthrough-alpha1', 'srgb8-punchthrough-alpha1'):
	test_name = ' ' .join(['oes_compressed_etc2_texture-miptree_gles3', tex_format])
	executable = '{0} -auto'.format(test_name)
	gles30[test_name] = concurrent_test(executable)
gles30['minmax'] = concurrent_test('minmax_gles3')
for test_mode in ['teximage', 'texsubimage']:
        test_name = 'ext_texture_array-compressed_gles3 {0}'.format(test_mode)
        gles30[test_name] = PlainExecTest(test_name + ' -auto -fbo')

arb_es3_compatibility = Group()
spec['ARB_ES3_compatibility'] = arb_es3_compatibility
for tex_format in ('rgb8', 'srgb8', 'rgba8', 'srgb8-alpha8', 'r11', 'rg11', 'rgb8-punchthrough-alpha1', 'srgb8-punchthrough-alpha1'):
	for context in ('core', 'compat'):
		test_name = ' ' .join(['oes_compressed_etc2_texture-miptree', tex_format, context])
		executable = '{0}'.format(test_name)
		arb_es3_compatibility[test_name] = concurrent_test(executable)

add_shader_test_dir(spec, os.path.join(generatedTestDir, 'spec'),
		    recursive=True)
import_glsl_parser_tests(profile.tests, generatedTestDir, ['spec'])

profile.tests['hiz'] = hiz
profile.tests['glean'] = glean
profile.tests['glslparsertest'] = glslparsertest
profile.tests['asmparsertest'] = asmparsertest
profile.tests['shaders'] = shaders
profile.tests['security'] = security
profile.tests['spec'] = spec
if platform.system() is not 'Windows':
	profile.tests['glx'] = glx

# Remove blacklisted tests
for test_path in blacklist:
    profile.remove_test(test_path)