[Piglit] [PATCH 19/21] all.py: Remove run_concurrent=True flag
Dylan Baker
baker.dylan.c at gmail.com
Tue Feb 24 17:35:09 PST 2015
The previous commit made True the default value. This removes ~400 LOC
from all.py (about 10%)
Signed-off-by: Dylan Baker <dylanx.c.baker at intel.com>
---
tests/all.py | 2833 ++++++++++++++++++++++++--------------------------------
tests/quick.py | 13 +-
2 files changed, 1217 insertions(+), 1629 deletions(-)
diff --git a/tests/all.py b/tests/all.py
index 6cca781..77c0faa 100644
--- a/tests/all.py
+++ b/tests/all.py
@@ -27,16 +27,14 @@ def add_depthstencil_render_miplevels_tests(adder, test_types):
run_concurrent=False)
def add_fbo_stencil_tests(adder, format):
- g(['fbo-stencil', 'clear', format], 'fbo-stencil-{}-clear'.format(format),
- run_concurrent=True)
+ g(['fbo-stencil', 'clear', format], 'fbo-stencil-{}-clear'.format(format))
g(['fbo-stencil', 'readpixels', format],
- 'fbo-stencil-{}-readpixels'.format(format), run_concurrent=True)
+ 'fbo-stencil-{}-readpixels'.format(format))
g(['fbo-stencil', 'drawpixels', format],
- 'fbo-stencil-{}-drawpixels'.format(format), run_concurrent=True)
+ 'fbo-stencil-{}-drawpixels'.format(format))
g(['fbo-stencil', 'copypixels', format],
- 'fbo-stencil-{}-copypixels'.format(format), run_concurrent=True)
- g(['fbo-stencil', 'blit', format], 'fbo-stencil-{}-blit'.format(format),
- run_concurrent=True)
+ 'fbo-stencil-{}-copypixels'.format(format))
+ g(['fbo-stencil', 'blit', format], 'fbo-stencil-{}-blit'.format(format))
def add_fbo_depthstencil_tests(group, format, num_samples):
assert format, 'add_fbo_depthstencil_tests argument "format" cannot be empty'
@@ -46,7 +44,7 @@ def add_fbo_depthstencil_tests(group, format, num_samples):
create_test = lambda a: PiglitGLTest(a, run_concurrent=False)
else:
prefix = 'fbo-'
- create_test = lambda a: PiglitGLTest(a, run_concurrent=True)
+ create_test = PiglitGLTest
if num_samples > 1:
suffix = ' samples=' + str(num_samples)
@@ -112,66 +110,55 @@ def add_msaa_visual_plain_tests(adder, args, **kwargs):
def add_fbo_formats_tests(adder, extension, suffix=''):
adder(['fbo-generatemipmap-formats', extension],
- 'fbo-generatemipmap-formats{}'.format(suffix),
- run_concurrent=True)
+ 'fbo-generatemipmap-formats{}'.format(suffix))
adder(['fbo-clear-formats', extension],
- 'fbo-clear-formats{}'.format(suffix), run_concurrent=True)
+ 'fbo-clear-formats{}'.format(suffix))
adder(['get-renderbuffer-internalformat', extension],
- 'get-renderbuffer-internalformat{}'.format(suffix),
- run_concurrent=True)
+ 'get-renderbuffer-internalformat{}'.format(suffix))
if 'depth' not in extension:
adder(['fbo-blending-formats', extension],
- 'fbo-blending-formats{}'.format(suffix), run_concurrent=True)
+ 'fbo-blending-formats{}'.format(suffix))
adder(['fbo-alphatest-formats', extension],
- 'fbo-alphatest-formats{}'.format(suffix), run_concurrent=True)
+ 'fbo-alphatest-formats{}'.format(suffix))
adder(['fbo-colormask-formats', extension],
- 'fbo-colormask-formats{}'.format(suffix), run_concurrent=True)
+ 'fbo-colormask-formats{}'.format(suffix))
def add_msaa_formats_tests(adder, extension):
for num_samples in MSAA_SAMPLE_COUNTS:
adder(['ext_framebuffer_multisample-formats', str(num_samples), extension],
- 'multisample-formats {} {}'.format(num_samples, extension),
- run_concurrent=True)
+ 'multisample-formats {} {}'.format(num_samples, extension))
def add_vpfpgeneric(adder, name):
adder(['vpfp-generic',
os.path.join(TESTS_DIR, 'shaders', 'generic', name + '.vpfp')],
- name, run_concurrent=True)
+ name)
def add_texwrap_target_tests(adder, target):
- adder(['texwrap', 'GL_RGBA8'], 'texwrap {}'.format(target),
- run_concurrent=True)
+ adder(['texwrap', 'GL_RGBA8'], 'texwrap {}'.format(target))
adder(['texwrap', 'GL_RGBA8', 'bordercolor'],
- 'texwrap {} bordercolor'.format(target), run_concurrent=True)
- adder(['texwrap', 'GL_RGBA8', 'proj'], 'texwrap {} proj'.format(target),
- run_concurrent=True)
+ 'texwrap {} bordercolor'.format(target))
+ adder(['texwrap', 'GL_RGBA8', 'proj'], 'texwrap {} proj'.format(target))
adder(['texwrap', 'GL_RGBA8', 'proj', 'bordercolor'],
- 'texwrap {} proj bordercolor'.format(target), run_concurrent=True)
+ 'texwrap {} proj bordercolor'.format(target))
def add_texwrap_format_tests(adder, ext='', suffix=''):
args = [] if ext == '' else [ext]
- adder(['texwrap'] + args, 'texwrap formats{}'.format(suffix),
- run_concurrent=True)
+ adder(['texwrap'] + args, 'texwrap formats{}'.format(suffix))
adder(['texwrap'] + args + ['bordercolor'],
- 'texwrap formats{} bordercolor'.format(suffix),
- run_concurrent=True)
+ 'texwrap formats{} bordercolor'.format(suffix))
adder(['texwrap'] + args + ['bordercolor', 'swizzled'],
- 'texwrap formats{} bordercolor-swizzled'.format(suffix),
- run_concurrent=True)
+ 'texwrap formats{} bordercolor-swizzled'.format(suffix))
def add_fbo_depth_tests(adder, format):
- adder(['fbo-depth-tex1d', format], 'fbo-depth-{}-tex1d'.format(format),
- run_concurrent=True)
- adder(['fbo-depth', 'clear', format], 'fbo-depth-{}-clear'.format(format),
- run_concurrent=True)
+ adder(['fbo-depth-tex1d', format], 'fbo-depth-{}-tex1d'.format(format))
+ adder(['fbo-depth', 'clear', format], 'fbo-depth-{}-clear'.format(format))
adder(['fbo-depth', 'readpixels', format],
- 'fbo-depth-{}-readpixels'.format(format), run_concurrent=True)
+ 'fbo-depth-{}-readpixels'.format(format))
adder(['fbo-depth', 'drawpixels', format],
- 'fbo-depth-{}-drawpixels'.format(format), run_concurrent=True)
+ 'fbo-depth-{}-drawpixels'.format(format))
adder(['fbo-depth', 'copypixels', format],
- 'fbo-depth-{}-copypixels'.format(format), run_concurrent=True)
- adder(['fbo-depth', 'blit', format], 'fbo-depth-{}-blit'.format(format),
- run_concurrent=True)
+ 'fbo-depth-{}-copypixels'.format(format))
+ adder(['fbo-depth', 'blit', format], 'fbo-depth-{}-blit'.format(format))
def power_set(s):
"""Generate all possible subsets of the given set, including the empty set.
@@ -229,8 +216,7 @@ for dirpath, _, filenames in os.walk(_basedir):
group = grouptools.join(base_group, filename)
profile.test_list[group] = PiglitGLTest(
- ['asmparsertest', type_, os.path.join(dirpath, filename)],
- run_concurrent=True)
+ ['asmparsertest', type_, os.path.join(dirpath, filename)])
# List of all of the MSAA sample counts we wish to test
MSAA_SAMPLE_COUNTS = (2, 4, 6, 8, 16, 32)
@@ -463,192 +449,174 @@ with profile.group_manager(PiglitGLTest, 'security') as g:
g(['initialized-vbo'], run_concurrent=False)
with profile.group_manager(PiglitGLTest, 'shaders') as g:
- g(['activeprogram-bad-program'], run_concurrent=True)
- g(['activeprogram-get'], run_concurrent=True)
- g(['attribute0'], run_concurrent=True)
- g(['createshaderprogram-bad-type'], run_concurrent=True)
- g(['createshaderprogram-attached-shaders'], run_concurrent=True)
- g(['glsl-arb-fragment-coord-conventions'], run_concurrent=True)
- g(['glsl-arb-fragment-coord-conventions-define'], run_concurrent=True)
- g(['glsl-bug-22603'], run_concurrent=True)
- g(['glsl-bindattriblocation'], run_concurrent=True)
- g(['glsl-dlist-getattriblocation'], run_concurrent=True)
- g(['glsl-getactiveuniform-array-size'], run_concurrent=True)
- g(['glsl-getactiveuniform-length'], run_concurrent=True)
- g(['glsl-getattriblocation'], run_concurrent=True)
- g(['getuniform-01'], run_concurrent=True)
- g(['getuniform-02'], run_concurrent=True)
- g(['glsl-invalid-asm-01'], run_concurrent=True)
- g(['glsl-invalid-asm-02'], run_concurrent=True)
- g(['glsl-novertexdata'], run_concurrent=True)
- g(['glsl-preprocessor-comments'], run_concurrent=True)
- g(['glsl-reload-source'], run_concurrent=True)
- g(['glsl-uniform-out-of-bounds'], run_concurrent=True)
- g(['glsl-uniform-out-of-bounds-2'], run_concurrent=True)
- g(['glsl-uniform-update'], run_concurrent=True)
- g(['glsl-unused-varying'], run_concurrent=True)
- g(['glsl-fs-bug25902'], run_concurrent=True)
- g(['glsl-fs-color-matrix'], run_concurrent=True)
- g(['glsl-fs-discard-02'], run_concurrent=True)
- g(['glsl-fs-exp2'], run_concurrent=True)
- g(['glsl-fs-flat-color'], run_concurrent=True)
- g(['glsl-fs-fogcolor-statechange'], run_concurrent=True)
- g(['glsl-fs-fogscale'], run_concurrent=True)
- g(['glsl-fs-fragcoord'], run_concurrent=True)
- g(['glsl-fs-fragcoord-zw-ortho'], run_concurrent=True)
- g(['glsl-fs-fragcoord-zw-perspective'], run_concurrent=True)
- g(['glsl-fs-loop'], run_concurrent=True)
- g(['glsl-fs-loop-nested'], run_concurrent=True)
- g(['glsl-fs-pointcoord'], run_concurrent=True)
- g(['glsl-fs-raytrace-bug27060'], run_concurrent=True)
- g(['glsl-fs-sampler-numbering'], run_concurrent=True)
- g(['glsl-fs-shader-stencil-export'], run_concurrent=True)
- g(['glsl-fs-sqrt-branch'], run_concurrent=True)
- g(['glsl-fs-texturecube'], run_concurrent=True)
- g(['glsl-fs-texturecube', '-bias'],
- 'glsl-fs-texturecube-bias',
- run_concurrent=True)
- g(['glsl-fs-texturecube-2'], run_concurrent=True)
- g(['glsl-fs-texturecube-2', '-bias'], 'glsl-fs-texturecube-2-bias',
- run_concurrent=True)
+ g(['activeprogram-bad-program'])
+ g(['activeprogram-get'])
+ g(['attribute0'])
+ g(['createshaderprogram-bad-type'])
+ g(['createshaderprogram-attached-shaders'])
+ g(['glsl-arb-fragment-coord-conventions'])
+ g(['glsl-arb-fragment-coord-conventions-define'])
+ g(['glsl-bug-22603'])
+ g(['glsl-bindattriblocation'])
+ g(['glsl-dlist-getattriblocation'])
+ g(['glsl-getactiveuniform-array-size'])
+ g(['glsl-getactiveuniform-length'])
+ g(['glsl-getattriblocation'])
+ g(['getuniform-01'])
+ g(['getuniform-02'])
+ g(['glsl-invalid-asm-01'])
+ g(['glsl-invalid-asm-02'])
+ g(['glsl-novertexdata'])
+ g(['glsl-preprocessor-comments'])
+ g(['glsl-reload-source'])
+ g(['glsl-uniform-out-of-bounds'])
+ g(['glsl-uniform-out-of-bounds-2'])
+ g(['glsl-uniform-update'])
+ g(['glsl-unused-varying'])
+ g(['glsl-fs-bug25902'])
+ g(['glsl-fs-color-matrix'])
+ g(['glsl-fs-discard-02'])
+ g(['glsl-fs-exp2'])
+ g(['glsl-fs-flat-color'])
+ g(['glsl-fs-fogcolor-statechange'])
+ g(['glsl-fs-fogscale'])
+ g(['glsl-fs-fragcoord'])
+ g(['glsl-fs-fragcoord-zw-ortho'])
+ g(['glsl-fs-fragcoord-zw-perspective'])
+ g(['glsl-fs-loop'])
+ g(['glsl-fs-loop-nested'])
+ g(['glsl-fs-pointcoord'])
+ g(['glsl-fs-raytrace-bug27060'])
+ g(['glsl-fs-sampler-numbering'])
+ g(['glsl-fs-shader-stencil-export'])
+ g(['glsl-fs-sqrt-branch'])
+ g(['glsl-fs-texturecube'])
+ g(['glsl-fs-texturecube', '-bias'], 'glsl-fs-texturecube-bias')
+ g(['glsl-fs-texturecube-2'])
+ g(['glsl-fs-texturecube-2', '-bias'], 'glsl-fs-texturecube-2-bias')
g(['glsl-fs-textureenvcolor-statechange'], run_concurrent=False)
- g(['glsl-fs-texture2drect'], run_concurrent=True)
- g(['glsl-fs-texture2drect', '-proj3'], 'glsl-fs-texture2drect-proj3',
- run_concurrent=True)
- g(['glsl-fs-texture2drect', '-proj4'], 'glsl-fs-texture2drect-proj4',
- run_concurrent=True)
- g(['glsl-fs-user-varying-ff'], run_concurrent=True)
- g(['glsl-mat-attribute'], run_concurrent=True)
- g(['glsl-max-varyings'], run_concurrent=True)
+ g(['glsl-fs-texture2drect'])
+ g(['glsl-fs-texture2drect', '-proj3'], 'glsl-fs-texture2drect-proj3')
+ g(['glsl-fs-texture2drect', '-proj4'], 'glsl-fs-texture2drect-proj4')
+ g(['glsl-fs-user-varying-ff'])
+ g(['glsl-mat-attribute'])
+ g(['glsl-max-varyings'])
g(['glsl-max-varyings', '--exceed-limits'],
- 'glsl-max-varyings >MAX_VARYING_COMPONENTS', run_concurrent=True)
- g(['glsl-orangebook-ch06-bump'], run_concurrent=True)
- g(['glsl-routing'], run_concurrent=True)
- g(['glsl-vs-arrays'], run_concurrent=True)
- g(['glsl-vs-normalscale'], run_concurrent=True)
- g(['glsl-vs-functions'], run_concurrent=True)
- g(['glsl-vs-user-varying-ff'], run_concurrent=True)
- g(['glsl-vs-texturematrix-1'], run_concurrent=True)
- g(['glsl-vs-texturematrix-2'], run_concurrent=True)
- g(['glsl-sin'], run_concurrent=True)
- g(['glsl-cos'], run_concurrent=True)
- g(['glsl-vs-if-bool'], run_concurrent=True)
- g(['glsl-vs-loop'], run_concurrent=True)
- g(['glsl-vs-loop-nested'], run_concurrent=True)
- g(['glsl-vs-mov-after-deref'], run_concurrent=True)
- g(['glsl-vs-mvp-statechange'], run_concurrent=True)
- g(['glsl-vs-raytrace-bug26691'], run_concurrent=True)
- g(['glsl-vs-statechange-1'], run_concurrent=True)
- g(['vp-combined-image-units'], run_concurrent=True)
- g(['glsl-derivs'], run_concurrent=True)
- g(['glsl-deriv-varyings'], run_concurrent=True)
- g(['glsl-fwidth'], run_concurrent=True)
- g(['glsl-lod-bias'], run_concurrent=True)
- g(['vp-ignore-input'], run_concurrent=True)
- g(['glsl-empty-vs-no-fs'], run_concurrent=True)
- g(['glsl-useprogram-displaylist'], run_concurrent=True)
- g(['glsl-vs-point-size'], run_concurrent=True)
- g(['glsl-light-model'], run_concurrent=True)
- g(['glsl-link-bug30552'], run_concurrent=True)
- g(['glsl-link-bug38015'], run_concurrent=True)
- g(['glsl-link-empty-prog-01'], run_concurrent=True)
- g(['glsl-link-empty-prog-02'], run_concurrent=True)
- g(['glsl-max-vertex-attrib'], run_concurrent=True)
- g(['glsl-kwin-blur-1'], run_concurrent=True)
- g(['glsl-kwin-blur-2'], run_concurrent=True)
- g(['gpu_shader4_attribs'], run_concurrent=True)
- g(['link-unresolved-function'], run_concurrent=True)
- g(['sso-simple'], run_concurrent=True)
- g(['sso-uniforms-01'], run_concurrent=True)
- g(['sso-uniforms-02'], run_concurrent=True)
- g(['sso-user-varying-01'], run_concurrent=True)
- g(['sso-user-varying-02'], run_concurrent=True)
- g(['useprogram-flushverts-1'], run_concurrent=True)
- g(['useprogram-flushverts-2'], run_concurrent=True)
- g(['useprogram-inside-begin'], run_concurrent=True)
- g(['useprogram-refcount-1'], run_concurrent=True)
- g(['useshaderprogram-bad-type'], run_concurrent=True)
- g(['useshaderprogram-bad-program'], run_concurrent=True)
- g(['useshaderprogram-flushverts-1'], run_concurrent=True)
- g(['point-vertex-id'], run_concurrent=True)
- g(['glsl-vs-int-attrib'], run_concurrent=True)
+ 'glsl-max-varyings >MAX_VARYING_COMPONENTS')
+ g(['glsl-orangebook-ch06-bump'])
+ g(['glsl-routing'])
+ g(['glsl-vs-arrays'])
+ g(['glsl-vs-normalscale'])
+ g(['glsl-vs-functions'])
+ g(['glsl-vs-user-varying-ff'])
+ g(['glsl-vs-texturematrix-1'])
+ g(['glsl-vs-texturematrix-2'])
+ g(['glsl-sin'])
+ g(['glsl-cos'])
+ g(['glsl-vs-if-bool'])
+ g(['glsl-vs-loop'])
+ g(['glsl-vs-loop-nested'])
+ g(['glsl-vs-mov-after-deref'])
+ g(['glsl-vs-mvp-statechange'])
+ g(['glsl-vs-raytrace-bug26691'])
+ g(['glsl-vs-statechange-1'])
+ g(['vp-combined-image-units'])
+ g(['glsl-derivs'])
+ g(['glsl-deriv-varyings'])
+ g(['glsl-fwidth'])
+ g(['glsl-lod-bias'])
+ g(['vp-ignore-input'])
+ g(['glsl-empty-vs-no-fs'])
+ g(['glsl-useprogram-displaylist'])
+ g(['glsl-vs-point-size'])
+ g(['glsl-light-model'])
+ g(['glsl-link-bug30552'])
+ g(['glsl-link-bug38015'])
+ g(['glsl-link-empty-prog-01'])
+ g(['glsl-link-empty-prog-02'])
+ g(['glsl-max-vertex-attrib'])
+ g(['glsl-kwin-blur-1'])
+ g(['glsl-kwin-blur-2'])
+ g(['gpu_shader4_attribs'])
+ g(['link-unresolved-function'])
+ g(['sso-simple'])
+ g(['sso-uniforms-01'])
+ g(['sso-uniforms-02'])
+ g(['sso-user-varying-01'])
+ g(['sso-user-varying-02'])
+ g(['useprogram-flushverts-1'])
+ g(['useprogram-flushverts-2'])
+ g(['useprogram-inside-begin'])
+ g(['useprogram-refcount-1'])
+ g(['useshaderprogram-bad-type'])
+ g(['useshaderprogram-bad-program'])
+ g(['useshaderprogram-flushverts-1'])
+ g(['point-vertex-id'])
+ g(['glsl-vs-int-attrib'])
g(['glsl-link-test',
os.path.join('shaders', 'glsl-link-initializer-01a.vert'),
os.path.join('shaders', 'glsl-link-initializer-01b.vert'), 'pass'],
- 'GLSL link single global initializer, 2 shaders',
- run_concurrent=True)
+ 'GLSL link single global initializer, 2 shaders')
g(['glsl-link-test',
os.path.join('shaders', 'glsl-link-initializer-01c.vert'),
os.path.join('shaders', 'glsl-link-initializer-01d.vert'),
'pass'],
- 'GLSL link matched global initializer, 2 shaders',
- run_concurrent=True)
+ 'GLSL link matched global initializer, 2 shaders')
g(['glsl-link-test',
os.path.join('shaders', 'glsl-link-initializer-01b.vert'),
os.path.join('shaders', 'glsl-link-initializer-01d.vert'),
'fail'],
- 'GLSL link mismatched global initializer, 2 shaders',
- run_concurrent=True)
+ 'GLSL link mismatched global initializer, 2 shaders')
g(['glsl-link-test',
os.path.join('shaders', 'glsl-link-initializer-01a.vert'),
os.path.join('shaders', 'glsl-link-initializer-01b.vert'),
os.path.join('shaders', 'glsl-link-initializer-01c.vert'),
'fail'],
- 'GLSL link mismatched global initializer, 3 shaders',
- run_concurrent=True)
+ 'GLSL link mismatched global initializer, 3 shaders')
g(['glsl-link-test',
os.path.join('shaders', 'glsl-link-initializer-02a.vert'),
os.path.join('shaders', 'glsl-link-initializer-02b.vert'),
'fail'],
- 'GLSL link mismatched global const initializer',
- run_concurrent=True)
+ 'GLSL link mismatched global const initializer')
g(['glsl-link-initializer-03'],
- 'GLSL link two programs, global initializer', run_concurrent=True)
+ 'GLSL link two programs, global initializer')
g(['glsl-link-test',
os.path.join('shaders', 'glsl-link-initializer-05a.vert'),
os.path.join('shaders', 'glsl-link-initializer-05b.vert'),
'fail'],
- 'GLSL link matched global initializer expression',
- run_concurrent=True)
+ 'GLSL link matched global initializer expression')
g(['glsl-link-test',
os.path.join('shaders', 'glsl-link-initializer-06a.vert'),
os.path.join('shaders', 'glsl-link-initializer-06b.vert'),
'fail'],
- 'GLSL link mismatched global initializer expression',
- run_concurrent=True)
+ 'GLSL link mismatched global initializer expression')
g(['glsl-link-test',
os.path.join('shaders', 'glsl-link-invariant-01a.vert'),
os.path.join('shaders', 'glsl-link-invariant-01b.vert'),
'fail'],
- 'GLSL link mismatched invariant',
- run_concurrent=True)
+ 'GLSL link mismatched invariant')
g(['glsl-link-test',
os.path.join('shaders', 'glsl-link-centroid-01a.vert'),
os.path.join('shaders', 'glsl-link-centroid-01b.vert'),
'fail'],
- 'GLSL link mismatched centroid',
- run_concurrent=True)
+ 'GLSL link mismatched centroid')
g(['glsl-link-test',
os.path.join('shaders', 'glsl-link-struct-array.frag'),
'pass'],
- 'GLSL link array-of-struct-of-array',
- run_concurrent=True)
+ 'GLSL link array-of-struct-of-array')
g(['glsl-getactiveuniform-count',
os.path.join('shaders', 'glsl-getactiveuniform-length.vert'), '1'],
- 'glsl-getactiveuniform-count: {}'.format('glsl-getactiveuniform-length'),
- run_concurrent=True)
+ 'glsl-getactiveuniform-count: {}'.format('glsl-getactiveuniform-length'))
g(['glsl-getactiveuniform-count',
os.path.join('shaders', 'glsl-getactiveuniform-ftransform.vert'), '2'],
'glsl-getactiveuniform-count: {}'.format(
- 'glsl-getactiveuniform-ftransform'),
- run_concurrent=True)
+ 'glsl-getactiveuniform-ftransform'))
g(['glsl-getactiveuniform-count',
os.path.join('shaders', 'glsl-getactiveuniform-mvp.vert'), '2'],
- 'glsl-getactiveuniform-count: {}'.format('glsl-getactiveuniform-mvp'),
- run_concurrent=True)
+ 'glsl-getactiveuniform-count: {}'.format('glsl-getactiveuniform-mvp'))
for subtest in ('interstage', 'intrastage', 'vs-gs'):
- g(['version-mixing', subtest], run_concurrent=True)
+ g(['version-mixing', subtest])
with profile.group_manager(
PiglitGLTest, 'glx',
@@ -683,16 +651,16 @@ with profile.group_manager(
g(['glx-make-glxdrawable-current'], run_concurrent=False)
g(['glx-context-flush-control'], run_concurrent=False)
g(['glx-buffer-age'], run_concurrent=False)
- g(['glx-pixmap-life'], run_concurrent=True)
- g(['glx-pixmap13-life'], run_concurrent=True)
- g(['glx-pixmap-multi'], run_concurrent=True)
+ g(['glx-pixmap-life'])
+ g(['glx-pixmap13-life'])
+ g(['glx-pixmap-multi'])
g(['glx-tfp'], run_concurrent=False)
g(['glx-visuals-depth'], run_concurrent=False)
- g(['glx-visuals-depth'], run_concurrent=True)
+ g(['glx-visuals-depth'])
g(['glx-visuals-stencil'], run_concurrent=False)
- g(['glx-visuals-stencil'], run_concurrent=True)
- g(['glx-window-life'], run_concurrent=True)
- g(['glx-pixmap-crosscheck'], run_concurrent=True)
+ g(['glx-visuals-stencil'])
+ g(['glx-window-life'])
+ g(['glx-pixmap-crosscheck'])
g(['glx-query-drawable', '--attr=GLX_WIDTH', '--type=GLXWINDOW'],
'glx-query-drawable-GLXWINDOW-GLX_WIDTH', run_concurrent=False)
g(['glx-query-drawable', '--attr=GLX_HEIGHT', '--type=GLXWINDOW'],
@@ -721,7 +689,7 @@ with profile.group_manager(
'glx-query-drawable-GLX_PRESERVED_CONTENTS', run_concurrent=False)
g(['glx-query-drawable', '--bad-drawable'],
'glx-query-drawable-GLXBadDrawable', run_concurrent=False)
- g(['glx-string-sanity'], 'extension string sanity', run_concurrent=True)
+ g(['glx-string-sanity'], 'extension string sanity')
add_msaa_visual_plain_tests(g, ['glx-copy-sub-buffer'],
run_concurrent=False)
profile.test_list[os.path.join('glx', 'glx-buffer-age vblank_mode=0')] = \
@@ -756,76 +724,59 @@ with profile.group_manager(
grouptools.join('glx', 'GLX_ARB_create_context'),
require_platforms=['glx', 'mixed_glx_egl']) as g:
g(['glx-create-context-current-no-framebuffer'],
- 'current with no framebuffer', run_concurrent=True)
- g(['glx-create-context-default-major-version'],
- 'default major version', run_concurrent=True)
- g(['glx-create-context-default-minor-version'],
- 'default minor version', run_concurrent=True)
- g(['glx-create-context-invalid-attribute'], 'invalid attribute',
- run_concurrent=True)
- g(['glx-create-context-invalid-flag'], 'invalid flag',
- run_concurrent=True)
+ 'current with no framebuffer')
+ g(['glx-create-context-default-major-version'], 'default major version')
+ g(['glx-create-context-default-minor-version'], 'default minor version')
+ g(['glx-create-context-invalid-attribute'], 'invalid attribute')
+ g(['glx-create-context-invalid-flag'], 'invalid flag')
g(['glx-create-context-invalid-flag-forward-compatible'],
- 'forward-compatible flag with pre-3.0',
- run_concurrent=True)
- g(['glx-create-context-invalid-gl-version'], 'invalid OpenGL version',
- run_concurrent=True)
- g(['glx-create-context-invalid-render-type'], 'invalid render type',
- run_concurrent=True)
+ 'forward-compatible flag with pre-3.0')
+ g(['glx-create-context-invalid-gl-version'], 'invalid OpenGL version')
+ g(['glx-create-context-invalid-render-type'], 'invalid render type')
g(['glx-create-context-invalid-render-type-color-index'],
- 'color-index render type with 3.0', run_concurrent=True)
- g(['glx-create-context-valid-attribute-empty'], 'empty attribute list',
- run_concurrent=True)
- g(['glx-create-context-valid-attribute-null'], 'NULL attribute list',
- run_concurrent=True)
+ 'color-index render type with 3.0')
+ g(['glx-create-context-valid-attribute-empty'], 'empty attribute list')
+ g(['glx-create-context-valid-attribute-null'], 'NULL attribute list')
g(['glx-create-context-valid-flag-forward-compatible'],
- 'forward-compatible flag with 3.0', run_concurrent=True)
+ 'forward-compatible flag with 3.0')
with profile.group_manager(
PiglitGLTest,
grouptools.join('glx', 'GLX_ARB_create_context_profile'),
require_platforms=['glx', 'mixed_glx_egl']) as g:
- g(['glx-create-context-core-profile'],
- '3.2 core profile required', run_concurrent=True)
- g(['glx-create-context-invalid-profile'],
- 'invalid profile', run_concurrent=True)
- g(['glx-create-context-pre-GL32-profile'],
- 'pre-GL3.2 profile', run_concurrent=True)
+ g(['glx-create-context-core-profile'], '3.2 core profile required')
+ g(['glx-create-context-invalid-profile'], 'invalid profile')
+ g(['glx-create-context-pre-GL32-profile'], 'pre-GL3.2 profile')
with profile.group_manager(
PiglitGLTest,
grouptools.join('glx', 'GLX_ARB_create_context_robustness'),
require_platforms=['glx', 'mixed_glx_egl']) as g:
g(['glx-create-context-invalid-reset-strategy'],
- 'invalid reset notification strategy', run_concurrent=True)
- g(['glx-create-context-require-robustness'], 'require GL_ARB_robustness'
- run_concurrent=True)
+ 'invalid reset notification strategy')
+ g(['glx-create-context-require-robustness'], 'require GL_ARB_robustness')
with profile.group_manager(
PiglitGLTest,
grouptools.join('glx', 'GLX_ARB_create_context_es2_profile'),
require_platforms=['glx', 'mixed_glx_egl']) as g:
g(['glx-create-context-indirect-es2-profile'],
- 'indirect rendering ES2 profile', run_concurrent=True)
- g(['glx-create-context-invalid-es-version'],
- 'invalid OpenGL ES version', run_concurrent=True)
+ 'indirect rendering ES2 profile')
+ g(['glx-create-context-invalid-es-version'], 'invalid OpenGL ES version')
with profile.group_manager(
PiglitGLTest,
grouptools.join('glx', 'GLX_ARB_sync_control'),
require_platforms=['glx', 'mixed_glx_egl']) as g:
- g(['glx-oml-sync-control-getmscrate'], 'glXGetMscRateOML',
- run_concurrent=True)
+ g(['glx-oml-sync-control-getmscrate'], 'glXGetMscRateOML')
g(['glx-oml-sync-control-swapbuffersmsc-divisor-zero'],
- 'swapbuffersmsc-divisor-zero', run_concurrent=True)
- g(['glx-oml-sync-control-swapbuffersmsc-return'], 'swapbuffersmsc-return',
- run_concurrent=True)
+ 'swapbuffersmsc-divisor-zero')
+ g(['glx-oml-sync-control-swapbuffersmsc-return'], 'swapbuffersmsc-return')
g(['glx-oml-sync-control-swapbuffersmsc-return', '0'],
- 'swapbuffersmsc-return swap_interval 0', run_concurrent=True)
+ 'swapbuffersmsc-return swap_interval 0')
g(['glx-oml-sync-control-swapbuffersmsc-return', '1'],
- 'swapbuffersmsc-return swap_interval 1', run_concurrent=True)
- g(['glx-oml-sync-control-waitformsc'], 'waitformsc',
- run_concurrent=True)
+ 'swapbuffersmsc-return swap_interval 1')
+ g(['glx-oml-sync-control-waitformsc'], 'waitformsc')
oml_sync_control_nonzeros = [
mode + [kind, period]
@@ -844,7 +795,7 @@ with profile.group_manager(
PiglitGLTest,
grouptools.join('glx', 'GLX_MESA_query_renderer'),
require_platforms=['glx', 'mixed_glx_egl']) as g:
- g(['glx-query-renderer-coverage'], 'coverage', run_concurrent=True)
+ g(['glx-query-renderer-coverage'], 'coverage')
with profile.group_manager(
PiglitGLTest,
@@ -861,7 +812,7 @@ with profile.group_manager(
g(['vbo-buffer-unmap'], run_concurrent=False)
g(['array-stride'], run_concurrent=False)
g(['clear-accum'], run_concurrent=False)
- g(['clipflat'], run_concurrent=True)
+ g(['clipflat'])
g(['copypixels-draw-sync'], run_concurrent=False)
g(['copypixels-sync'], run_concurrent=False)
g(['degenerate-prims'], run_concurrent=False)
@@ -874,28 +825,28 @@ with profile.group_manager(
g(['dlist-fdo31590'], run_concurrent=False)
g(['draw-arrays-colormaterial'], run_concurrent=False)
g(['draw-copypixels-sync'], run_concurrent=False)
- g(['draw-pixel-with-texture'], run_concurrent=True)
- g(['drawpix-z'], run_concurrent=True)
+ g(['draw-pixel-with-texture'])
+ g(['drawpix-z'])
g(['fog-modes'], run_concurrent=False)
g(['fragment-center'], run_concurrent=False)
g(['geterror-invalid-enum'], run_concurrent=False)
g(['geterror-inside-begin'], run_concurrent=False)
- g(['glinfo'], run_concurrent=True)
+ g(['glinfo'])
g(['hiz'], run_concurrent=False)
g(['infinite-spot-light'], run_concurrent=False)
g(['line-aa-width'], run_concurrent=False)
- g(['line-flat-clip-color'], run_concurrent=True)
+ g(['line-flat-clip-color'])
g(['lineloop'], run_concurrent=False)
g(['linestipple'], run_concurrent=False)
g(['longprim'], run_concurrent=False)
- g(['masked-clear'], run_concurrent=True)
+ g(['masked-clear'])
g(['point-line-no-cull'], run_concurrent=False)
g(['polygon-mode'], run_concurrent=False)
- g(['polygon-mode-offset'], run_concurrent=True)
+ g(['polygon-mode-offset'])
g(['polygon-offset'], run_concurrent=False)
- g(['push-pop-texture-state'], run_concurrent=True)
- g(['quad-invariance'], run_concurrent=True)
- g(['readpix-z'], run_concurrent=True)
+ g(['push-pop-texture-state'])
+ g(['quad-invariance'])
+ g(['readpix-z'])
g(['roundmode-getintegerv'], run_concurrent=False)
g(['roundmode-pixelstore'], run_concurrent=False)
g(['scissor-bitmap'], run_concurrent=False)
@@ -904,7 +855,7 @@ with profile.group_manager(
g(['scissor-depth-clear'], run_concurrent=False)
g(['scissor-many'], run_concurrent=False)
g(['scissor-offscreen'], run_concurrent=False)
- g(['scissor-polygon'], run_concurrent=True)
+ g(['scissor-polygon'])
g(['scissor-stencil-clear'], run_concurrent=False)
g(['select', 'gl11'], 'GL_SELECT - no test function', run_concurrent=False)
g(['select', 'depth'], 'GL_SELECT - depth-test enabled', run_concurrent=False)
@@ -924,20 +875,20 @@ with profile.group_manager(
g(['getteximage-luminance'], run_concurrent=False)
g(['getteximage-simple'], run_concurrent=False)
g(['incomplete-texture', 'fixed'], 'incomplete-texture-fixed',
- run_concurrent=True)
+ )
g(['max-texture-size'], run_concurrent=False)
- g(['max-texture-size-level'], run_concurrent=True)
- g(['proxy-texture'], run_concurrent=True)
- g(['sized-texture-format-channels'], run_concurrent=True)
+ g(['max-texture-size-level'])
+ g(['proxy-texture'])
+ g(['sized-texture-format-channels'])
g(['streaming-texture-leak'], run_concurrent=False)
g(['texredefine'], run_concurrent=False)
g(['texsubimage'], run_concurrent=False)
g(['texsubimage-depth-formats'], run_concurrent=False)
g(['texture-al'], run_concurrent=False)
- g(['triangle-guardband-viewport'], run_concurrent=True)
- g(['getteximage-targets', '1D'], run_concurrent=True)
- g(['getteximage-targets', '2D'], run_concurrent=True)
- g(['teximage-scale-bias'], run_concurrent=True)
+ g(['triangle-guardband-viewport'])
+ g(['getteximage-targets', '1D'])
+ g(['getteximage-targets', '2D'])
+ g(['teximage-scale-bias'])
add_msaa_visual_plain_tests(g, ['draw-pixels'], run_concurrent=False)
add_msaa_visual_plain_tests(g, ['read-front'], run_concurrent=False)
add_msaa_visual_plain_tests(g, ['read-front', 'clear-front-first'],
@@ -982,22 +933,22 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', '!opengl 1.0')) as g:
- g(['gl-1.0-beginend-coverage'], run_concurrent=True)
- g(['gl-1.0-dlist-beginend'], run_concurrent=True)
- g(['gl-1.0-dlist-shademodel'], run_concurrent=True)
- g(['gl-1.0-edgeflag'], run_concurrent=True)
- g(['gl-1.0-edgeflag-const'], run_concurrent=True)
- g(['gl-1.0-edgeflag-quads'], run_concurrent=True)
- g(['gl-1.0-long-dlist'], run_concurrent=True)
- g(['gl-1.0-rendermode-feedback'], run_concurrent=True)
+ g(['gl-1.0-beginend-coverage'])
+ g(['gl-1.0-dlist-beginend'])
+ g(['gl-1.0-dlist-shademodel'])
+ g(['gl-1.0-edgeflag'])
+ g(['gl-1.0-edgeflag-const'])
+ g(['gl-1.0-edgeflag-quads'])
+ g(['gl-1.0-long-dlist'])
+ g(['gl-1.0-rendermode-feedback'])
g(['gl-1.0-front-invalidate-back'], run_concurrent=False)
g(['gl-1.0-swapbuffers-behavior'], run_concurrent=False)
- g(['gl-1.0-polygon-line-aa'], run_concurrent=True)
- g(['gl-1.0-blend-func'], run_concurrent=True)
- g(['gl-1.0-fpexceptions'], run_concurrent=True)
- g(['gl-1.0-ortho-pos'], run_concurrent=True)
- g(['gl-1.0-readpixsanity'], run_concurrent=True)
- g(['gl-1.0-logicop'], run_concurrent=True)
+ g(['gl-1.0-polygon-line-aa'])
+ g(['gl-1.0-blend-func'])
+ g(['gl-1.0-fpexceptions'])
+ g(['gl-1.0-ortho-pos'])
+ g(['gl-1.0-readpixsanity'])
+ g(['gl-1.0-logicop'])
with profile.group_manager(
PiglitGLTest,
@@ -1015,7 +966,7 @@ with profile.group_manager(
g(['tex3d-maxsize'], run_concurrent=False)
g(['teximage-errors'], run_concurrent=False)
g(['texture-packed-formats'], run_concurrent=False)
- g(['getteximage-targets', '3D'], run_concurrent=True)
+ g(['getteximage-targets', '3D'])
add_msaa_visual_plain_tests(g, ['copyteximage', '3D'], run_concurrent=False)
add_texwrap_target_tests(g, '3D')
@@ -1024,7 +975,7 @@ with profile.group_manager(
grouptools.join('spec', '!opengl 1.3')) as g:
g(['texunits'], run_concurrent=False)
g(['tex-border-1'], run_concurrent=False)
- g(['tex3d-depth1'], run_concurrent=True)
+ g(['tex3d-depth1'])
with profile.group_manager(
PiglitGLTest,
@@ -1033,20 +984,17 @@ with profile.group_manager(
g(['tex1d-2dborder'], run_concurrent=False)
g(['blendminmax'], run_concurrent=False)
g(['blendsquare'], run_concurrent=False)
- g(['gl-1.4-dlist-multidrawarrays'], run_concurrent=True)
- g(['gl-1.4-polygon-offset'], run_concurrent=True)
+ g(['gl-1.4-dlist-multidrawarrays'])
+ g(['gl-1.4-polygon-offset'])
g(['draw-batch'], run_concurrent=False)
g(['stencil-wrap'], run_concurrent=False)
g(['triangle-rasterization'], run_concurrent=False)
g(['triangle-rasterization', '-use_fbo'], 'triangle-rasterization-fbo',
run_concurrent=False)
g(['triangle-rasterization-overdraw'], run_concurrent=False)
- g(['tex-miplevel-selection', '-nobias', '-nolod'], 'tex-miplevel-selection',
- run_concurrent=True)
- g(['tex-miplevel-selection', '-nobias'], 'tex-miplevel-selection-lod',
- run_concurrent=True)
- g(['tex-miplevel-selection'], 'tex-miplevel-selection-lod-bias',
- run_concurrent=True)
+ g(['tex-miplevel-selection', '-nobias', '-nolod'], 'tex-miplevel-selection')
+ g(['tex-miplevel-selection', '-nobias'], 'tex-miplevel-selection-lod')
+ g(['tex-miplevel-selection'], 'tex-miplevel-selection-lod-bias')
with profile.group_manager(
PiglitGLTest,
@@ -1070,61 +1018,46 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', '!opengl 2.0')) as g:
- g(['attribs'], run_concurrent=True)
- g(['gl-2.0-edgeflag'], run_concurrent=True)
- g(['gl-2.0-edgeflag-immediate'], run_concurrent=True)
- g(['gl-2.0-vertexattribpointer'], run_concurrent=True)
+ g(['attribs'])
+ g(['gl-2.0-edgeflag'])
+ g(['gl-2.0-edgeflag-immediate'])
+ g(['gl-2.0-vertexattribpointer'])
g(['attrib-assignments'], run_concurrent=False)
g(['getattriblocation-conventional'], run_concurrent=False)
g(['clip-flag-behavior'], run_concurrent=False)
- g(['vertex-program-two-side', 'enabled', 'front', 'back', 'front2', 'back2'],
- run_concurrent=True)
- g(['vertex-program-two-side', 'enabled', 'front', 'back', 'front2'],
- run_concurrent=True)
- g(['vertex-program-two-side', 'enabled', 'front', 'back', 'back2'],
- run_concurrent=True)
- g(['vertex-program-two-side', 'enabled', 'front', 'back'],
- run_concurrent=True)
- g(['vertex-program-two-side', 'enabled', 'front', 'front2', 'back2'],
- run_concurrent=True)
- g(['vertex-program-two-side', 'enabled', 'front', 'front2'],
- run_concurrent=True)
- g(['vertex-program-two-side', 'enabled', 'front', 'back2'],
- run_concurrent=True)
- g(['vertex-program-two-side', 'enabled', 'front'], run_concurrent=True)
- g(['vertex-program-two-side', 'enabled', 'back', 'front2', 'back2'],
- run_concurrent=True)
- g(['vertex-program-two-side', 'enabled', 'back', 'front2'],
- run_concurrent=True)
- g(['vertex-program-two-side', 'enabled', 'back', 'back2'],
- run_concurrent=True)
- g(['vertex-program-two-side', 'enabled', 'back'], run_concurrent=True)
- g(['vertex-program-two-side', 'enabled', 'front2', 'back2'],
- run_concurrent=True)
- g(['vertex-program-two-side', 'enabled', 'front2'], run_concurrent=True)
- g(['vertex-program-two-side', 'enabled', 'back2'], run_concurrent=True)
- g(['vertex-program-two-side', 'enabled'], run_concurrent=True)
- g(['vertex-program-two-side', 'front', 'back', 'front2', 'back2'],
- run_concurrent=True)
- g(['vertex-program-two-side', 'front', 'back', 'front2'],
- run_concurrent=True)
- g(['vertex-program-two-side', 'front', 'back', 'back2'],
- run_concurrent=True)
- g(['vertex-program-two-side', 'front', 'back'], run_concurrent=True)
- g(['vertex-program-two-side', 'front', 'front2', 'back2'],
- run_concurrent=True)
- g(['vertex-program-two-side', 'front', 'front2'], run_concurrent=True)
- g(['vertex-program-two-side', 'front', 'back2'], run_concurrent=True)
- g(['vertex-program-two-side', 'front'], run_concurrent=True)
- g(['vertex-program-two-side', 'back', 'front2', 'back2'],
- run_concurrent=True)
- g(['vertex-program-two-side', 'back', 'front2'], run_concurrent=True)
- g(['vertex-program-two-side', 'back', 'back2'], run_concurrent=True)
- g(['vertex-program-two-side', 'back'], run_concurrent=True)
- g(['vertex-program-two-side', 'front2', 'back2'], run_concurrent=True)
- g(['vertex-program-two-side', 'front2'], run_concurrent=True)
- g(['vertex-program-two-side', 'back2'], run_concurrent=True)
- g(['vertex-program-two-side'], run_concurrent=True)
+ g(['vertex-program-two-side', 'enabled', 'front', 'back', 'front2',
+ 'back2'])
+ g(['vertex-program-two-side', 'enabled', 'front', 'back', 'front2'])
+ g(['vertex-program-two-side', 'enabled', 'front', 'back', 'back2'])
+ g(['vertex-program-two-side', 'enabled', 'front', 'back'])
+ g(['vertex-program-two-side', 'enabled', 'front', 'front2', 'back2'])
+ g(['vertex-program-two-side', 'enabled', 'front', 'front2'])
+ g(['vertex-program-two-side', 'enabled', 'front', 'back2'])
+ g(['vertex-program-two-side', 'enabled', 'front'])
+ g(['vertex-program-two-side', 'enabled', 'back', 'front2', 'back2'])
+ g(['vertex-program-two-side', 'enabled', 'back', 'front2'])
+ g(['vertex-program-two-side', 'enabled', 'back', 'back2'])
+ g(['vertex-program-two-side', 'enabled', 'back'])
+ g(['vertex-program-two-side', 'enabled', 'front2', 'back2'])
+ g(['vertex-program-two-side', 'enabled', 'front2'])
+ g(['vertex-program-two-side', 'enabled', 'back2'])
+ g(['vertex-program-two-side', 'enabled'])
+ g(['vertex-program-two-side', 'front', 'back', 'front2', 'back2'])
+ g(['vertex-program-two-side', 'front', 'back', 'front2'])
+ g(['vertex-program-two-side', 'front', 'back', 'back2'])
+ g(['vertex-program-two-side', 'front', 'back'])
+ g(['vertex-program-two-side', 'front', 'front2', 'back2'])
+ g(['vertex-program-two-side', 'front', 'front2'])
+ g(['vertex-program-two-side', 'front', 'back2'])
+ g(['vertex-program-two-side', 'front'])
+ g(['vertex-program-two-side', 'back', 'front2', 'back2'])
+ g(['vertex-program-two-side', 'back', 'front2'])
+ g(['vertex-program-two-side', 'back', 'back2'])
+ g(['vertex-program-two-side', 'back'])
+ g(['vertex-program-two-side', 'front2', 'back2'])
+ g(['vertex-program-two-side', 'front2'])
+ g(['vertex-program-two-side', 'back2'])
+ g(['vertex-program-two-side'])
g(['clear-varray-2.0'], run_concurrent=False)
g(['early-z'], run_concurrent=False)
g(['occlusion-query-discard'], run_concurrent=False)
@@ -1132,56 +1065,54 @@ with profile.group_manager(
g(['vs-point_size-zero'], run_concurrent=False)
g(['depth-tex-modes-glsl'], run_concurrent=False)
g(['fragment-and-vertex-texturing'], run_concurrent=False)
- g(['incomplete-texture', 'glsl'], 'incomplete-texture-glsl',
- run_concurrent=True)
+ g(['incomplete-texture', 'glsl'], 'incomplete-texture-glsl')
g(['tex3d-npot'], run_concurrent=False)
- g(['max-samplers'], run_concurrent=True)
- g(['max-samplers', 'border'], run_concurrent=True)
- g(['gl-2.0-active-sampler-conflict'], run_concurrent=True)
+ g(['max-samplers'])
+ g(['max-samplers', 'border'])
+ g(['gl-2.0-active-sampler-conflict'])
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', '!opengl 2.1')) as g:
- g(['gl-2.1-minmax'], 'minmax', run_concurrent=True)
- g(['gl-2.1-pbo'], 'pbo', run_concurrent=True)
+ g(['gl-2.1-minmax'], 'minmax')
+ g(['gl-2.1-pbo'], 'pbo')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', '!opengl 3.0')) as g:
- g(['attribs', 'GL3'], 'attribs', run_concurrent=True)
- g(['bindfragdata-invalid-parameters'], run_concurrent=True)
- g(['bindfragdata-link-error'], run_concurrent=True)
- g(['bindfragdata-nonexistent-variable'], run_concurrent=True)
+ g(['attribs', 'GL3'], 'attribs')
+ g(['bindfragdata-invalid-parameters'])
+ g(['bindfragdata-link-error'])
+ g(['bindfragdata-nonexistent-variable'])
g(['gl-3.0-bound-resource-limits'],
'bound-resource-limits',
- run_concurrent=True)
- g(['clearbuffer-depth'], run_concurrent=True)
- g(['clearbuffer-depth-stencil'], run_concurrent=True)
+ )
+ g(['clearbuffer-depth'])
+ g(['clearbuffer-depth-stencil'])
g(['clearbuffer-display-lists'], run_concurrent=False)
- g(['clearbuffer-invalid-drawbuffer'], run_concurrent=True)
- g(['clearbuffer-invalid-buffer'], run_concurrent=True)
- g(['clearbuffer-mixed-format'], run_concurrent=True)
- g(['clearbuffer-stencil'], run_concurrent=True)
- g(['genmipmap-errors'], run_concurrent=True)
- g(['getfragdatalocation'], run_concurrent=True)
- g(['integer-errors'], run_concurrent=True)
+ g(['clearbuffer-invalid-drawbuffer'])
+ g(['clearbuffer-invalid-buffer'])
+ g(['clearbuffer-mixed-format'])
+ g(['clearbuffer-stencil'])
+ g(['genmipmap-errors'])
+ g(['getfragdatalocation'])
+ g(['integer-errors'])
g(['gl-3.0-multidrawarrays-vertexid'],
- 'gl_VertexID used with glMultiDrawArrays',
- run_concurrent=True)
- g(['gl-3.0-minmax'], 'minmax', run_concurrent=True)
- g(['gl-3.0-render-integer'], 'render-integer', run_concurrent=True)
+ 'gl_VertexID used with glMultiDrawArrays')
+ g(['gl-3.0-minmax'], 'minmax')
+ g(['gl-3.0-render-integer'], 'render-integer')
g(['gl-3.0-required-sized-texture-formats', '30'],
- 'required-sized-texture-formats', run_concurrent=True)
+ 'required-sized-texture-formats')
g(['gl-3.0-required-renderbuffer-attachment-formats', '30'],
- 'required-renderbuffer-attachment-formats', run_concurrent=True)
+ 'required-renderbuffer-attachment-formats')
g(['gl-3.0-required-texture-attachment-formats', '30'],
- 'required-texture-attachment-formats', run_concurrent=True)
+ 'required-texture-attachment-formats')
g(['gl-3.0-forward-compatible-bit', 'yes'],
- 'forward-compatible-bit yes', run_concurrent=True)
+ 'forward-compatible-bit yes')
g(['gl-3.0-forward-compatible-bit', 'no'],
- 'forward-compatible-bit no', run_concurrent=True)
- g(['gl-3.0-texture-integer'], run_concurrent=True)
- g(['gl-3.0-vertexattribipointer'], run_concurrent=True)
+ 'forward-compatible-bit no')
+ g(['gl-3.0-texture-integer'])
+ g(['gl-3.0-vertexattribipointer'])
g(['gl30basic'], run_concurrent=False)
g(['array-depth-roundtrip'], run_concurrent=False)
g(['depth-cube-map'], run_concurrent=False)
@@ -1190,87 +1121,76 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', '!opengl 3.1')) as g:
- g(['gl-3.1-draw-buffers-errors'], 'draw-buffers-errors',
- run_concurrent=True)
- g(['gl-3.1-genned-names'], 'genned-names', run_concurrent=True)
- g(['gl-3.1-minmax'], 'minmax', run_concurrent=True)
- g(['gl-3.1-vao-broken-attrib'], 'vao-broken-attrib', run_concurrent=True)
+ g(['gl-3.1-draw-buffers-errors'], 'draw-buffers-errors')
+ g(['gl-3.1-genned-names'], 'genned-names')
+ g(['gl-3.1-minmax'], 'minmax')
+ g(['gl-3.1-vao-broken-attrib'], 'vao-broken-attrib')
g(['gl-3.0-required-renderbuffer-attachment-formats', '31'],
- 'required-renderbuffer-attachment-formats', run_concurrent=True)
+ 'required-renderbuffer-attachment-formats')
g(['gl-3.0-required-sized-texture-formats', '31'],
- 'required-sized-texture-formats', run_concurrent=True)
+ 'required-sized-texture-formats')
g(['gl-3.0-required-texture-attachment-formats', '31'],
- 'required-texture-attachment-formats', run_concurrent=True)
+ 'required-texture-attachment-formats')
for subtest in ['generated', 'written', 'flush']:
g(['gl-3.1-primitive-restart-xfb', subtest],
- 'primitive-restart-xfb {0}'.format(subtest), run_concurrent=True)
+ 'primitive-restart-xfb {0}'.format(subtest))
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', '!opengl 3.2')) as g:
- g(['glsl-resource-not-bound', '1D'], run_concurrent=True)
- g(['glsl-resource-not-bound', '2D'], run_concurrent=True)
- g(['glsl-resource-not-bound', '3D'], run_concurrent=True)
- g(['glsl-resource-not-bound', '2DRect'], run_concurrent=True)
- g(['glsl-resource-not-bound', '1DArray'], run_concurrent=True)
- g(['glsl-resource-not-bound', '2DArray'], run_concurrent=True)
- g(['glsl-resource-not-bound', '2DMS'], run_concurrent=True)
- g(['glsl-resource-not-bound', '2DMSArray'], run_concurrent=True)
- g(['glsl-resource-not-bound', 'Buffer'], run_concurrent=True)
- g(['glsl-resource-not-bound', 'Cube'], run_concurrent=True)
+ g(['glsl-resource-not-bound', '1D'])
+ g(['glsl-resource-not-bound', '2D'])
+ g(['glsl-resource-not-bound', '3D'])
+ g(['glsl-resource-not-bound', '2DRect'])
+ g(['glsl-resource-not-bound', '1DArray'])
+ g(['glsl-resource-not-bound', '2DArray'])
+ g(['glsl-resource-not-bound', '2DMS'])
+ g(['glsl-resource-not-bound', '2DMSArray'])
+ g(['glsl-resource-not-bound', 'Buffer'])
+ g(['glsl-resource-not-bound', 'Cube'])
g(['gl-3.2-basevertex-vertexid'],
- 'gl_VertexID used with glMultiDrawElementsBaseVertex',
- run_concurrent=True)
- g(['gl-3.2-minmax'], 'minmax', run_concurrent=True)
- g(['gl-3.2-clear-no-buffers'], 'clear-no-buffers', run_concurrent=True)
- g(['gl-3.2-depth-tex-sampling'], 'depth-tex-sampling', run_concurrent=True)
- g(['gl-3.2-get-buffer-parameter-i64v'], 'get-buffer-parameter-i64v',
- run_concurrent=True)
- g(['gl-3.2-get-integer-64iv'], 'get-integer-64iv', run_concurrent=True)
- g(['gl-3.2-get-integer-64v'], 'get-integer-64v', run_concurrent=True)
- g(['gl-3.2-pointsprite-coord'], 'pointsprite-coord', run_concurrent=True)
- g(['gl-3.2-pointsprite-origin'], 'pointsprite-origin', run_concurrent=True)
+ 'gl_VertexID used with glMultiDrawElementsBaseVertex')
+ g(['gl-3.2-minmax'], 'minmax')
+ g(['gl-3.2-clear-no-buffers'], 'clear-no-buffers')
+ g(['gl-3.2-depth-tex-sampling'], 'depth-tex-sampling')
+ g(['gl-3.2-get-buffer-parameter-i64v'], 'get-buffer-parameter-i64v')
+ g(['gl-3.2-get-integer-64iv'], 'get-integer-64iv')
+ g(['gl-3.2-get-integer-64v'], 'get-integer-64v')
+ g(['gl-3.2-pointsprite-coord'], 'pointsprite-coord')
+ g(['gl-3.2-pointsprite-origin'], 'pointsprite-origin')
g(['gl-coord-replace-doesnt-eliminate-frag-tex-coords'],
- 'coord-replace-doesnt-eliminate-frag-tex-coords',
- run_concurrent=True)
+ 'coord-replace-doesnt-eliminate-frag-tex-coords')
g(['gl-get-active-attrib-returns-all-inputs'],
- 'get-active-attrib-returns-all-inputs', run_concurrent=True)
- g(['gl-3.2-texture-border-deprecated'], 'texture-border-deprecated',
- run_concurrent=True)
+ 'get-active-attrib-returns-all-inputs')
+ g(['gl-3.2-texture-border-deprecated'], 'texture-border-deprecated')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', '!opengl 3.2', 'layered-rendering')) as g:
- g(['gl-3.2-layered-rendering-blit'], 'blit', run_concurrent=True)
- g(['gl-3.2-layered-rendering-clear-color'], 'clear-color',
- run_concurrent=True)
+ g(['gl-3.2-layered-rendering-blit'], 'blit')
+ g(['gl-3.2-layered-rendering-clear-color'], 'clear-color')
g(['gl-3.2-layered-rendering-clear-color-mismatched-layer-count'],
- 'clear-color-mismatched-layer-count', run_concurrent=True)
- g(['gl-3.2-layered-rendering-clear-depth'], 'clear-depth',
- run_concurrent=True)
- g(['gl-3.2-layered-rendering-framebuffertexture'], 'framebuffertexture',
- run_concurrent=True)
+ 'clear-color-mismatched-layer-count')
+ g(['gl-3.2-layered-rendering-clear-depth'], 'clear-depth')
+ g(['gl-3.2-layered-rendering-framebuffertexture'], 'framebuffertexture')
g(['gl-3.2-layered-rendering-framebuffertexture-buffer-textures'],
- 'framebuffertexture-buffer-textures', run_concurrent=True)
+ 'framebuffertexture-buffer-textures')
g(['gl-3.2-layered-rendering-framebuffertexture-defaults'],
- 'framebuffertexture-defaults', run_concurrent=True)
- g(['gl-3.2-layered-rendering-readpixels'], 'readpixels',
- run_concurrent=True)
+ 'framebuffertexture-defaults')
+ g(['gl-3.2-layered-rendering-readpixels'], 'readpixels')
g(['gl-3.2-layered-rendering-framebuffer-layer-attachment-mismatch'],
- 'framebuffer-layer-attachment-mismatch', run_concurrent=True)
+ 'framebuffer-layer-attachment-mismatch')
g(['gl-3.2-layered-rendering-framebuffer-layer-complete'],
- 'framebuffer-layer-complete', run_concurrent=True)
+ 'framebuffer-layer-complete')
g(['gl-3.2-layered-rendering-framebuffer-layer-count-mismatch'],
- 'framebuffer-layer-count-mismatch', run_concurrent=True)
+ 'framebuffer-layer-count-mismatch')
g(['gl-3.2-layered-rendering-framebuffer-layered-attachments'],
- 'framebuffer-layered-attachments', run_concurrent=True)
- g(['gl-3.2-layered-rendering-gl-layer'], 'gl-layer', run_concurrent=True)
- g(['gl-3.2-layered-rendering-gl-layer-cube-map'], 'gl-layer-cube-map',
- run_concurrent=True)
+ 'framebuffer-layered-attachments')
+ g(['gl-3.2-layered-rendering-gl-layer'], 'gl-layer')
+ g(['gl-3.2-layered-rendering-gl-layer-cube-map'], 'gl-layer-cube-map')
g(['gl-3.2-layered-rendering-gl-layer-not-layered'],
- 'gl-layer-not-layered', run_concurrent=True)
- g(['gl-3.2-layered-rendering-gl-layer-render'], 'gl-layer-render',
- run_concurrent=True)
+ 'gl-layer-not-layered')
+ g(['gl-3.2-layered-rendering-gl-layer-render'], 'gl-layer-render')
for texture_type in ['3d', '2d_array', '2d_multisample_array', '1d_array',
'cube_map', 'cube_map_array']:
@@ -1279,36 +1199,34 @@ with profile.group_manager(
continue
g(['gl-3.2-layered-rendering-clear-color-all-types', texture_type,
test_type],
- 'clear-color-all-types {} {}'.format(texture_type, test_type),
- run_concurrent=True)
+ 'clear-color-all-types {} {}'.format(texture_type, test_type))
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', '!opengl 3.3')) as g:
- g(['gl-3.3-minmax'], 'minmax', run_concurrent=True)
+ g(['gl-3.3-minmax'], 'minmax')
g(['gl-3.0-required-renderbuffer-attachment-formats', '33'],
- 'required-renderbuffer-attachment-formats', run_concurrent=True)
+ 'required-renderbuffer-attachment-formats')
g(['gl-3.0-required-sized-texture-formats', '33'],
- 'required-sized-texture-formats', run_concurrent=True)
+ 'required-sized-texture-formats')
g(['gl-3.0-required-texture-attachment-formats', '33'],
- 'required-texture-attachment-formats', run_concurrent=True)
+ 'required-texture-attachment-formats')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', '!opengl 4.2')) as g:
g(['gl-3.0-required-renderbuffer-attachment-formats', '42'],
- 'required-renderbuffer-attachment-formats', run_concurrent=True)
+ 'required-renderbuffer-attachment-formats')
g(['gl-3.0-required-sized-texture-formats', '42'],
- 'required-sized-texture-formats', run_concurrent=True)
+ 'required-sized-texture-formats')
g(['gl-3.0-required-texture-attachment-formats', '42'],
- 'required-texture-attachment-formats', run_concurrent=True)
- g(['gl-4.4-max_vertex_attrib_stride'], 'gl-max-vertex-attrib-stride',
- run_concurrent=True)
+ 'required-texture-attachment-formats')
+ g(['gl-4.4-max_vertex_attrib_stride'], 'gl-max-vertex-attrib-stride')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', '!opengl 4.4')) as g:
- g(['tex-errors'], run_concurrent=True)
+ g(['tex-errors'])
# Group spec/glsl-es-1.00
with profile.group_manager(
@@ -1316,21 +1234,21 @@ with profile.group_manager(
grouptools.join('spec', 'glsl-es-1.00')) as g:
g(['built-in-constants_gles2',
os.path.join(TESTS_DIR, 'spec', 'glsl-es-1.00', 'minimum-maximums.txt')],
- 'built-in constants', run_concurrent=True)
+ 'built-in constants')
# Group spec/glsl-1.10
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'glsl-1.10', 'execution')) as g:
- g(['glsl-render-after-bad-attach'], run_concurrent=True)
- g(['glsl-1.10-fragdepth'], run_concurrent=True)
+ g(['glsl-render-after-bad-attach'])
+ g(['glsl-1.10-fragdepth'])
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'glsl-1.10', 'execution', 'clipping')) as g:
for mode in ['fixed', 'pos_clipvert', 'clipvert_pos']:
g(['clip-plane-transformation', mode],
- 'clip-plane-transformation {}'.format(mode), run_concurrent=True)
+ 'clip-plane-transformation {}'.format(mode))
with profile.group_manager(
PiglitGLTest,
@@ -1342,33 +1260,33 @@ with profile.group_manager(
'mat4x3']:
for arrayspec in ['array', 'separate']:
g(['varying-packing-simple', type_, arrayspec],
- 'simple {} {}'.format(type_, arrayspec), run_concurrent=True)
+ 'simple {} {}'.format(type_, arrayspec))
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'glsl-1.10')) as g:
g(['built-in-constants',
os.path.join(TESTS_DIR, 'spec', 'glsl-1.10', 'minimum-maximums.txt')],
- 'built-in constants', run_concurrent=True)
+ 'built-in constants')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'glsl-1.10', 'api')) as g:
- g(['getactiveattrib', '110'], 'getactiveattrib 110', run_concurrent=True)
+ g(['getactiveattrib', '110'], 'getactiveattrib 110')
# Group spec/glsl-1.20
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'glsl-1.20')) as g:
- g(['glsl-1.20-getactiveuniform-constant'], run_concurrent=True)
+ g(['glsl-1.20-getactiveuniform-constant'])
g(['built-in-constants',
os.path.join(TESTS_DIR, 'spec', 'glsl-1.20','minimum-maximums.txt')],
- 'built-in constants', run_concurrent=True)
+ 'built-in constants')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'glsl-1.20', 'api')) as g:
- g(['getactiveattrib', '120'], run_concurrent=True)
+ g(['getactiveattrib', '120'])
with profile.group_manager(
PiglitGLTest,
@@ -1392,17 +1310,13 @@ with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'glsl-1.20', 'execution')) as g:
for test in ['1D', '2D', '3D', 'Cube', '1DShadow', '2DShadow']:
- g(['tex-miplevel-selection', 'GL2:texture()', test],
- run_concurrent=True)
- g(['tex-miplevel-selection', 'GL2:texture(bias)', test],
- run_concurrent=True)
+ g(['tex-miplevel-selection', 'GL2:texture()', test])
+ g(['tex-miplevel-selection', 'GL2:texture(bias)', test])
for test in ['1D', '1D_ProjVec4', '2D', '2D_ProjVec4', '3D', '1DShadow',
'2DShadow']:
- g(['tex-miplevel-selection', 'GL2:textureProj', test],
- run_concurrent=True)
- g(['tex-miplevel-selection', 'GL2:textureProj(bias)', test],
- run_concurrent=True)
+ g(['tex-miplevel-selection', 'GL2:textureProj', test])
+ g(['tex-miplevel-selection', 'GL2:textureProj(bias)', test])
textureSize_samplers_130 = [
'sampler1D', 'sampler2D', 'sampler3D', 'samplerCube', 'sampler1DShadow',
@@ -1421,151 +1335,122 @@ for stage in ['vs', 'gs', 'fs']:
profile.test_list[grouptools.join(
'spec', 'glsl-{}'.format(version), 'execution', 'textureSize',
'{}-textureSize-{}'.format(stage, sampler))] = PiglitGLTest(
- ['textureSize', stage, sampler],
- run_concurrent=True)
+ ['textureSize', stage, sampler])
# texelFetch():
for sampler in ['sampler1D', 'sampler2D', 'sampler3D', 'sampler1DArray', 'sampler2DArray', 'isampler1D', 'isampler2D', 'isampler3D', 'isampler1DArray', 'isampler2DArray', 'usampler1D', 'usampler2D', 'usampler3D', 'usampler1DArray', 'usampler2DArray']:
profile.test_list[grouptools.join(
'spec', 'glsl-{}'.format(version), 'execution', 'texelFetch',
'{}-texelFetch-{}'.format(stage, sampler))] = PiglitGLTest(
- ['texelFetch', stage, sampler],
- run_concurrent=True)
+ ['texelFetch', stage, sampler])
profile.test_list[grouptools.join(
'spec', 'glsl-{}'.format(version), 'execution', 'texelFetchOffset',
'{}-texelFetch-{}'.format(stage, sampler))] = PiglitGLTest(
- ['texelFetch', 'offset', stage, sampler],
- run_concurrent=True)
+ ['texelFetch', 'offset', stage, sampler])
# texelFetch() with EXT_texture_swizzle mode "b0r1":
for type in ['i', 'u', '']:
profile.test_list[grouptools.join(
'spec', 'glsl-{}'.format(version), 'execution', 'texelFetch',
'{}-texelFetch-{}sampler2Darray-swizzle'.format(stage, type))] = PiglitGLTest(
- ['texelFetch', stage, '{}sampler2DArray'.format(type), 'b0r1'],
- run_concurrent=True)
+ ['texelFetch', stage, '{}sampler2DArray'.format(type), 'b0r1'])
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'glsl-1.30')) as g:
- g(['glsl-1.30-texel-offset-limits'], 'texel-offset-limits',
- run_concurrent=True)
+ g(['glsl-1.30-texel-offset-limits'], 'texel-offset-limits')
g(['built-in-constants',
os.path.join(TESTS_DIR, 'spec', 'glsl-1.30', 'minimum-maximums.txt')],
- 'built-in constants', run_concurrent=True)
+ 'built-in constants')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'glsl-1.30', 'execution')) as g:
- g(['texelFetch', 'fs', 'sampler1D', '1-513'], run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler1DArray', '1x71-501x71'],
- run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler1DArray', '1x281-501x281'],
- run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler1DArray', '71x1-71x281'],
- run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler1DArray', '281x1-281x281'],
- run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler2D', '1x71-501x71'], run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler2D', '1x281-501x281'], run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler2D', '71x1-71x281'], run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler2D', '281x1-281x281'], run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler3D', '1x129x9-98x129x9'],
- run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler3D', '98x1x9-98x129x9'],
- run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler3D', '98x129x1-98x129x9'],
- run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler2DArray', '1x129x9-98x129x9'],
- run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler2DArray', '98x1x9-98x129x9'],
- run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler2DArray', '98x129x1-98x129x9'],
- run_concurrent=True)
- g(['fs-texelFetch-2D'], run_concurrent=True)
- g(['fs-texelFetchOffset-2D'], run_concurrent=True)
- g(['fs-textureOffset-2D'], run_concurrent=True)
- g(['fs-discard-exit-2'], run_concurrent=True)
- g(['vertexid-beginend'], run_concurrent=True)
- g(['vertexid-drawarrays'], run_concurrent=True)
- g(['vertexid-drawelements'], run_concurrent=True)
- g(['fs-execution-ordering'], run_concurrent=True)
+ g(['texelFetch', 'fs', 'sampler1D', '1-513'])
+ g(['texelFetch', 'fs', 'sampler1DArray', '1x71-501x71'])
+ g(['texelFetch', 'fs', 'sampler1DArray', '1x281-501x281'])
+ g(['texelFetch', 'fs', 'sampler1DArray', '71x1-71x281'])
+ g(['texelFetch', 'fs', 'sampler1DArray', '281x1-281x281'])
+ g(['texelFetch', 'fs', 'sampler2D', '1x71-501x71'])
+ g(['texelFetch', 'fs', 'sampler2D', '1x281-501x281'])
+ g(['texelFetch', 'fs', 'sampler2D', '71x1-71x281'])
+ g(['texelFetch', 'fs', 'sampler2D', '281x1-281x281'])
+ g(['texelFetch', 'fs', 'sampler3D', '1x129x9-98x129x9'])
+ g(['texelFetch', 'fs', 'sampler3D', '98x1x9-98x129x9'])
+ g(['texelFetch', 'fs', 'sampler3D', '98x129x1-98x129x9'])
+ g(['texelFetch', 'fs', 'sampler2DArray', '1x129x9-98x129x9'])
+ g(['texelFetch', 'fs', 'sampler2DArray', '98x1x9-98x129x9'])
+ g(['texelFetch', 'fs', 'sampler2DArray', '98x129x1-98x129x9'])
+ g(['fs-texelFetch-2D'])
+ g(['fs-texelFetchOffset-2D'])
+ g(['fs-textureOffset-2D'])
+ g(['fs-discard-exit-2'])
+ g(['vertexid-beginend'])
+ g(['vertexid-drawarrays'])
+ g(['vertexid-drawelements'])
+ g(['fs-execution-ordering'])
for stage in ['1D', '2D', '3D', 'Cube', '1DShadow', '2DShadow', '1DArray',
'2DArray', '1DArrayShadow', 'CubeArray']:
- g(['tex-miplevel-selection', 'textureLod', stage], run_concurrent=True)
+ g(['tex-miplevel-selection', 'textureLod', stage])
for stage in ['1D', '2D', '3D', 'Cube', '1DShadow', '2DShadow',
'CubeShadow', '1DArray', '2DArray', 'CubeArray',
'1DArrayShadow']:
- g(['tex-miplevel-selection', 'texture(bias)', stage],
- run_concurrent=True)
+ g(['tex-miplevel-selection', 'texture(bias)', stage])
for stage in ['1D', '2D', '3D', 'Cube', '1DShadow', '2DShadow',
'CubeShadow', '1DArray', '2DArray', 'CubeArray',
'1DArrayShadow', '2DArrayShadow', '2DRect', '2DRectShadow',
'CubeArrayShadow']:
- g(['tex-miplevel-selection', 'texture()', stage], run_concurrent=True)
+ g(['tex-miplevel-selection', 'texture()', stage])
for stage in ['1D', '2D', '3D', '2DRect', '2DRectShadow', '1DShadow',
'2DShadow', '1DArray', '2DArray', '1DArrayShadow',
'2DArrayShadow']:
- g(['tex-miplevel-selection', 'textureOffset', stage],
- run_concurrent=True)
+ g(['tex-miplevel-selection', 'textureOffset', stage])
for stage in ['1D', '2D', '3D', '1DShadow', '2DShadow', '1DArray',
'2DArray', '1DArrayShadow']:
- g(['tex-miplevel-selection', 'textureOffset(bias)', stage],
- run_concurrent=True)
+ g(['tex-miplevel-selection', 'textureOffset(bias)', stage])
for stage in ['1D', '1D_ProjVec4', '2D', '2D_ProjVec4', '3D', '1DShadow',
'2DShadow', '2DRect', '2DRect_ProjVec4', '2DRectShadow']:
- g(['tex-miplevel-selection', 'textureProj', stage],
- run_concurrent=True)
+ g(['tex-miplevel-selection', 'textureProj', stage])
for stage in ['1D', '1D_ProjVec4', '2D', '2D_ProjVec4', '3D', '1DShadow',
'2DShadow']:
- g(['tex-miplevel-selection', 'textureProj(bias)', stage],
- run_concurrent=True)
+ g(['tex-miplevel-selection', 'textureProj(bias)', stage])
for stage in ['1D', '1D_ProjVec4', '2D', '2D_ProjVec4', '3D', '2DRect',
'2DRect_ProjVec4', '2DRectShadow', '1DShadow', '2DShadow']:
- g(['tex-miplevel-selection', 'textureProjOffset', stage],
- run_concurrent=True)
+ g(['tex-miplevel-selection', 'textureProjOffset', stage])
for stage in ['1D', '1D_ProjVec4', '2D', '2D_ProjVec4', '3D', '1DShadow',
'2DShadow']:
- g(['tex-miplevel-selection', 'textureProjOffset(bias)', stage],
- run_concurrent=True)
+ g(['tex-miplevel-selection', 'textureProjOffset(bias)', stage])
for stage in ['1D','2D','3D', '1DShadow', '2DShadow', '1DArray', '2DArray',
'1DArrayShadow']:
- g(['tex-miplevel-selection', 'textureLodOffset', stage],
- run_concurrent=True)
+ g(['tex-miplevel-selection', 'textureLodOffset', stage])
for stage in ['1D', '2D', '3D', '1D_ProjVec4', '2D_ProjVec4', '1DShadow',
'2DShadow']:
- g(['tex-miplevel-selection', 'textureProjLod', stage],
- run_concurrent=True)
- g(['tex-miplevel-selection', 'textureProjLodOffset', stage],
- run_concurrent=True)
+ g(['tex-miplevel-selection', 'textureProjLod', stage])
+ g(['tex-miplevel-selection', 'textureProjLodOffset', stage])
for stage in ['1D', '2D', '3D', 'Cube', '2DRect', '2DRectShadow',
'1DShadow', '2DShadow', 'CubeShadow', '1DArray', '2DArray',
'1DArrayShadow', '2DArrayShadow', 'CubeArray']:
- g(['tex-miplevel-selection', 'textureGrad', stage],
- run_concurrent=True)
+ g(['tex-miplevel-selection', 'textureGrad', stage])
for stage in ['1D', '2D', '3D','2DRect', '2DRectShadow', '1DShadow',
'2DShadow', '1DArray', '2DArray', '1DArrayShadow',
'2DArrayShadow']:
- g(['tex-miplevel-selection', 'textureGradOffset', stage],
- run_concurrent=True)
+ g(['tex-miplevel-selection', 'textureGradOffset', stage])
for stage in ['1D', '2D', '3D', '1D_ProjVec4', '2D_ProjVec4', '2DRect',
'2DRect_ProjVec4', '1DShadow', '2DShadow', '2DRectShadow']:
- g(['tex-miplevel-selection', 'textureProjGrad', stage],
- run_concurrent=True)
- g(['tex-miplevel-selection', 'textureProjGradOffset', stage],
- run_concurrent=True)
+ g(['tex-miplevel-selection', 'textureProjGrad', stage])
+ g(['tex-miplevel-selection', 'textureProjGradOffset', stage])
with profile.group_manager(
PiglitGLTest,
@@ -1582,7 +1467,7 @@ with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'glsl-1.30', 'execution', 'clipping')) as g:
g(['max-clip-distances'], run_concurrent=False)
- g(['clip-plane-transformation', 'pos'], run_concurrent=True)
+ g(['clip-plane-transformation', 'pos'])
with profile.group_manager(
PiglitGLTest,
@@ -1595,13 +1480,12 @@ with profile.group_manager(
grouptools.join('spec', 'glsl-1.40')) as g:
g(['built-in-constants',
os.path.join(TESTS_DIR, 'spec', 'glsl-1.40', 'minimum-maximums.txt')],
- 'built-in constants',
- run_concurrent=True)
+ 'built-in constants')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'glsl-1.40', 'execution')) as g:
- g(['glsl-1.40-tf-no-position'], 'tf-no-position', run_concurrent=True)
+ g(['glsl-1.40-tf-no-position'], 'tf-no-position')
textureSize_samplers_140 = textureSize_samplers_130 + [
'sampler2DRect', 'isampler2DRect', 'sampler2DRectShadow', 'samplerBuffer',
@@ -1616,41 +1500,34 @@ for stage in ['vs', 'gs', 'fs']:
profile.test_list[grouptools.join(
'spec', 'glsl-{}'.format(version), 'execution', 'textureSize',
'{}-textureSize-{}'.format(stage, sampler))] = PiglitGLTest(
- ['textureSize', '140', stage, sampler],
- run_concurrent=True)
+ ['textureSize', '140', stage, sampler])
# texelFetch():
for sampler in ['sampler2DRect', 'usampler2DRect', 'isampler2DRect']:
profile.test_list[grouptools.join(
'spec', 'glsl-{}'.format(version), 'execution', 'texelFetch',
'{}-texelFetch-{}'.format(stage, sampler))] = PiglitGLTest(
- ['texelFetch', '140', stage, sampler],
- run_concurrent=True)
+ ['texelFetch', '140', stage, sampler])
profile.test_list[grouptools.join(
'spec', 'glsl-{}'.format(version), 'execution', 'texelFetchOffset',
'{}-{}'.format(stage, sampler))] = PiglitGLTest(
- ['texelFetch', 'offset', '140', stage, sampler],
- run_concurrent=True)
+ ['texelFetch', 'offset', '140', stage, sampler])
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'glsl-1.50')) as g:
g(['built-in-constants',
os.path.join(TESTS_DIR, 'spec', 'glsl-1.50', 'minimum-maximums.txt')],
- 'built-in constants', run_concurrent=True)
- g(['glsl-1.50-gs-emits-too-few-verts'], 'gs-emits-too-few-verts',
- run_concurrent=True)
+ 'built-in constants')
+ g(['glsl-1.50-gs-emits-too-few-verts'], 'gs-emits-too-few-verts')
g(['glsl-1.50-geometry-end-primitive-optional-with-points-out'],
- 'gs-end-primitive-optional-with-points-out', run_concurrent=True)
- g(['glsl-1.50-getshaderiv-may-return-GS'], 'getshaderiv-may-return-GS',
- run_concurrent=True)
- g(['glsl-1.50-query-gs-prim-types'], 'query-gs-prim-types',
- run_concurrent=True)
+ 'gs-end-primitive-optional-with-points-out')
+ g(['glsl-1.50-getshaderiv-may-return-GS'], 'getshaderiv-may-return-GS')
+ g(['glsl-1.50-query-gs-prim-types'], 'query-gs-prim-types')
g(['glsl-1.50-transform-feedback-type-and-size'],
- 'transform-feedback-type-and-size', run_concurrent=True)
+ 'transform-feedback-type-and-size')
g(['glsl-1.50-transform-feedback-vertex-id'],
- 'transform-feedback-vertex-id', run_concurrent=True)
- g(['glsl-1.50-transform-feedback-builtins'], 'transform-feedback-builtins',
- run_concurrent=True)
+ 'transform-feedback-vertex-id')
+ g(['glsl-1.50-transform-feedback-builtins'], 'transform-feedback-builtins')
for draw in ['', 'indexed']:
for prim in ['GL_LINES_ADJACENCY', 'GL_LINE_STRIP_ADJACENCY',
@@ -1659,29 +1536,25 @@ with profile.group_manager(
'core', draw, prim], run_concurrent=False)
for subtest in ['unnamed', 'named', 'array']:
- g(['glsl-1.50-interface-block-centroid', subtest], run_concurrent=True)
+ g(['glsl-1.50-interface-block-centroid', subtest])
for layout_type in ['points', 'lines', 'lines_adjacency', 'triangles',
'triangles_adjacency']:
- g(['glsl-1.50-gs-mismatch-prim-type', layout_type], run_concurrent=True)
+ g(['glsl-1.50-gs-mismatch-prim-type', layout_type])
for layout in ['points', 'lines', 'lines_adjacency', 'triangles',
'triangles_adjacency', 'line_strip', 'triangle_strip']:
- g(['glsl-1.50-gs-input-layout-qualifiers', layout],
- run_concurrent=True)
- g(['glsl-1.50-gs-output-layout-qualifiers', layout],
- run_concurrent=True)
+ g(['glsl-1.50-gs-input-layout-qualifiers', layout])
+ g(['glsl-1.50-gs-output-layout-qualifiers', layout])
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'glsl-1.50', 'execution')) as g:
- g(['glsl-1.50-get-active-attrib-array'], 'get-active-attrib-array',
- run_concurrent=True)
+ g(['glsl-1.50-get-active-attrib-array'], 'get-active-attrib-array')
g(['glsl-1.50-interface-blocks-api-access-members'],
- 'interface-blocks-api-access-members', run_concurrent=True)
- g(['glsl-1.50-vs-input-arrays'], 'vs-input-arrays', run_concurrent=True)
- g(['glsl-1.50-vs-named-block-no-modify'], 'vs-named-block-no-modify',
- run_concurrent=True)
+ 'interface-blocks-api-access-members')
+ g(['glsl-1.50-vs-input-arrays'], 'vs-input-arrays')
+ g(['glsl-1.50-vs-named-block-no-modify'], 'vs-named-block-no-modify')
# max_vertices of 32 and 128 are important transition points for
# mesa/i965 (they are the number of bits in a float and a vec4,
@@ -1693,44 +1566,42 @@ with profile.group_manager(
grouptools.join('spec', 'glsl-1.50', 'execution', 'geometry')) as g:
for i in [31, 32, 33, 34, 127, 128, 129, 130, 0]:
g(['glsl-1.50-geometry-end-primitive', str(i)],
- 'end-primitive {0}'.format(i), run_concurrent=True)
+ 'end-primitive {0}'.format(i))
for prim_type in ['GL_POINTS', 'GL_LINE_LOOP', 'GL_LINE_STRIP', 'GL_LINES',
'GL_TRIANGLES', 'GL_TRIANGLE_STRIP', 'GL_TRIANGLE_FAN',
'GL_LINES_ADJACENCY', 'GL_LINE_STRIP_ADJACENCY',
'GL_TRIANGLES_ADJACENCY', 'GL_TRIANGLE_STRIP_ADJACENCY']:
g(['glsl-1.50-geometry-primitive-types', prim_type],
- 'primitive-types {0}'.format(prim_type), run_concurrent=True)
+ 'primitive-types {0}'.format(prim_type))
for restart_index in ['ffs', 'other']:
g(['glsl-1.50-geometry-primitive-id-restart', prim_type, restart_index],
- 'primitive-id-restart {0} {1}'.format(prim_type, restart_index),
- run_concurrent=True)
+ 'primitive-id-restart {0} {1}'.format(prim_type, restart_index))
for prim_type in ['GL_TRIANGLE_STRIP', 'GL_TRIANGLE_STRIP_ADJACENCY']:
for restart_index in ['ffs', 'other']:
g(['glsl-1.50-geometry-tri-strip-ordering-with-prim-restart',
prim_type, restart_index],
'tri-strip-ordering-with-prim-restart {0} {1}'.format(
- prim_type, restart_index),
- run_concurrent=True)
+ prim_type, restart_index))
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'glsl-3.30')) as g:
g(['built-in-constants',
os.path.join(TESTS_DIR, 'spec', 'glsl-3.30', 'minimum-maximums.txt')],
- 'built-in constants', run_concurrent=True)
+ 'built-in constants')
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'glsl-es-3.00')) as g:
g(['built-in-constants_gles3',
os.path.join(TESTS_DIR, 'spec', 'glsl-es-3.00', 'minimum-maximums.txt')],
- 'built-in constants', run_concurrent=True)
+ 'built-in constants')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'glsl-es-3.00', 'execution')) as g:
- g(['varying-struct-centroid_gles3'], run_concurrent=True)
+ g(['varying-struct-centroid_gles3'])
# AMD_performance_monitor
with profile.group_manager(
@@ -1746,50 +1617,42 @@ with profile.group_manager(
# Group ARB_tessellation_shader
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'ARB_tessellation_shader')) as g:
- g(['arb_tessellation_shader-get-tcs-params'], run_concurrent=True)
- g(['arb_tessellation_shader-get-tes-params'], run_concurrent=True)
- g(['arb_tessellation_shader-minmax'], run_concurrent=True)
- g(['arb_tessellation_shader-invalid-get-program-params'], run_concurrent=True)
- g(['arb_tessellation_shader-invalid-patch-vertices-range'], run_concurrent=True)
- g(['arb_tessellation_shader-invalid-primitive'], run_concurrent=True)
+ g(['arb_tessellation_shader-get-tcs-params'])
+ g(['arb_tessellation_shader-get-tes-params'])
+ g(['arb_tessellation_shader-minmax'])
+ g(['arb_tessellation_shader-invalid-get-program-params'])
+ g(['arb_tessellation_shader-invalid-patch-vertices-range'])
+ g(['arb_tessellation_shader-invalid-primitive'])
g(['built-in-constants',
os.path.join(TESTS_DIR, 'spec', 'arb_tessellation_shader',
'minimum-maximums.txt')],
- 'built-in-constants', run_concurrent=True)
- g(['arb_tessellation_shader-minmax'], run_concurrent=True)
+ 'built-in-constants')
+ g(['arb_tessellation_shader-minmax'])
# Group ARB_texture_multisample
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'ARB_texture_multisample')) as g:
- g(['arb_texture_multisample-minmax'], run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler2DMS', '4', '1x71-501x71'],
- run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler2DMS', '4', '1x130-501x130'],
- run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler2DMS', '4', '71x1-71x130'],
- run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler2DMS', '4', '281x1-281x130'],
- run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler2DMSArray', '4', '1x129x9-98x129x9'],
- run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler2DMSArray', '4', '98x1x9-98x129x9'],
- run_concurrent=True)
- g(['texelFetch', 'fs', 'sampler2DMSArray', '4', '98x129x1-98x129x9'],
- run_concurrent=True)
- g(['arb_texture_multisample-texstate'], run_concurrent=True)
- g(['arb_texture_multisample-errors'], run_concurrent=True)
- g(['arb_texture_multisample-texelfetch', '2'], run_concurrent=True)
- g(['arb_texture_multisample-texelfetch', '4'], run_concurrent=True)
- g(['arb_texture_multisample-texelfetch', '8'], run_concurrent=True)
- g(['arb_texture_multisample-sample-mask'], run_concurrent=True)
- g(['arb_texture_multisample-sample-mask-value'], run_concurrent=True)
- g(['arb_texture_multisample-sample-mask-execution'], run_concurrent=True)
- g(['arb_texture_multisample-sample-mask-execution', '-tex'],
- run_concurrent=True)
- g(['arb_texture_multisample-negative-max-samples'], run_concurrent=True)
- g(['arb_texture_multisample-teximage-3d-multisample'], run_concurrent=True)
- g(['arb_texture_multisample-teximage-2d-multisample'], run_concurrent=True)
- g(['arb_texture_multisample-sample-depth'], run_concurrent=True)
+ g(['arb_texture_multisample-minmax'])
+ g(['texelFetch', 'fs', 'sampler2DMS', '4', '1x71-501x71'])
+ g(['texelFetch', 'fs', 'sampler2DMS', '4', '1x130-501x130'])
+ g(['texelFetch', 'fs', 'sampler2DMS', '4', '71x1-71x130'])
+ g(['texelFetch', 'fs', 'sampler2DMS', '4', '281x1-281x130'])
+ g(['texelFetch', 'fs', 'sampler2DMSArray', '4', '1x129x9-98x129x9'])
+ g(['texelFetch', 'fs', 'sampler2DMSArray', '4', '98x1x9-98x129x9'])
+ g(['texelFetch', 'fs', 'sampler2DMSArray', '4', '98x129x1-98x129x9'])
+ g(['arb_texture_multisample-texstate'])
+ g(['arb_texture_multisample-errors'])
+ g(['arb_texture_multisample-texelfetch', '2'])
+ g(['arb_texture_multisample-texelfetch', '4'])
+ g(['arb_texture_multisample-texelfetch', '8'])
+ g(['arb_texture_multisample-sample-mask'])
+ g(['arb_texture_multisample-sample-mask-value'])
+ g(['arb_texture_multisample-sample-mask-execution'])
+ g(['arb_texture_multisample-sample-mask-execution', '-tex'])
+ g(['arb_texture_multisample-negative-max-samples'])
+ g(['arb_texture_multisample-teximage-3d-multisample'])
+ g(['arb_texture_multisample-teximage-2d-multisample'])
+ g(['arb_texture_multisample-sample-depth'])
samplers_atm = ['sampler2DMS', 'isampler2DMS', 'usampler2DMS',
'sampler2DMSArray', 'isampler2DMSArray', 'usampler2DMSArray']
@@ -1801,7 +1664,7 @@ with profile.group_manager(
for sample_count in (str(x) for x in MSAA_SAMPLE_COUNTS):
# fb-completeness
g(['arb_texture_multisample-fb-completeness', sample_count],
- sample_count, run_concurrent=True)
+ sample_count)
with profile.group_manager(
PiglitGLTest,
@@ -1811,8 +1674,7 @@ with profile.group_manager(
for sampler, stage, sample_count in itertools.product(
samplers_atm, stages, (str(x) for x in MSAA_SAMPLE_COUNTS)):
g(['texelFetch', stage, sampler, sample_count],
- '{}-{}-{}'.format(sample_count, stage, sampler),
- run_concurrent=True)
+ '{}-{}-{}'.format(sample_count, stage, sampler))
with profile.group_manager(
PiglitGLTest,
@@ -1821,7 +1683,7 @@ with profile.group_manager(
# sample positions
for sample_count in (str(x) for x in MSAA_SAMPLE_COUNTS):
g(['arb_texture_multisample-sample-position', sample_count],
- sample_count, run_concurrent=True)
+ sample_count)
with profile.group_manager(
@@ -1831,7 +1693,7 @@ with profile.group_manager(
stages = ['vs', 'gs', 'fs']
for stage, sampler in itertools.product(stages, samplers_atm):
g(['textureSize', stage, sampler],
- '{}-textureSize-{}'.format(stage, sampler), run_concurrent=True)
+ '{}-textureSize-{}'.format(stage, sampler))
# Group ARB_texture_gather
with profile.group_manager(
@@ -1852,26 +1714,25 @@ with profile.group_manager(
type_, sampler))
g(['textureGather', stage,
'offset' if func == 'textureGatherOffset' else '',
- comp, swiz, type_, sampler], testname, run_concurrent=True)
+ comp, swiz, type_, sampler], testname)
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ARB_stencil_texturing')) as g:
- g(['arb_stencil_texturing-draw'], 'draw', run_concurrent=True)
+ g(['arb_stencil_texturing-draw'], 'draw')
# Group ARB_sync
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'ARB_sync')) as g:
- g(['arb_sync-client-wait-errors'], 'ClientWaitSync-errors',
- run_concurrent=True)
- g(['arb_sync-delete'], 'DeleteSync', run_concurrent=True)
- g(['arb_sync-fence-sync-errors'], 'FenceSync-errors', run_concurrent=True)
- g(['arb_sync-get-sync-errors'], 'GetSynciv-errors', run_concurrent=True)
- g(['arb_sync-is-sync'], 'IsSync', run_concurrent=True)
- g(['arb_sync-repeat-wait'], 'repeat-wait', run_concurrent=True)
- g(['arb_sync-sync-initialize'], 'sync-initialize', run_concurrent=True)
- g(['arb_sync-timeout-zero'], 'timeout-zero', run_concurrent=True)
- g(['arb_sync-WaitSync-errors'], 'WaitSync-errors', run_concurrent=True)
+ g(['arb_sync-client-wait-errors'], 'ClientWaitSync-errors')
+ g(['arb_sync-delete'], 'DeleteSync')
+ g(['arb_sync-fence-sync-errors'], 'FenceSync-errors')
+ g(['arb_sync-get-sync-errors'], 'GetSynciv-errors')
+ g(['arb_sync-is-sync'], 'IsSync')
+ g(['arb_sync-repeat-wait'], 'repeat-wait')
+ g(['arb_sync-sync-initialize'], 'sync-initialize')
+ g(['arb_sync-timeout-zero'], 'timeout-zero')
+ g(['arb_sync-WaitSync-errors'], 'WaitSync-errors')
g(['sync_api'], run_concurrent=False)
# Group ARB_ES2_compatibility
@@ -1886,14 +1747,11 @@ with profile.group_manager(
g(['arb_es2_compatibility-fixed-type'], run_concurrent=False)
g(['fbo-missing-attachment-clear'], run_concurrent=False)
g(['fbo-missing-attachment-blit', 'es2', 'to'],
- 'FBO blit to missing attachment (ES2 completeness rules)',
- run_concurrent=True)
+ 'FBO blit to missing attachment (ES2 completeness rules)')
g(['fbo-missing-attachment-blit', 'es2', 'from'],
- 'FBO blit from missing attachment (ES2 completeness rules)',
- run_concurrent=True)
+ 'FBO blit from missing attachment (ES2 completeness rules)')
g(['arb_get_program_binary-overrun', 'shader'],
- 'NUM_SHADER_BINARY_FORMATS over-run check',
- run_concurrent=True)
+ 'NUM_SHADER_BINARY_FORMATS over-run check')
add_texwrap_format_tests(g, 'GL_ARB_ES2_compatibility')
add_fbo_formats_tests(g, 'GL_ARB_ES2_compatibility')
@@ -1902,11 +1760,11 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'ARB_get_program_binary')) as g:
g(['arb_get_program_binary-api-errors'],
- 'misc. API error checks', run_concurrent=True)
+ 'misc. API error checks')
g(['arb_get_program_binary-overrun', 'program'],
- 'NUM_PROGRAM_BINARY_FORMATS over-run check', run_concurrent=True)
+ 'NUM_PROGRAM_BINARY_FORMATS over-run check')
g(['arb_get_program_binary-retrievable_hint'],
- 'PROGRAM_BINARY_RETRIEVABLE_HINT', run_concurrent=True)
+ 'PROGRAM_BINARY_RETRIEVABLE_HINT')
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'ARB_depth_clamp')) as g:
@@ -1918,7 +1776,7 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ARB_draw_elements_base_vertex')) as g:
- g(['arb_draw_elements_base_vertex-dlist'], 'dlist', run_concurrent=True)
+ g(['arb_draw_elements_base_vertex-dlist'], 'dlist')
g(['arb_draw_elements_base_vertex-drawelements'], run_concurrent=False)
g(['arb_draw_elements_base_vertex-drawelements', 'user_varrays'],
'arb_draw_elements_base_vertex-drawelements-user_varrays',
@@ -1937,37 +1795,37 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ARB_draw_instanced')) as g:
- g(['arb_draw_instanced-dlist'], 'dlist', run_concurrent=True)
- g(['arb_draw_instanced-elements'], 'elements', run_concurrent=True)
+ g(['arb_draw_instanced-dlist'], 'dlist')
+ g(['arb_draw_instanced-elements'], 'elements')
g(['arb_draw_instanced-negative-arrays-first-negative'],
- 'negative-arrays-first-negative', run_concurrent=True)
+ 'negative-arrays-first-negative')
g(['arb_draw_instanced-negative-elements-type'],
- 'negative-elements-type', run_concurrent=True)
+ 'negative-elements-type')
g(['arb_draw_instanced-drawarrays'], run_concurrent=False)
# Group ARB_draw_indirect
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ARB_draw_indirect')) as g:
- g(['arb_draw_indirect-api-errors'], run_concurrent=True)
- g(['arb_draw_indirect-draw-arrays'], run_concurrent=True)
- g(['arb_draw_indirect-draw-arrays-prim-restart'], run_concurrent=True)
- g(['arb_draw_indirect-draw-elements'], run_concurrent=True)
- g(['arb_draw_indirect-draw-arrays-base-instance'], run_concurrent=True)
- g(['arb_draw_indirect-draw-elements-base-instance'], run_concurrent=True)
- g(['arb_draw_indirect-draw-elements-prim-restart'], run_concurrent=True)
- g(['arb_draw_indirect-draw-elements-prim-restart-ugly'], run_concurrent=True)
- g(['arb_draw_indirect-draw-arrays-instances'], run_concurrent=True)
+ g(['arb_draw_indirect-api-errors'])
+ g(['arb_draw_indirect-draw-arrays'])
+ g(['arb_draw_indirect-draw-arrays-prim-restart'])
+ g(['arb_draw_indirect-draw-elements'])
+ g(['arb_draw_indirect-draw-arrays-base-instance'])
+ g(['arb_draw_indirect-draw-elements-base-instance'])
+ g(['arb_draw_indirect-draw-elements-prim-restart'])
+ g(['arb_draw_indirect-draw-elements-prim-restart-ugly'])
+ g(['arb_draw_indirect-draw-arrays-instances'])
g(['arb_draw_indirect-vertexid'],
- 'gl_VertexID used with glDrawArraysIndirect', run_concurrent=True)
+ 'gl_VertexID used with glDrawArraysIndirect')
g(['arb_draw_indirect-vertexid', 'elements'],
- 'gl_VertexID used with glDrawElementsIndirect', run_concurrent=True)
+ 'gl_VertexID used with glDrawElementsIndirect')
# Group ARB_fragment_program
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ARB_fragment_program')) as g:
- g(['arb_fragment_program-minmax'], 'minmax', run_concurrent=True)
+ g(['arb_fragment_program-minmax'], 'minmax')
g(['fp-abs-01'], run_concurrent=False)
g(['fp-fog'], run_concurrent=False)
g(['fp-formats'], run_concurrent=False)
@@ -1981,10 +1839,8 @@ with profile.group_manager(
g(['fp-long-alu'], run_concurrent=False)
g(['fp-set-01'], run_concurrent=False)
g(['trinity-fp1'], run_concurrent=False)
- g(['arb_fragment_program-sparse-samplers'], 'sparse-samplers',
- run_concurrent=True)
- g(['incomplete-texture', 'arb_fp'], 'incomplete-texture-arb_fp',
- run_concurrent=True)
+ g(['arb_fragment_program-sparse-samplers'], 'sparse-samplers')
+ g(['incomplete-texture', 'arb_fp'], 'incomplete-texture-arb_fp')
add_vpfpgeneric(g, 'fdo30337a')
add_vpfpgeneric(g, 'fdo30337b')
add_vpfpgeneric(g, 'fdo38145')
@@ -2012,64 +1868,60 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ATI_fragment_shader')) as g:
- g(['ati-fs-bad-delete'], run_concurrent=True)
+ g(['ati-fs-bad-delete'])
# Group ARB_framebuffer_object
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ARB_framebuffer_object')) as g:
- g(['same-attachment-glFramebufferTexture2D-GL_DEPTH_STENCIL_ATTACHMENT'],
- run_concurrent=True)
- g(['same-attachment-glFramebufferRenderbuffer-GL_DEPTH_STENCIL_ATTACHMENT'],
- run_concurrent=True)
+ g(['same-attachment-glFramebufferTexture2D-GL_DEPTH_STENCIL_ATTACHMENT'])
+ g(['same-attachment-glFramebufferRenderbuffer-GL_DEPTH_STENCIL_ATTACHMENT'])
g(['fdo28551'], run_concurrent=False)
- g(['fbo-alpha'], run_concurrent=True)
+ g(['fbo-alpha'])
g(['fbo-blit-stretch'], run_concurrent=False)
- g(['fbo-blit-scaled-linear'], run_concurrent=True)
- g(['fbo-attachments-blit-scaled-linear'], run_concurrent=True)
- g(['fbo-deriv'], run_concurrent=True)
- g(['fbo-luminance-alpha'], run_concurrent=True)
- g(['fbo-getframebufferattachmentparameter-01'], run_concurrent=True)
- g(['fbo-gl_pointcoord'], run_concurrent=True)
- g(['fbo-incomplete'], run_concurrent=True)
- g(['fbo-incomplete-invalid-texture'], run_concurrent=True)
- g(['fbo-incomplete-texture-01'], run_concurrent=True)
- g(['fbo-incomplete-texture-02'], run_concurrent=True)
- g(['fbo-incomplete-texture-03'], run_concurrent=True)
- g(['fbo-incomplete-texture-04'], run_concurrent=True)
- g(['fbo-mipmap-copypix'], run_concurrent=True)
+ g(['fbo-blit-scaled-linear'])
+ g(['fbo-attachments-blit-scaled-linear'])
+ g(['fbo-deriv'])
+ g(['fbo-luminance-alpha'])
+ g(['fbo-getframebufferattachmentparameter-01'])
+ g(['fbo-gl_pointcoord'])
+ g(['fbo-incomplete'])
+ g(['fbo-incomplete-invalid-texture'])
+ g(['fbo-incomplete-texture-01'])
+ g(['fbo-incomplete-texture-02'])
+ g(['fbo-incomplete-texture-03'])
+ g(['fbo-incomplete-texture-04'])
+ g(['fbo-mipmap-copypix'])
g(['fbo-viewport'], run_concurrent=False)
- g(['fbo-missing-attachment-blit', 'to'], 'FBO blit to missing attachment',
- run_concurrent=True)
+ g(['fbo-missing-attachment-blit', 'to'], 'FBO blit to missing attachment')
g(['fbo-missing-attachment-blit', 'from'],
- 'FBO blit from missing attachment', run_concurrent=True)
- g(['fbo-scissor-blit', 'fbo'], 'fbo-scissor-blit fbo', run_concurrent=True)
+ 'FBO blit from missing attachment')
+ g(['fbo-scissor-blit', 'fbo'], 'fbo-scissor-blit fbo')
g(['fbo-scissor-blit', 'window'], 'fbo-scissor-blit window',
run_concurrent=False)
- g(['fbo-tex-rgbx'], 'fbo-tex-rgbx', run_concurrent=True)
+ g(['fbo-tex-rgbx'], 'fbo-tex-rgbx')
g(['arb_framebuffer_object-negative-readpixels-no-rb'],
- 'negative-readpixels-no-rb', run_concurrent=True)
- g(['fbo-drawbuffers-none', 'glClear'], run_concurrent=True)
- g(['fbo-drawbuffers-none', 'glClearBuffer'], run_concurrent=True)
- g(['fbo-drawbuffers-none', 'gl_FragColor'], run_concurrent=True)
- g(['fbo-drawbuffers-none', 'gl_FragData'], run_concurrent=True)
- g(['fbo-drawbuffers-none', 'use_frag_out'], run_concurrent=True)
- g(['fbo-drawbuffers-none', 'glColorMaskIndexed'], run_concurrent=True)
- g(['fbo-drawbuffers-none', 'glBlendFunci'], run_concurrent=True)
- g(['fbo-drawbuffers-none', 'glDrawPixels'], run_concurrent=True)
- g(['fbo-drawbuffers-none', 'glBlitFramebuffer'], run_concurrent=True)
- g(['fbo-generatemipmap-cubemap'], run_concurrent=True)
- g(['fbo-generatemipmap-cubemap', 'RGB9_E5'], run_concurrent=True)
- g(['fbo-generatemipmap-cubemap', 'S3TC_DXT1'], run_concurrent=True)
- g(['fbo-generatemipmap-1d'], run_concurrent=True)
- g(['fbo-generatemipmap-1d', 'RGB9_E5'], run_concurrent=True)
- g(['fbo-generatemipmap-3d'], run_concurrent=True)
- g(['fbo-generatemipmap-3d', 'RGB9_E5'], run_concurrent=True)
+ 'negative-readpixels-no-rb')
+ g(['fbo-drawbuffers-none', 'glClear'])
+ g(['fbo-drawbuffers-none', 'glClearBuffer'])
+ g(['fbo-drawbuffers-none', 'gl_FragColor'])
+ g(['fbo-drawbuffers-none', 'gl_FragData'])
+ g(['fbo-drawbuffers-none', 'use_frag_out'])
+ g(['fbo-drawbuffers-none', 'glColorMaskIndexed'])
+ g(['fbo-drawbuffers-none', 'glBlendFunci'])
+ g(['fbo-drawbuffers-none', 'glDrawPixels'])
+ g(['fbo-drawbuffers-none', 'glBlitFramebuffer'])
+ g(['fbo-generatemipmap-cubemap'])
+ g(['fbo-generatemipmap-cubemap', 'RGB9_E5'])
+ g(['fbo-generatemipmap-cubemap', 'S3TC_DXT1'])
+ g(['fbo-generatemipmap-1d'])
+ g(['fbo-generatemipmap-1d', 'RGB9_E5'])
+ g(['fbo-generatemipmap-3d'])
+ g(['fbo-generatemipmap-3d', 'RGB9_E5'])
for format in ('rgba', 'depth', 'stencil'):
for test_mode in ('draw', 'read'):
g(['framebuffer-blit-levels', test_mode, format],
- 'framebuffer-blit-levels {} {}'.format(test_mode, format),
- run_concurrent=True)
+ 'framebuffer-blit-levels {} {}'.format(test_mode, format))
# Group ARB_framebuffer_sRGB
with profile.group_manager(
@@ -2086,10 +1938,9 @@ with profile.group_manager(
blit_type, framebuffer_srgb_setting],
'blit {} {} {} {}'.format(
backing_type, srgb_types, blit_type,
- framebuffer_srgb_setting),
- run_concurrent=True)
+ framebuffer_srgb_setting))
g(['framebuffer-srgb'], run_concurrent=False)
- g(['arb_framebuffer_srgb-clear'], run_concurrent=True)
+ g(['arb_framebuffer_srgb-clear'])
with profile.group_manager(
PiglitGLTest,
@@ -2109,7 +1960,7 @@ with profile.group_manager(
comp, str(cs), type_, sampler, address_mode]
testname = grouptools.join(func, '{}-{}-{}-{}-{}'.format(
stage, comp, cs, type_, sampler))
- g(cmd, testname, run_concurrent=True)
+ g(cmd, testname)
if func == 'textureGatherOffset':
# also add a constant offset version.
@@ -2118,7 +1969,7 @@ with profile.group_manager(
stage, comp, cs, type_, sampler))
cmd = ['textureGather', stage, 'offset',
comp, str(cs), type_, sampler, address_mode]
- g(cmd, testname, run_concurrent=True)
+ g(cmd, testname)
# test shadow samplers
samplers = ['2D', '2DArray', 'Cube', 'CubeArray', '2DRect']
@@ -2130,26 +1981,26 @@ with profile.group_manager(
'offsets' if func == 'textureGatherOffsets' else 'nonconst' if func == 'textureGatherOffset' else '',
sampler,
'clamp' if sampler == '2DRect' else 'repeat']
- g(cmd, testname, run_concurrent=True)
-
- g(['arb_gpu_shader5-minmax'], run_concurrent=True)
- g(['arb_gpu_shader5-invocation-id'], run_concurrent=True)
- g(['arb_gpu_shader5-invocations_count_too_large'], run_concurrent=True)
- g(['arb_gpu_shader5-xfb-streams'], run_concurrent=True)
- g(['arb_gpu_shader5-stream_value_too_large'], run_concurrent=True)
- g(['arb_gpu_shader5-emitstreamvertex_stream_too_large'], run_concurrent=True)
- g(['arb_gpu_shader5-tf-wrong-stream-value'], run_concurrent=True)
- g(['arb_gpu_shader5-xfb-streams-without-invocations'], run_concurrent=True)
- g(['arb_gpu_shader5-emitstreamvertex_nodraw'], run_concurrent=True)
- g(['arb_gpu_shader5-interpolateAtCentroid'], run_concurrent=True)
- g(['arb_gpu_shader5-interpolateAtCentroid-packing'], run_concurrent=True)
- g(['arb_gpu_shader5-interpolateAtCentroid-flat'], run_concurrent=True)
- g(['arb_gpu_shader5-interpolateAtCentroid-centroid'], run_concurrent=True)
- g(['arb_gpu_shader5-interpolateAtCentroid-noperspective'], run_concurrent=True)
- g(['arb_gpu_shader5-interpolateAtSample'], run_concurrent=True)
- g(['arb_gpu_shader5-interpolateAtSample-nonconst'], run_concurrent=True)
- g(['arb_gpu_shader5-interpolateAtOffset'], run_concurrent=True)
- g(['arb_gpu_shader5-interpolateAtOffset-nonconst'], run_concurrent=True)
+ g(cmd, testname)
+
+ g(['arb_gpu_shader5-minmax'])
+ g(['arb_gpu_shader5-invocation-id'])
+ g(['arb_gpu_shader5-invocations_count_too_large'])
+ g(['arb_gpu_shader5-xfb-streams'])
+ g(['arb_gpu_shader5-stream_value_too_large'])
+ g(['arb_gpu_shader5-emitstreamvertex_stream_too_large'])
+ g(['arb_gpu_shader5-tf-wrong-stream-value'])
+ g(['arb_gpu_shader5-xfb-streams-without-invocations'])
+ g(['arb_gpu_shader5-emitstreamvertex_nodraw'])
+ g(['arb_gpu_shader5-interpolateAtCentroid'])
+ g(['arb_gpu_shader5-interpolateAtCentroid-packing'])
+ g(['arb_gpu_shader5-interpolateAtCentroid-flat'])
+ g(['arb_gpu_shader5-interpolateAtCentroid-centroid'])
+ g(['arb_gpu_shader5-interpolateAtCentroid-noperspective'])
+ g(['arb_gpu_shader5-interpolateAtSample'])
+ g(['arb_gpu_shader5-interpolateAtSample-nonconst'])
+ g(['arb_gpu_shader5-interpolateAtOffset'])
+ g(['arb_gpu_shader5-interpolateAtOffset-nonconst'])
with profile.group_manager(
@@ -2165,54 +2016,54 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ARB_shader_subroutine')) as g:
- g(['arb_shader_subroutine-minmax'], run_concurrent=True)
+ g(['arb_shader_subroutine-minmax'])
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ARB_occlusion_query')) as g:
- g(['occlusion_query'], run_concurrent=True)
- g(['occlusion_query_lifetime'], run_concurrent=True)
- g(['occlusion_query_meta_fragments'], run_concurrent=True)
- g(['occlusion_query_meta_no_fragments'], run_concurrent=True)
- g(['occlusion_query_meta_save'], run_concurrent=True)
- g(['occlusion_query_order'], run_concurrent=True)
- g(['gen_delete_while_active'], run_concurrent=True)
+ g(['occlusion_query'])
+ g(['occlusion_query_lifetime'])
+ g(['occlusion_query_meta_fragments'])
+ g(['occlusion_query_meta_no_fragments'])
+ g(['occlusion_query_meta_save'])
+ g(['occlusion_query_order'])
+ g(['gen_delete_while_active'])
# Group ARB_separate_shader_objects
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ARB_separate_shader_objects')) as g:
g(['arb_separate_shader_object-ActiveShaderProgram-invalid-program'],
- 'ActiveShaderProgram with invalid program', run_concurrent=True)
+ 'ActiveShaderProgram with invalid program')
g(['arb_separate_shader_object-GetProgramPipelineiv'],
- 'GetProgramPipelineiv', run_concurrent=True)
+ 'GetProgramPipelineiv')
g(['arb_separate_shader_object-IsProgramPipeline'],
- 'IsProgramPipeline', run_concurrent=True)
+ 'IsProgramPipeline')
g(['arb_separate_shader_object-UseProgramStages-non-separable'],
- 'UseProgramStages - non-separable program', run_concurrent=True)
+ 'UseProgramStages - non-separable program')
g(['arb_separate_shader_object-ProgramUniform-coverage'],
- 'ProgramUniform coverage', run_concurrent=True)
+ 'ProgramUniform coverage')
g(['arb_separate_shader_object-rendezvous_by_location', '-fbo'],
'Rendezvous by location', run_concurrent=False)
g(['arb_separate_shader_object-ValidateProgramPipeline'],
- 'ValidateProgramPipeline', run_concurrent=True)
+ 'ValidateProgramPipeline')
g(['arb_separate_shader_object-400-combinations', '-fbo', '--by-location'],
'400 combinations by location', run_concurrent=False)
g(['arb_separate_shader_object-400-combinations', '-fbo'],
'400 combinations by name', run_concurrent=False)
g(['arb_separate_shader_object-active-sampler-conflict'],
- 'active sampler conflict', run_concurrent=True)
+ 'active sampler conflict')
# Group ARB_sampler_objects
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ARB_sampler_objects')) as g:
g(['arb_sampler_objects-sampler-objects'], 'sampler-objects',
- run_concurrent=True)
+ )
g(['arb_sampler_objects-sampler-incomplete'], 'sampler-incomplete',
- run_concurrent=True)
+ )
g(['arb_sampler_objects-srgb-decode'], 'GL_EXT_texture_sRGB_decode',
- run_concurrent=True)
+ )
g(['arb_sampler_objects-framebufferblit'], 'framebufferblit',
run_concurrent=False)
@@ -2245,8 +2096,7 @@ with profile.group_manager(
for num_samples in [0, 2, 4, 6, 8]:
g(['arb_sample_shading-builtin-gl-sample-mask-simple', str(num_samples)],
- 'builtin-gl-sample-mask-simple {}'.format(num_samples),
- run_concurrent=True)
+ 'builtin-gl-sample-mask-simple {}'.format(num_samples))
# Group ARB_debug_output
with profile.group_manager(
@@ -2258,24 +2108,19 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'KHR_debug')) as g:
- g(['khr_debug-object-label_gl'], 'object-label_gl', run_concurrent=True)
- g(['khr_debug-object-label_gles2'], 'object-label_gles2',
- run_concurrent=True)
- g(['khr_debug-object-label_gles3'], 'object-label_gles3',
- run_concurrent=True)
- g(['khr_debug-push-pop-group_gl'], 'push-pop-group_gl',
- run_concurrent=True)
- g(['khr_debug-push-pop-group_gles2'], 'push-pop-group_gles2',
- run_concurrent=True)
- g(['khr_debug-push-pop-group_gles3'], 'push-pop-group_gles3',
- run_concurrent=True)
+ g(['khr_debug-object-label_gl'], 'object-label_gl')
+ g(['khr_debug-object-label_gles2'], 'object-label_gles2')
+ g(['khr_debug-object-label_gles3'], 'object-label_gles3')
+ g(['khr_debug-push-pop-group_gl'], 'push-pop-group_gl')
+ g(['khr_debug-push-pop-group_gles2'], 'push-pop-group_gles2')
+ g(['khr_debug-push-pop-group_gles3'], 'push-pop-group_gles3')
# Group ARB_occlusion_query2
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ARB_occlusion_query2')) as g:
- g(['arb_occlusion_query2-api'], 'api', run_concurrent=True)
- g(['arb_occlusion_query2-render'], 'render', run_concurrent=True)
+ g(['arb_occlusion_query2-api'], 'api')
+ g(['arb_occlusion_query2-render'], 'render')
with profile.group_manager(
PiglitGLTest,
@@ -2287,9 +2132,9 @@ with profile.group_manager(
g(['pbo-teximage'], run_concurrent=False)
g(['pbo-teximage-tiling'], run_concurrent=False)
g(['pbo-teximage-tiling-2'], run_concurrent=False)
- g(['texsubimage', 'pbo'], run_concurrent=True)
- g(['texsubimage', 'array', 'pbo'], run_concurrent=True)
- g(['texsubimage', 'cube_map_array', 'pbo'], run_concurrent=True)
+ g(['texsubimage', 'pbo'])
+ g(['texsubimage', 'array', 'pbo'])
+ g(['texsubimage', 'cube_map_array', 'pbo'])
# Group ARB_provoking_vertex
with profile.group_manager(
@@ -2311,65 +2156,54 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ARB_shader_texture_lod', 'execution')) as g:
- g(['arb_shader_texture_lod-texgrad'], run_concurrent=True)
- g(['arb_shader_texture_lod-texgradcube'], run_concurrent=True)
- g(['tex-miplevel-selection', '*Lod', '1D'], run_concurrent=True)
- g(['tex-miplevel-selection', '*Lod', '2D'], run_concurrent=True)
- g(['tex-miplevel-selection', '*Lod', '3D'], run_concurrent=True)
- g(['tex-miplevel-selection', '*Lod', 'Cube'], run_concurrent=True)
- g(['tex-miplevel-selection', '*Lod', '1DShadow'], run_concurrent=True)
- g(['tex-miplevel-selection', '*Lod', '2DShadow'], run_concurrent=True)
- g(['tex-miplevel-selection', '*ProjLod', '1D'], run_concurrent=True)
- g(['tex-miplevel-selection', '*ProjLod', '1D_ProjVec4'],
- run_concurrent=True)
- g(['tex-miplevel-selection', '*ProjLod', '2D'], run_concurrent=True)
- g(['tex-miplevel-selection', '*ProjLod', '2D_ProjVec4'],
- run_concurrent=True)
- g(['tex-miplevel-selection', '*ProjLod', '3D'], run_concurrent=True)
- g(['tex-miplevel-selection', '*ProjLod', '1DShadow'], run_concurrent=True)
- g(['tex-miplevel-selection', '*ProjLod', '2DShadow'], run_concurrent=True)
- g(['tex-miplevel-selection', '*GradARB', '1D'], run_concurrent=True)
- g(['tex-miplevel-selection', '*GradARB', '2D'], run_concurrent=True)
- g(['tex-miplevel-selection', '*GradARB', '3D'], run_concurrent=True)
- g(['tex-miplevel-selection', '*GradARB', 'Cube'], run_concurrent=True)
- g(['tex-miplevel-selection', '*GradARB', '1DShadow'], run_concurrent=True)
- g(['tex-miplevel-selection', '*GradARB', '2DShadow'], run_concurrent=True)
- g(['tex-miplevel-selection', '*GradARB', '2DRect'], run_concurrent=True)
- g(['tex-miplevel-selection', '*GradARB', '2DRectShadow'],
- run_concurrent=True)
- g(['tex-miplevel-selection', '*ProjGradARB', '1D'], run_concurrent=True)
- g(['tex-miplevel-selection', '*ProjGradARB', '1D_ProjVec4'],
- run_concurrent=True)
- g(['tex-miplevel-selection', '*ProjGradARB', '2D'], run_concurrent=True)
- g(['tex-miplevel-selection', '*ProjGradARB', '2D_ProjVec4'],
- run_concurrent=True)
- g(['tex-miplevel-selection', '*ProjGradARB', '3D'], run_concurrent=True)
- g(['tex-miplevel-selection', '*ProjGradARB', '1DShadow'],
- run_concurrent=True)
- g(['tex-miplevel-selection', '*ProjGradARB', '2DShadow'],
- run_concurrent=True)
- g(['tex-miplevel-selection', '*ProjGradARB', '2DRect'], run_concurrent=True)
- g(['tex-miplevel-selection', '*ProjGradARB', '2DRect_ProjVec4'],
- run_concurrent=True)
- g(['tex-miplevel-selection', '*ProjGradARB', '2DRectShadow'],
- run_concurrent=True)
+ g(['arb_shader_texture_lod-texgrad'])
+ g(['arb_shader_texture_lod-texgradcube'])
+ g(['tex-miplevel-selection', '*Lod', '1D'])
+ g(['tex-miplevel-selection', '*Lod', '2D'])
+ g(['tex-miplevel-selection', '*Lod', '3D'])
+ g(['tex-miplevel-selection', '*Lod', 'Cube'])
+ g(['tex-miplevel-selection', '*Lod', '1DShadow'])
+ g(['tex-miplevel-selection', '*Lod', '2DShadow'])
+ g(['tex-miplevel-selection', '*ProjLod', '1D'])
+ g(['tex-miplevel-selection', '*ProjLod', '1D_ProjVec4'])
+ g(['tex-miplevel-selection', '*ProjLod', '2D'])
+ g(['tex-miplevel-selection', '*ProjLod', '2D_ProjVec4'])
+ g(['tex-miplevel-selection', '*ProjLod', '3D'])
+ g(['tex-miplevel-selection', '*ProjLod', '1DShadow'])
+ g(['tex-miplevel-selection', '*ProjLod', '2DShadow'])
+ g(['tex-miplevel-selection', '*GradARB', '1D'])
+ g(['tex-miplevel-selection', '*GradARB', '2D'])
+ g(['tex-miplevel-selection', '*GradARB', '3D'])
+ g(['tex-miplevel-selection', '*GradARB', 'Cube'])
+ g(['tex-miplevel-selection', '*GradARB', '1DShadow'])
+ g(['tex-miplevel-selection', '*GradARB', '2DShadow'])
+ g(['tex-miplevel-selection', '*GradARB', '2DRect'])
+ g(['tex-miplevel-selection', '*GradARB', '2DRectShadow'])
+ g(['tex-miplevel-selection', '*ProjGradARB', '1D'])
+ g(['tex-miplevel-selection', '*ProjGradARB', '1D_ProjVec4'])
+ g(['tex-miplevel-selection', '*ProjGradARB', '2D'])
+ g(['tex-miplevel-selection', '*ProjGradARB', '2D_ProjVec4'])
+ g(['tex-miplevel-selection', '*ProjGradARB', '3D'])
+ g(['tex-miplevel-selection', '*ProjGradARB', '1DShadow'])
+ g(['tex-miplevel-selection', '*ProjGradARB', '2DShadow'])
+ g(['tex-miplevel-selection', '*ProjGradARB', '2DRect'])
+ g(['tex-miplevel-selection', '*ProjGradARB', '2DRect_ProjVec4'])
+ g(['tex-miplevel-selection', '*ProjGradARB', '2DRectShadow'])
# Group ARB_shader_objects
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ARB_shader_objects')) as g:
- g(['arb_shader_objects-getuniform'], 'getuniform', run_concurrent=True)
+ g(['arb_shader_objects-getuniform'], 'getuniform')
g(['arb_shader_objects-bindattriblocation-scratch-name'],
- 'bindattriblocation-scratch-name', run_concurrent=True)
+ 'bindattriblocation-scratch-name')
g(['arb_shader_objects-getactiveuniform-beginend'],
- 'getactiveuniform-beginend', run_concurrent=True)
+ 'getactiveuniform-beginend')
g(['arb_shader_objects-getuniformlocation-array-of-struct-of-array'],
- 'getuniformlocation-array-of-struct-of-array', run_concurrent=True)
- g(['arb_shader_objects-clear-with-deleted'],
- 'clear-with-deleted', run_concurrent=True)
- g(['arb_shader_objects-delete-repeat'], 'delete-repeat',
- run_concurrent=True)
+ 'getuniformlocation-array-of-struct-of-array')
+ g(['arb_shader_objects-clear-with-deleted'], 'clear-with-deleted')
+ g(['arb_shader_objects-delete-repeat'], 'delete-repeat')
with profile.group_manager(
PiglitGLTest,
@@ -2377,11 +2211,10 @@ with profile.group_manager(
g(['built-in-constants',
os.path.join(TESTS_DIR, 'spec', 'arb_shading_language_420pack',
'minimum-maximums.txt')],
- 'built-in constants', run_concurrent=True)
+ 'built-in constants')
g(['arb_shading_language_420pack-multiple-layout-qualifiers'],
- 'multiple layout qualifiers', run_concurrent=True)
- g(['arb_shading_language_420pack-binding-layout'], 'binding layout',
- run_concurrent=True)
+ 'multiple layout qualifiers')
+ g(['arb_shading_language_420pack-binding-layout'], 'binding layout')
# Group ARB_explicit_attrib_location
with profile.group_manager(
@@ -2409,61 +2242,48 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ARB_texture_buffer_object')) as g:
- g(['arb_texture_buffer_object-data-sync'], 'data-sync',
- run_concurrent=True)
- g(['arb_texture_buffer_object-dlist'], 'dlist', run_concurrent=True)
+ g(['arb_texture_buffer_object-data-sync'], 'data-sync')
+ g(['arb_texture_buffer_object-dlist'], 'dlist')
g(['arb_texture_buffer_object-formats', 'fs', 'core'],
- 'formats (FS, 3.1 core)', run_concurrent=True)
+ 'formats (FS, 3.1 core)')
g(['arb_texture_buffer_object-formats', 'vs', 'core'],
- 'formats (VS, 3.1 core)', run_concurrent=True)
- g(['arb_texture_buffer_object-formats', 'fs', 'arb'],
- 'formats (FS, ARB)', run_concurrent=True)
- g(['arb_texture_buffer_object-formats', 'vs', 'arb'],
- 'formats (VS, ARB)', run_concurrent=True)
- g(['arb_texture_buffer_object-get'], 'get', run_concurrent=True)
+ 'formats (VS, 3.1 core)')
+ g(['arb_texture_buffer_object-formats', 'fs', 'arb'], 'formats (FS, ARB)')
+ g(['arb_texture_buffer_object-formats', 'vs', 'arb'], 'formats (VS, ARB)')
+ g(['arb_texture_buffer_object-get'], 'get')
g(['arb_texture_buffer_object-fetch-outside-bounds'],
- 'fetch-outside-bounds', run_concurrent=True)
- g(['arb_texture_buffer_object-minmax'], 'minmax', run_concurrent=True)
- g(['arb_texture_buffer_object-negative-bad-bo'], 'negative-bad-bo',
- run_concurrent=True)
- g(['arb_texture_buffer_object-negative-bad-format'], 'negative-bad-format',
- run_concurrent=True)
- g(['arb_texture_buffer_object-negative-bad-target'], 'negative-bad-target',
- run_concurrent=True)
+ 'fetch-outside-bounds')
+ g(['arb_texture_buffer_object-minmax'], 'minmax')
+ g(['arb_texture_buffer_object-negative-bad-bo'], 'negative-bad-bo')
+ g(['arb_texture_buffer_object-negative-bad-format'], 'negative-bad-format')
+ g(['arb_texture_buffer_object-negative-bad-target'], 'negative-bad-target')
g(['arb_texture_buffer_object-negative-unsupported'],
- 'negative-unsupported', run_concurrent=True)
- g(['arb_texture_buffer_object-subdata-sync'], 'subdata-sync',
- run_concurrent=True)
- g(['arb_texture_buffer_object-unused-name'], 'unused-name',
- run_concurrent=True)
+ 'negative-unsupported')
+ g(['arb_texture_buffer_object-subdata-sync'], 'subdata-sync')
+ g(['arb_texture_buffer_object-unused-name'], 'unused-name')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ARB_texture_buffer_range')) as g:
- g(['arb_texture_buffer_range-dlist'], 'dlist', run_concurrent=True)
- g(['arb_texture_buffer_range-errors'], 'errors', run_concurrent=True)
- g(['arb_texture_buffer_range-ranges'], 'ranges', run_concurrent=True)
- g(['arb_texture_buffer_range-ranges-2'], 'ranges-2', run_concurrent=True)
+ g(['arb_texture_buffer_range-dlist'], 'dlist')
+ g(['arb_texture_buffer_range-errors'], 'errors')
+ g(['arb_texture_buffer_range-ranges'], 'ranges')
+ g(['arb_texture_buffer_range-ranges-2'], 'ranges-2')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ARB_texture_rectangle')) as g:
- g(['1-1-linear-texture'], run_concurrent=True)
+ g(['1-1-linear-texture'])
g(['texrect-many'], run_concurrent=False)
- g(['getteximage-targets', 'RECT'], run_concurrent=True)
+ g(['getteximage-targets', 'RECT'])
g(['texrect_simple_arb_texrect'], run_concurrent=False)
g(['arb_texrect-texture-base-level-error'], run_concurrent=False)
g(['fbo-blit', 'rect'], run_concurrent=False)
- g(['tex-miplevel-selection', 'GL2:texture()', '2DRect'],
- run_concurrent=True)
- g(['tex-miplevel-selection', 'GL2:texture()', '2DRectShadow'],
- run_concurrent=True)
- g(['tex-miplevel-selection', 'GL2:textureProj', '2DRect'],
- run_concurrent=True)
- g(['tex-miplevel-selection', 'GL2:textureProj', '2DRect_ProjVec4'],
- run_concurrent=True)
- g(['tex-miplevel-selection', 'GL2:textureProj', '2DRectShadow'],
- run_concurrent=True)
+ g(['tex-miplevel-selection', 'GL2:texture()', '2DRect'])
+ g(['tex-miplevel-selection', 'GL2:texture()', '2DRectShadow'])
+ g(['tex-miplevel-selection', 'GL2:textureProj', '2DRect'])
+ g(['tex-miplevel-selection', 'GL2:textureProj', '2DRect_ProjVec4'])
+ g(['tex-miplevel-selection', 'GL2:textureProj', '2DRectShadow'])
add_msaa_visual_plain_tests(g, ['copyteximage', 'RECT'],
run_concurrent=False)
add_texwrap_target_tests(g, 'RECT')
@@ -2476,63 +2296,47 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ARB_texture_storage_multisample')) as g:
- g(['arb_texture_storage_multisample-tex-storage'], 'tex-storage',
- run_concurrent=True)
- g(['arb_texture_storage_multisample-tex-param'], 'tex-param',
- run_concurrent=True)
+ g(['arb_texture_storage_multisample-tex-storage'], 'tex-storage')
+ g(['arb_texture_storage_multisample-tex-param'], 'tex-param')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ARB_texture_view')) as g:
- g(['arb_texture_view-cubemap-view'], 'cubemap-view', run_concurrent=True)
- g(['arb_texture_view-texture-immutable-levels'], 'immutable_levels',
- run_concurrent=True)
- g(['arb_texture_view-max-level'], 'max-level', run_concurrent=True)
- g(['arb_texture_view-params'], 'params', run_concurrent=True)
- g(['arb_texture_view-formats'], 'formats', run_concurrent=True)
- g(['arb_texture_view-targets'], 'targets', run_concurrent=True)
- g(['arb_texture_view-queries'], 'queries', run_concurrent=True)
- g(['arb_texture_view-rendering-target'], 'rendering-target',
- run_concurrent=True)
- g(['arb_texture_view-rendering-levels'], 'rendering-levels',
- run_concurrent=True)
- g(['arb_texture_view-rendering-layers'], 'rendering-layers',
- run_concurrent=True)
- g(['arb_texture_view-rendering-formats'], 'rendering-formats',
- run_concurrent=True)
- g(['arb_texture_view-lifetime-format'], 'lifetime-format',
- run_concurrent=True)
- g(['arb_texture_view-getteximage-srgb'], 'getteximage-srgb',
- run_concurrent=True)
- g(['arb_texture_view-texsubimage-levels'], 'texsubimage-levels',
- run_concurrent=True)
- g(['arb_texture_view-texsubimage-layers'], 'texsubimage-layers',
- run_concurrent=True)
- g(['arb_texture_view-clear-into-view-2d'], 'clear-into-view-2d',
- run_concurrent=True)
+ g(['arb_texture_view-cubemap-view'], 'cubemap-view')
+ g(['arb_texture_view-texture-immutable-levels'], 'immutable_levels')
+ g(['arb_texture_view-max-level'], 'max-level')
+ g(['arb_texture_view-params'], 'params')
+ g(['arb_texture_view-formats'], 'formats')
+ g(['arb_texture_view-targets'], 'targets')
+ g(['arb_texture_view-queries'], 'queries')
+ g(['arb_texture_view-rendering-target'], 'rendering-target')
+ g(['arb_texture_view-rendering-levels'], 'rendering-levels')
+ g(['arb_texture_view-rendering-layers'], 'rendering-layers')
+ g(['arb_texture_view-rendering-formats'], 'rendering-formats')
+ g(['arb_texture_view-lifetime-format'], 'lifetime-format')
+ g(['arb_texture_view-getteximage-srgb'], 'getteximage-srgb')
+ g(['arb_texture_view-texsubimage-levels'], 'texsubimage-levels')
+ g(['arb_texture_view-texsubimage-layers'], 'texsubimage-layers')
+ g(['arb_texture_view-clear-into-view-2d'], 'clear-into-view-2d')
g(['arb_texture_view-clear-into-view-2d-array'],
- 'clear-into-view-2d-array', run_concurrent=True)
- g(['arb_texture_view-clear-into-view-layered'], 'clear-into-view-layered',
- run_concurrent=True)
- g(['arb_texture_view-copytexsubimage-layers'], 'copytexsubimage-layers',
- run_concurrent=True)
+ 'clear-into-view-2d-array')
+ g(['arb_texture_view-clear-into-view-layered'], 'clear-into-view-layered')
+ g(['arb_texture_view-copytexsubimage-layers'], 'copytexsubimage-layers')
g(['arb_texture_view-sampling-2d-array-as-cubemap'],
- 'sampling-2d-array-as-cubemap', run_concurrent=True)
+ 'sampling-2d-array-as-cubemap')
g(['arb_texture_view-sampling-2d-array-as-cubemap-array'],
- 'sampling-2d-array-as-cubemap-array', run_concurrent=True)
+ 'sampling-2d-array-as-cubemap-array')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', '3DFX_texture_compression_FXT1')) as g:
- g(['compressedteximage', 'GL_COMPRESSED_RGB_FXT1_3DFX'],
- run_concurrent=True)
- g(['compressedteximage', 'GL_COMPRESSED_RGBA_FXT1_3DFX'],
- run_concurrent=True)
+ g(['compressedteximage', 'GL_COMPRESSED_RGB_FXT1_3DFX'])
+ g(['compressedteximage', 'GL_COMPRESSED_RGBA_FXT1_3DFX'])
g(['fxt1-teximage'], run_concurrent=False)
g(['arb_texture_compression-invalid-formats', 'fxt1'],
- 'invalid formats', run_concurrent=True)
+ 'invalid formats')
g(['fbo-generatemipmap-formats', 'GL_3DFX_texture_compression_FXT1'],
- 'fbo-generatemipmap-formats', run_concurrent=True)
+ 'fbo-generatemipmap-formats')
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'arb_color_buffer_float')) as g:
@@ -2544,7 +2348,7 @@ with profile.group_manager(
'-{}'.format(p1) if p1 else '',
'-{}'.format(p2) if p2 else '')
cmd = ['arb_color_buffer_float-{}'.format(name), format, p1, p2]
- g([c for c in cmd if c is not None], testname, run_concurrent=True)
+ g([c for c in cmd if c is not None], testname)
f('mrt', 'mixed')
@@ -2604,7 +2408,7 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'arb_depth_buffer_float')) as g:
g(['fbo-clear-formats', 'GL_ARB_depth_buffer_float', 'stencil'],
- 'fbo-clear-formats stencil', run_concurrent=True)
+ 'fbo-clear-formats stencil')
add_depthstencil_render_miplevels_tests(
g,
['d=z32f_s8', 'd=z32f', 'd=z32f_s8_s=z24_s8', 'd=z32f_s=z24_s8',
@@ -2626,28 +2430,27 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'arb_texture_compression')) as g:
g(['arb_texture_compression-internal-format-query'],
- 'GL_TEXTURE_INTERNAL_FORMAT query', run_concurrent=True)
+ 'GL_TEXTURE_INTERNAL_FORMAT query')
g(['arb_texture_compression-invalid-formats', 'unknown'],
- 'unknown formats', run_concurrent=True)
+ 'unknown formats')
g(['fbo-generatemipmap-formats', 'GL_ARB_texture_compression'],
- 'fbo-generatemipmap-formats', run_concurrent=True)
+ 'fbo-generatemipmap-formats')
add_texwrap_format_tests(g, 'GL_ARB_texture_compression')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_texture_compression_bptc')) as g:
- g(['arb_texture_compression-invalid-formats', 'bptc'], 'invalid formats',
- run_concurrent=True)
- g(['bptc-modes'], run_concurrent=True)
- g(['bptc-float-modes'], run_concurrent=True)
- g(['compressedteximage', 'GL_COMPRESSED_RGBA_BPTC_UNORM'], run_concurrent=True)
- g(['compressedteximage', 'GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM'], run_concurrent=True)
- g(['compressedteximage', 'GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT'], run_concurrent=True)
- g(['compressedteximage', 'GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT'], run_concurrent=True)
+ g(['arb_texture_compression-invalid-formats', 'bptc'], 'invalid formats')
+ g(['bptc-modes'])
+ g(['bptc-float-modes'])
+ g(['compressedteximage', 'GL_COMPRESSED_RGBA_BPTC_UNORM'])
+ g(['compressedteximage', 'GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM'])
+ g(['compressedteximage', 'GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT'])
+ g(['compressedteximage', 'GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT'])
g(['fbo-generatemipmap-formats', 'GL_ARB_texture_compression_bptc-unorm'],
- 'fbo-generatemipmap-formats', run_concurrent=True)
+ 'fbo-generatemipmap-formats')
g(['fbo-generatemipmap-formats', 'GL_ARB_texture_compression_bptc-float'],
- 'fbo-generatemipmap-formats', run_concurrent=True)
+ 'fbo-generatemipmap-formats')
add_texwrap_format_tests(g, 'GL_ARB_texture_compression_bptc')
with profile.group_manager(
@@ -2661,8 +2464,7 @@ with profile.group_manager(
grouptools.join('spec', 'apple_vertex_array_object')) as g:
g(['vao-01'], run_concurrent=False)
g(['vao-02'], run_concurrent=False)
- g(['arb_vertex_array-isvertexarray', 'apple'], 'isvertexarray',
- run_concurrent=True)
+ g(['arb_vertex_array-isvertexarray', 'apple'], 'isvertexarray')
with profile.group_manager(
PiglitGLTest,
@@ -2673,8 +2475,8 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_vertex_array_object')) as g:
- g(['vao-element-array-buffer'], run_concurrent=True)
- g(['arb_vertex_array-isvertexarray'], 'isvertexarray', run_concurrent=True)
+ g(['vao-element-array-buffer'])
+ g(['arb_vertex_array-isvertexarray'], 'isvertexarray')
with profile.group_manager(
PiglitGLTest,
@@ -2686,20 +2488,18 @@ with profile.group_manager(
g(['fdo14575'], run_concurrent=False)
g(['fdo22540'], run_concurrent=False)
g(['fdo31934'], run_concurrent=False)
- g(['arb_vertex_buffer_object-ib-data-sync'], 'ib-data-sync',
- run_concurrent=True)
- g(['arb_vertex_buffer_object-ib-subdata-sync'], 'ib-subdata-sync',
- run_concurrent=True)
+ g(['arb_vertex_buffer_object-ib-data-sync'], 'ib-data-sync')
+ g(['arb_vertex_buffer_object-ib-subdata-sync'], 'ib-subdata-sync')
g(['pos-array'], run_concurrent=False)
g(['vbo-bufferdata'], run_concurrent=False)
g(['vbo-map-remap'], run_concurrent=False)
- g(['vbo-map-unsync'], run_concurrent=True)
+ g(['vbo-map-unsync'])
g(['arb_vertex_buffer_object-vbo-subdata-many', 'drawarrays'],
- 'vbo-subdata-many drawarrays', run_concurrent=True)
+ 'vbo-subdata-many drawarrays')
g(['arb_vertex_buffer_object-vbo-subdata-many', 'drawelements'],
- 'vbo-subdata-many drawelements', run_concurrent=True)
+ 'vbo-subdata-many drawelements')
g(['arb_vertex_buffer_object-vbo-subdata-many', 'drawrangeelements'],
- 'vbo-subdata-many drawrangeelements', run_concurrent=True)
+ 'vbo-subdata-many drawrangeelements')
g(['vbo-subdata-sync'], run_concurrent=False)
g(['vbo-subdata-zero'], run_concurrent=False)
@@ -2710,13 +2510,11 @@ with profile.group_manager(
run_concurrent=False)
g(['arb_vertex_program-getlocal4d-with-error'], 'getlocal4d-with-error',
run_concurrent=False)
- g(['arb_vertex_program-getlocal4f-max'], 'getlocal4f-max',
- run_concurrent=True)
- g(['arb_vertex_program-getlocal4-errors'], 'getlocal4-errors',
- run_concurrent=True)
+ g(['arb_vertex_program-getlocal4f-max'], 'getlocal4f-max')
+ g(['arb_vertex_program-getlocal4-errors'], 'getlocal4-errors')
g(['clip-plane-transformation', 'arb'],
- 'clip-plane-transformation arb', run_concurrent=True)
- g(['arb_vertex_program-minmax'], 'minmax', run_concurrent=True)
+ 'clip-plane-transformation arb')
+ g(['arb_vertex_program-minmax'], 'minmax')
g(['fdo24066'], run_concurrent=False)
g(['vp-address-01'], run_concurrent=False)
g(['vp-address-02'], run_concurrent=False)
@@ -2753,24 +2551,17 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_viewport_array')) as g:
- g(['arb_viewport_array-viewport-indices'], 'viewport-indices',
- run_concurrent=True)
- g(['arb_viewport_array-depthrange-indices'], 'depthrange-indices',
- run_concurrent=True)
- g(['arb_viewport_array-scissor-check'], 'scissor-check',
- run_concurrent=True)
- g(['arb_viewport_array-scissor-indices'], 'scissor-indices',
- run_concurrent=True)
- g(['arb_viewport_array-bounds'], 'bounds', run_concurrent=True)
- g(['arb_viewport_array-queries'], 'queries', run_concurrent=True)
- g(['arb_viewport_array-minmax'], 'minmax', run_concurrent=True)
- g(['arb_viewport_array-render-viewport'], 'render-viewport',
- run_concurrent=True)
- g(['arb_viewport_array-render-depthrange'], 'render-depthrange',
- run_concurrent=True)
- g(['arb_viewport_array-render-scissor'], 'render-scissor',
- run_concurrent=True)
- g(['arb_viewport_array-clear'], 'clear', run_concurrent=True)
+ g(['arb_viewport_array-viewport-indices'], 'viewport-indices')
+ g(['arb_viewport_array-depthrange-indices'], 'depthrange-indices')
+ g(['arb_viewport_array-scissor-check'], 'scissor-check')
+ g(['arb_viewport_array-scissor-indices'], 'scissor-indices')
+ g(['arb_viewport_array-bounds'], 'bounds')
+ g(['arb_viewport_array-queries'], 'queries')
+ g(['arb_viewport_array-minmax'], 'minmax')
+ g(['arb_viewport_array-render-viewport'], 'render-viewport')
+ g(['arb_viewport_array-render-depthrange'], 'render-depthrange')
+ g(['arb_viewport_array-render-scissor'], 'render-scissor')
+ g(['arb_viewport_array-clear'], 'clear')
with profile.group_manager(
PiglitGLTest,
@@ -2797,7 +2588,7 @@ with profile.group_manager(
g(['fbo-blit'], run_concurrent=False)
g(['fbo-copypix'], run_concurrent=False)
g(['fbo-readdrawpix'], run_concurrent=False)
- g(['fbo-srgb-blit'], run_concurrent=True)
+ g(['fbo-srgb-blit'])
g(['fbo-sys-blit'], run_concurrent=False)
g(['fbo-sys-sub-blit'], run_concurrent=False)
@@ -2805,57 +2596,53 @@ with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ext_framebuffer_multisample_blit_scaled')) as g:
g(['ext_framebuffer_multisample_blit_scaled-negative-blit-scaled'],
- 'negative-blit-scaled', run_concurrent=True)
+ 'negative-blit-scaled')
for num_samples in MSAA_SAMPLE_COUNTS:
g(['ext_framebuffer_multisample_blit_scaled-blit-scaled', str(num_samples)],
- 'blit-scaled samples={}'.format(num_samples),
- run_concurrent=True)
+ 'blit-scaled samples={}'.format(num_samples))
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ext_framebuffer_multisample')) as g:
g(['ext_framebuffer_multisample-blit-mismatched-samples'],
- 'blit-mismatched-samples', run_concurrent=True)
+ 'blit-mismatched-samples')
g(['ext_framebuffer_multisample-blit-mismatched-sizes'],
- 'blit-mismatched-sizes', run_concurrent=True)
+ 'blit-mismatched-sizes')
g(['ext_framebuffer_multisample-blit-mismatched-formats'],
- 'blit-mismatched-formats', run_concurrent=True)
- g(['ext_framebuffer_multisample-dlist'], 'dlist', run_concurrent=True)
- g(['ext_framebuffer_multisample-enable-flag'], 'enable-flag',
- run_concurrent=True)
- g(['ext_framebuffer_multisample-minmax'], 'minmax', run_concurrent=True)
+ 'blit-mismatched-formats')
+ g(['ext_framebuffer_multisample-dlist'], 'dlist')
+ g(['ext_framebuffer_multisample-enable-flag'], 'enable-flag')
+ g(['ext_framebuffer_multisample-minmax'], 'minmax')
g(['ext_framebuffer_multisample-negative-copypixels'],
- 'negative-copypixels', run_concurrent=True)
+ 'negative-copypixels')
g(['ext_framebuffer_multisample-negative-copyteximage'],
- 'negative-copyteximage', run_concurrent=True)
+ 'negative-copyteximage')
g(['ext_framebuffer_multisample-negative-max-samples'],
- 'negative-max-samples', run_concurrent=True)
+ 'negative-max-samples')
g(['ext_framebuffer_multisample-negative-mismatched-samples'],
- 'negative-mismatched-samples', run_concurrent=True)
+ 'negative-mismatched-samples')
g(['ext_framebuffer_multisample-negative-readpixels'],
- 'negative-readpixels', run_concurrent=True)
+ 'negative-readpixels')
g(['ext_framebuffer_multisample-renderbufferstorage-samples'],
- 'renderbufferstorage-samples', run_concurrent=True)
+ 'renderbufferstorage-samples')
g(['ext_framebuffer_multisample-renderbuffer-samples'],
- 'renderbuffer-samples', run_concurrent=True)
- g(['ext_framebuffer_multisample-samples'], 'samples', run_concurrent=True)
- g(['ext_framebuffer_multisample-alpha-blending'], 'alpha-blending',
- run_concurrent=True)
+ 'renderbuffer-samples')
+ g(['ext_framebuffer_multisample-samples'], 'samples')
+ g(['ext_framebuffer_multisample-alpha-blending'], 'alpha-blending')
g(['ext_framebuffer_multisample-alpha-blending', 'slow_cc'],
- 'alpha-blending slow_cc', run_concurrent=True)
+ 'alpha-blending slow_cc')
for num_samples in MSAA_SAMPLE_COUNTS:
if num_samples % 2 != 0:
continue
g(['ext_framebuffer_multisample-alpha-blending-after-rendering',
str(num_samples)],
- 'alpha-blending-after-rendering {}'.format(num_samples),
- run_concurrent=True)
+ 'alpha-blending-after-rendering {}'.format(num_samples))
for num_samples in ('all_samples', ) + MSAA_SAMPLE_COUNTS:
g(['ext_framebuffer_multisample-formats', str(num_samples)],
- 'formats {}'.format(num_samples), run_concurrent=True)
+ 'formats {}'.format(num_samples))
for test_type in ('color', 'srgb', 'stencil_draw', 'stencil_resolve',
'depth_draw', 'depth_resolve'):
@@ -2865,8 +2652,8 @@ with profile.group_manager(
for options in power_set(sensible_options):
g(['ext_framebuffer_multisample-accuracy', str(num_samples),
test_type] + options,
- ' '.join(['accuracy', str(num_samples), test_type] + options),
- run_concurrent=True)
+ ' '.join(['accuracy', str(num_samples), test_type] +
+ options))
# Note: the interpolation tests also check for sensible behaviour with
# non-multisampled framebuffers, so go ahead and test them with
@@ -2874,8 +2661,7 @@ with profile.group_manager(
for num_samples in (0,) + MSAA_SAMPLE_COUNTS:
g(['ext_framebuffer_multisample-blit-multiple-render-targets',
str(num_samples)],
- 'blit-multiple-render-targets {}'.format(num_samples),
- run_concurrent=True)
+ 'blit-multiple-render-targets {}'.format(num_samples))
for test_type in ('non-centroid-disabled', 'centroid-disabled',
'centroid-edges', 'non-centroid-deriv',
@@ -2883,8 +2669,7 @@ with profile.group_manager(
'centroid-deriv-disabled'):
g(['ext_framebuffer_multisample-interpolation', str(num_samples),
test_type],
- 'interpolation {} {}'.format(num_samples, test_type),
- run_concurrent=True)
+ 'interpolation {} {}'.format(num_samples, test_type))
for num_samples in MSAA_SAMPLE_COUNTS:
g(['ext_framebuffer_multisample-turn-on-off', str(num_samples)],
@@ -2900,33 +2685,28 @@ with profile.group_manager(
g(['ext_framebuffer_multisample-upsample', str(num_samples),
buffer_type] + options,
'upsample {} {}'.format(
- num_samples, ' '.join([buffer_type] + options)),
- run_concurrent=True)
+ num_samples, ' '.join([buffer_type] + options)))
g(['ext_framebuffer_multisample-multisample-blit',
str(num_samples), buffer_type] + options,
'multisample-blit {}'.format(
- ' '.join([str(num_samples), buffer_type] + options)),
- run_concurrent=True)
+ ' '.join([str(num_samples), buffer_type] + options)))
for blit_type in ('msaa', 'upsample', 'downsample'):
g(['ext_framebuffer_multisample-unaligned-blit',
str(num_samples), buffer_type, blit_type],
'unaligned-blit {} {} {}'.format(
- num_samples, buffer_type, blit_type),
- run_concurrent=True)
+ num_samples, buffer_type, blit_type))
for test_mode in ('inverted', 'non-inverted'):
g(['ext_framebuffer_multisample-sample-coverage', str(num_samples),
test_mode],
- 'sample-coverage {} {}'.format(num_samples, test_mode),
- run_concurrent=True)
+ 'sample-coverage {} {}'.format(num_samples, test_mode))
for buffer_type in ('color', 'depth'):
g(['ext_framebuffer_multisample-sample-alpha-to-coverage',
str(num_samples), buffer_type],
'sample-alpha-to-coverage {} {}'.format(
- num_samples, buffer_type),
- run_concurrent=True)
+ num_samples, buffer_type))
for test in ['line-smooth', 'point-smooth', 'polygon-smooth',
'sample-alpha-to-one',
@@ -2943,81 +2723,77 @@ with profile.group_manager(
'alpha-to-one-single-sample-buffer',
'bitmap', 'polygon-stipple']:
g(['ext_framebuffer_multisample-{}'.format(test), str(num_samples)],
- '{} {}'.format(test, num_samples), run_concurrent=True)
+ '{} {}'.format(test, num_samples))
for blit_type in ('msaa', 'upsample', 'downsample', 'normal'):
g(['ext_framebuffer_multisample-clip-and-scissor-blit',
str(num_samples), blit_type],
- 'clip-and-scissor-blit {} {}'.format(str(num_samples), blit_type),
- run_concurrent=True)
+ 'clip-and-scissor-blit {} {}'.format(str(num_samples), blit_type))
for flip_direction in ('x', 'y'):
g(['ext_framebuffer_multisample-blit-flipped', str(num_samples),
flip_direction],
- 'blit-flipped {} {}'.format(str(num_samples), flip_direction),
- run_concurrent=True)
+ 'blit-flipped {} {}'.format(str(num_samples), flip_direction))
for buffer_type in ('color', 'depth', 'stencil'):
g(['ext_framebuffer_multisample-clear', str(num_samples),
buffer_type],
- 'clear {} {}'.format(str(num_samples), buffer_type),
- run_concurrent=True)
+ 'clear {} {}'.format(str(num_samples), buffer_type))
for test_type in ('depth', 'depth-computed', 'stencil'):
for buffer_config in ('combined', 'separate', 'single'):
g(['ext_framebuffer_multisample-no-color', str(num_samples),
test_type, buffer_config],
'no-color {} {} {}'.format(
- num_samples, test_type, buffer_config),
- run_concurrent=True)
+ num_samples, test_type, buffer_config))
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ext_framebuffer_object')) as g:
- g(['fbo-generatemipmap-noimage'], run_concurrent=True)
- g(['fdo20701'], run_concurrent=True)
- g(['fbo-1d'], run_concurrent=True)
- g(['fbo-3d'], run_concurrent=True)
- g(['fbo-alphatest-formats'], run_concurrent=True)
- g(['fbo-alphatest-nocolor'], run_concurrent=True)
- g(['fbo-alphatest-nocolor-ff'], run_concurrent=True)
- g(['fbo-blending-formats'], run_concurrent=True)
- g(['fbo-bind-renderbuffer'], run_concurrent=True)
- g(['fbo-clearmipmap'], run_concurrent=True)
- g(['fbo-clear-formats'], run_concurrent=True)
- g(['fbo-copyteximage'], run_concurrent=True)
- g(['fbo-copyteximage-simple'], run_concurrent=True)
- g(['fbo-cubemap'], run_concurrent=True)
- g(['fbo-depthtex'], run_concurrent=True)
- g(['fbo-depth-sample-compare'], run_concurrent=True)
- g(['fbo-drawbuffers'], run_concurrent=True)
- g(['fbo-drawbuffers', 'masked-clear'], run_concurrent=True)
- g(['fbo-drawbuffers-arbfp'], run_concurrent=True)
- g(['fbo-drawbuffers-blend-add'], run_concurrent=True)
- g(['fbo-drawbuffers-fragcolor'], run_concurrent=True)
- g(['fbo-drawbuffers-maxtargets'], run_concurrent=True)
- g(['fbo-finish-deleted'], run_concurrent=True)
- g(['fbo-flushing'], run_concurrent=True)
- g(['fbo-flushing-2'], run_concurrent=True)
- g(['fbo-fragcoord'], run_concurrent=True)
- g(['fbo-fragcoord2'], run_concurrent=True)
- g(['fbo-generatemipmap'], run_concurrent=True)
- g(['fbo-generatemipmap-filtering'], run_concurrent=True)
- g(['fbo-generatemipmap-formats'], run_concurrent=True)
- g(['fbo-generatemipmap-scissor'], run_concurrent=True)
- g(['fbo-generatemipmap-swizzle'], run_concurrent=True)
- g(['fbo-generatemipmap-nonsquare'], run_concurrent=True)
- g(['fbo-generatemipmap-npot'], run_concurrent=True)
- g(['fbo-generatemipmap-viewport'], run_concurrent=True)
- g(['fbo-maxsize'], run_concurrent=True)
- g(['fbo-nodepth-test'], run_concurrent=True)
- g(['fbo-nostencil-test'], run_concurrent=True)
- g(['fbo-readpixels'], run_concurrent=True)
- g(['fbo-readpixels-depth-formats'], run_concurrent=True)
- g(['fbo-scissor-bitmap'], run_concurrent=True)
- g(['fbo-storage-completeness'], run_concurrent=True)
- g(['fbo-storage-formats'], run_concurrent=True)
- g(['getteximage-formats', 'init-by-rendering'], run_concurrent=True)
+ g(['fbo-generatemipmap-noimage'])
+ g(['fdo20701'])
+ g(['fbo-1d'])
+ g(['fbo-3d'])
+ g(['fbo-alphatest-formats'])
+ g(['fbo-alphatest-nocolor'])
+ g(['fbo-alphatest-nocolor-ff'])
+ g(['fbo-blending-formats'])
+ g(['fbo-bind-renderbuffer'])
+ g(['fbo-clearmipmap'])
+ g(['fbo-clear-formats'])
+ g(['fbo-copyteximage'])
+ g(['fbo-copyteximage-simple'])
+ g(['fbo-cubemap'])
+ g(['fbo-depthtex'])
+ g(['fbo-depth-sample-compare'])
+ g(['fbo-drawbuffers'])
+ g(['fbo-drawbuffers', 'masked-clear'])
+ g(['fbo-drawbuffers-arbfp'])
+ g(['fbo-drawbuffers-blend-add'])
+ g(['fbo-drawbuffers-fragcolor'])
+ g(['fbo-drawbuffers-maxtargets'])
+ g(['fbo-finish-deleted'])
+ g(['fbo-flushing'])
+ g(['fbo-flushing-2'])
+ g(['fbo-fragcoord'])
+ g(['fbo-fragcoord2'])
+ g(['fbo-generatemipmap'])
+ g(['fbo-generatemipmap-filtering'])
+ g(['fbo-generatemipmap-formats'])
+ g(['fbo-generatemipmap-scissor'])
+ g(['fbo-generatemipmap-swizzle'])
+ g(['fbo-generatemipmap-nonsquare'])
+ g(['fbo-generatemipmap-npot'])
+ g(['fbo-generatemipmap-viewport'])
+ g(['fbo-maxsize'])
+ g(['fbo-nodepth-test'])
+ g(['fbo-nostencil-test'])
+ g(['fbo-readpixels'])
+ g(['fbo-readpixels-depth-formats'])
+ g(['fbo-scissor-bitmap'])
+ g(['fbo-storage-completeness'])
+ g(['fbo-storage-formats'])
+ g(['getteximage-formats', 'init-by-rendering'])
add_fbo_stencil_tests(g, 'GL_STENCIL_INDEX1')
add_fbo_stencil_tests(g, 'GL_STENCIL_INDEX4')
add_fbo_stencil_tests(g, 'GL_STENCIL_INDEX8')
@@ -3045,16 +2821,13 @@ with profile.group_manager(
grouptools.join('spec', 'ext_packed_depth_stencil')) as g:
g(['fbo-blit-d24s8'], run_concurrent=False)
g(['fbo-clear-formats', 'GL_EXT_packed_depth_stencil', 'stencil'],
- 'fbo-clear-formats stencil', run_concurrent=True)
+ 'fbo-clear-formats stencil')
g(['ext_packed_depth_stencil-depth-stencil-texture'],
- 'DEPTH_STENCIL texture', run_concurrent=True)
- g(['ext_packed_depth_stencil-errors'], 'errors', run_concurrent=True)
- g(['ext_packed_depth_stencil-getteximage'], 'getteximage',
- run_concurrent=True)
- g(['ext_packed_depth_stencil-readdrawpixels'], 'readdrawpixels',
- run_concurrent=True)
- g(['ext_packed_depth_stencil-texsubimage'], 'texsubimage',
- run_concurrent=True)
+ 'DEPTH_STENCIL texture')
+ g(['ext_packed_depth_stencil-errors'], 'errors')
+ g(['ext_packed_depth_stencil-getteximage'], 'getteximage')
+ g(['ext_packed_depth_stencil-readdrawpixels'], 'readdrawpixels')
+ g(['ext_packed_depth_stencil-texsubimage'], 'texsubimage')
g(['ext_packed_depth_stencil-readpixels-24_8'], 'readpixels-24_8',
run_concurrent=False)
add_depthstencil_render_miplevels_tests(
@@ -3074,33 +2847,31 @@ with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'oes_packed_depth_stencil')) as g:
g(['oes_packed_depth_stencil-depth-stencil-texture_gles2'],
- 'DEPTH_STENCIL texture GLES2', run_concurrent=True)
+ 'DEPTH_STENCIL texture GLES2')
g(['oes_packed_depth_stencil-depth-stencil-texture_gles1'],
- 'DEPTH_STENCIL texture GLES1', run_concurrent=True)
+ 'DEPTH_STENCIL texture GLES1')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ext_texture_array')) as g:
- g(['fbo-generatemipmap-array'], run_concurrent=True)
- g(['fbo-generatemipmap-array', 'RGB9_E5'], run_concurrent=True)
- g(['fbo-generatemipmap-array', 'S3TC_DXT1'], run_concurrent=True)
- g(['ext_texture_array-maxlayers'], 'maxlayers',
- run_concurrent=True)
- g(['ext_texture_array-gen-mipmap'], 'gen-mipmap',
- run_concurrent=True)
+ g(['fbo-generatemipmap-array'])
+ g(['fbo-generatemipmap-array', 'RGB9_E5'])
+ g(['fbo-generatemipmap-array', 'S3TC_DXT1'])
+ g(['ext_texture_array-maxlayers'], 'maxlayers')
+ g(['ext_texture_array-gen-mipmap'], 'gen-mipmap')
g(['fbo-array'], run_concurrent=False)
g(['array-texture'], run_concurrent=False)
- g(['ext_texture_array-errors'], run_concurrent=True)
- g(['getteximage-targets', '1D_ARRAY'], run_concurrent=True)
- g(['getteximage-targets', '2D_ARRAY'], run_concurrent=True)
- g(['texsubimage', 'array'], run_concurrent=True)
+ g(['ext_texture_array-errors'])
+ g(['getteximage-targets', '1D_ARRAY'])
+ g(['getteximage-targets', '2D_ARRAY'])
+ g(['texsubimage', 'array'])
add_msaa_visual_plain_tests(g, ['copyteximage', '1D_ARRAY'],
run_concurrent=False)
add_msaa_visual_plain_tests(g, ['copyteximage', '2D_ARRAY'],
run_concurrent=False)
for test in ('depth-clear', 'depth-layered-clear', 'depth-draw', 'fs-writes-depth',
'stencil-clear', 'stencil-layered-clear', 'stencil-draw', 'fs-writes-stencil'):
- g(['fbo-depth-array', test], run_concurrent=True)
+ g(['fbo-depth-array', test])
for test_mode in ['teximage', 'texsubimage']:
test_name = 'compressed {0}'.format(test_mode, run_concurrent=False)
g(['ext_texture_array-{}'.format(test_name), '-fbo'], test_name,
@@ -3111,13 +2882,13 @@ with profile.group_manager(
grouptools.join('spec', 'arb_texture_cube_map')) as g:
g(['crash-cubemap-order'], run_concurrent=False)
g(['cubemap'], run_concurrent=False)
- g(['cubemap-getteximage-pbo'], run_concurrent=True)
+ g(['cubemap-getteximage-pbo'])
g(['cubemap-mismatch'], run_concurrent=False)
g(['cubemap', 'npot'], 'cubemap npot', run_concurrent=False)
g(['cubemap-shader'], run_concurrent=False)
g(['cubemap-shader', 'lod'], 'cubemap-shader lod', run_concurrent=False)
g(['cubemap-shader', 'bias'], 'cubemap-shader bias', run_concurrent=False)
- g(['getteximage-targets', 'CUBE'], run_concurrent=True)
+ g(['getteximage-targets', 'CUBE'])
add_msaa_visual_plain_tests(g, ['copyteximage', 'CUBE'],
run_concurrent=False)
@@ -3132,12 +2903,12 @@ with profile.group_manager(
g(['arb_texture_cube_map_array-fbo-cubemap-array'], run_concurrent=False)
g(['arb_texture_cube_map_array-sampler-cube-array-shadow'],
run_concurrent=False)
- g(['getteximage-targets', 'CUBE_ARRAY'], run_concurrent=True)
- g(['glsl-resource-not-bound', 'CubeArray'], run_concurrent=True)
- g(['fbo-generatemipmap-cubemap', 'array'], run_concurrent=True)
- g(['fbo-generatemipmap-cubemap', 'array', 'RGB9_E5'], run_concurrent=True)
- g(['fbo-generatemipmap-cubemap', 'array', 'S3TC_DXT1'], run_concurrent=True)
- g(['texsubimage', 'cube_map_array'], run_concurrent=True)
+ g(['getteximage-targets', 'CUBE_ARRAY'])
+ g(['glsl-resource-not-bound', 'CubeArray'])
+ g(['fbo-generatemipmap-cubemap', 'array'])
+ g(['fbo-generatemipmap-cubemap', 'array', 'RGB9_E5'])
+ g(['fbo-generatemipmap-cubemap', 'array', 'S3TC_DXT1'])
+ g(['texsubimage', 'cube_map_array'])
for stage in ['vs', 'gs', 'fs']:
# textureSize():
@@ -3145,86 +2916,80 @@ with profile.group_manager(
'usamplerCubeArray', 'samplerCubeArrayShadow']:
g(['textureSize', stage, sampler],
grouptools.join('textureSize', '{}-textureSize-{}'.format(
- stage, sampler)),
- run_concurrent=True)
+ stage, sampler)))
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ext_texture_swizzle')) as g:
- g(['ext_texture_swizzle-api'], run_concurrent=True)
- g(['ext_texture_swizzle-swizzle'], run_concurrent=True)
- g(['depth_texture_mode_and_swizzle'], 'depth_texture_mode_and_swizzle',
- run_concurrent=True)
+ g(['ext_texture_swizzle-api'])
+ g(['ext_texture_swizzle-swizzle'])
+ g(['depth_texture_mode_and_swizzle'], 'depth_texture_mode_and_swizzle')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ext_texture_compression_latc')) as g:
- g(['arb_texture_compression-invalid-formats', 'latc'],
- 'invalid formats',
- run_concurrent=True)
+ g(['arb_texture_compression-invalid-formats', 'latc'], 'invalid formats')
g(['fbo-generatemipmap-formats', 'GL_EXT_texture_compression_latc'],
- 'fbo-generatemipmap-formats', run_concurrent=True)
+ 'fbo-generatemipmap-formats')
g(['fbo-generatemipmap-formats', 'GL_EXT_texture_compression_latc-signed'],
- 'fbo-generatemipmap-formats-signed', run_concurrent=True)
+ 'fbo-generatemipmap-formats-signed')
add_texwrap_format_tests(g, 'GL_EXT_texture_compression_latc')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ext_texture_compression_rgtc')) as g:
- g(['compressedteximage', 'GL_COMPRESSED_RED_RGTC1_EXT'], run_concurrent=True)
- g(['compressedteximage', 'GL_COMPRESSED_RED_GREEN_RGTC2_EXT'], run_concurrent=True)
- g(['compressedteximage', 'GL_COMPRESSED_SIGNED_RED_RGTC1_EXT'], run_concurrent=True)
- g(['compressedteximage', 'GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT'], run_concurrent=True)
+ g(['compressedteximage', 'GL_COMPRESSED_RED_RGTC1_EXT'])
+ g(['compressedteximage', 'GL_COMPRESSED_RED_GREEN_RGTC2_EXT'])
+ g(['compressedteximage', 'GL_COMPRESSED_SIGNED_RED_RGTC1_EXT'])
+ g(['compressedteximage', 'GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT'])
g(['arb_texture_compression-invalid-formats', 'rgtc'], 'invalid formats',
- run_concurrent=True)
+ )
g(['rgtc-teximage-01'], run_concurrent=False)
g(['rgtc-teximage-02'], run_concurrent=False)
g(['fbo-generatemipmap-formats', 'GL_EXT_texture_compression_rgtc'],
- 'fbo-generatemipmap-formats', run_concurrent=True)
+ 'fbo-generatemipmap-formats')
g(['fbo-generatemipmap-formats', 'GL_EXT_texture_compression_rgtc-signed'],
- 'fbo-generatemipmap-formats-signed', run_concurrent=True)
+ 'fbo-generatemipmap-formats-signed')
add_texwrap_format_tests(g, 'GL_EXT_texture_compression_rgtc')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ext_texture_compression_s3tc')) as g:
- g(['compressedteximage', 'GL_COMPRESSED_RGB_S3TC_DXT1_EXT'], run_concurrent=True)
- g(['compressedteximage', 'GL_COMPRESSED_RGBA_S3TC_DXT1_EXT'], run_concurrent=True)
- g(['compressedteximage', 'GL_COMPRESSED_RGBA_S3TC_DXT3_EXT'], run_concurrent=True)
- g(['compressedteximage', 'GL_COMPRESSED_RGBA_S3TC_DXT5_EXT'], run_concurrent=True)
- g(['arb_texture_compression-invalid-formats', 's3tc'], 'invalid formats',
- run_concurrent=True)
+ g(['compressedteximage', 'GL_COMPRESSED_RGB_S3TC_DXT1_EXT'])
+ g(['compressedteximage', 'GL_COMPRESSED_RGBA_S3TC_DXT1_EXT'])
+ g(['compressedteximage', 'GL_COMPRESSED_RGBA_S3TC_DXT3_EXT'])
+ g(['compressedteximage', 'GL_COMPRESSED_RGBA_S3TC_DXT5_EXT'])
+ g(['arb_texture_compression-invalid-formats', 's3tc'], 'invalid formats')
g(['gen-compressed-teximage'], run_concurrent=False)
- g(['s3tc-errors'], run_concurrent=True)
+ g(['s3tc-errors'])
g(['s3tc-teximage'], run_concurrent=False)
g(['s3tc-texsubimage'], run_concurrent=False)
- g(['getteximage-targets', 'S3TC', '2D'], run_concurrent=True)
- g(['getteximage-targets', 'S3TC', '2D_ARRAY'], run_concurrent=True)
- g(['getteximage-targets', 'S3TC', 'CUBE'], run_concurrent=True)
- g(['getteximage-targets', 'S3TC', 'CUBE_ARRAY'], run_concurrent=True)
- g(['compressedteximage', 'GL_COMPRESSED_SRGB_S3TC_DXT1_EXT'], run_concurrent=True)
- g(['compressedteximage', 'GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT'], run_concurrent=True)
- g(['compressedteximage', 'GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT'], run_concurrent=True)
- g(['compressedteximage', 'GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT'], run_concurrent=True)
+ g(['getteximage-targets', 'S3TC', '2D'])
+ g(['getteximage-targets', 'S3TC', '2D_ARRAY'])
+ g(['getteximage-targets', 'S3TC', 'CUBE'])
+ g(['getteximage-targets', 'S3TC', 'CUBE_ARRAY'])
+ g(['compressedteximage', 'GL_COMPRESSED_SRGB_S3TC_DXT1_EXT'])
+ g(['compressedteximage', 'GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT'])
+ g(['compressedteximage', 'GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT'])
+ g(['compressedteximage', 'GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT'])
g(['fbo-generatemipmap-formats', 'GL_EXT_texture_compression_s3tc'],
- 'fbo-generatemipmap-formats', run_concurrent=True)
+ 'fbo-generatemipmap-formats')
add_texwrap_format_tests(g, 'GL_EXT_texture_compression_s3tc')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ati_texture_compression_3dc')) as g:
- g(['arb_texture_compression-invalid-formats', '3dc'], 'invalid formats',
- run_concurrent=True)
+ g(['arb_texture_compression-invalid-formats', '3dc'], 'invalid formats')
g(['fbo-generatemipmap-formats', 'GL_ATI_texture_compression_3dc'],
- 'fbo-generatemipmap-formats', run_concurrent=True)
+ 'fbo-generatemipmap-formats')
add_texwrap_format_tests(g, 'GL_ATI_texture_compression_3dc')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ext_packed_float')) as g:
- g(['ext_packed_float-pack'], 'pack', run_concurrent=True)
+ g(['ext_packed_float-pack'], 'pack')
g(['getteximage-invalid-format-for-packed-type'],
- 'getteximage-invalid-format-for-packed-type', run_concurrent=True)
+ 'getteximage-invalid-format-for-packed-type')
add_msaa_formats_tests(g, 'GL_EXT_packed_float')
add_texwrap_format_tests(g, 'GL_EXT_packed_float')
add_fbo_formats_tests(g, 'GL_EXT_packed_float')
@@ -3240,38 +3005,33 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'oes_texture_float')) as g:
- g(['oes_texture_float'], run_concurrent=True)
- g(['oes_texture_float', 'half'], run_concurrent=True)
- g(['oes_texture_float', 'linear'], run_concurrent=True)
- g(['oes_texture_float', 'half', 'linear'], run_concurrent=True)
+ g(['oes_texture_float'])
+ g(['oes_texture_float', 'half'])
+ g(['oes_texture_float', 'linear'])
+ g(['oes_texture_float', 'half', 'linear'])
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ext_texture_integer')) as g:
- g(['ext_texture_integer-api-drawpixels'],
- 'api-drawpixels', run_concurrent=True)
- g(['ext_texture_integer-api-teximage'],
- 'api-teximage', run_concurrent=True)
- g(['ext_texture_integer-api-readpixels'],
- 'api-readpixels', run_concurrent=True)
- g(['ext_texture_integer-fbo-blending'],
- 'fbo-blending', run_concurrent=True)
+ g(['ext_texture_integer-api-drawpixels'], 'api-drawpixels')
+ g(['ext_texture_integer-api-teximage'], 'api-teximage')
+ g(['ext_texture_integer-api-readpixels'], 'api-readpixels')
+ g(['ext_texture_integer-fbo-blending'], 'fbo-blending')
g(['ext_texture_integer-fbo-blending', 'GL_ARB_texture_rg'],
- 'fbo-blending GL_ARB_texture_rg', run_concurrent=True)
+ 'fbo-blending GL_ARB_texture_rg')
g(['ext_texture_integer-fbo_integer_precision_clear'],
'fbo_integer_precision_clear', run_concurrent=False)
g(['ext_texture_integer-fbo_integer_readpixels_sint_uint'],
'fbo_integer_readpixels_sint_uint', run_concurrent=False)
- g(['ext_texture_integer-getteximage-clamping'], 'getteximage-clamping',
- run_concurrent=True)
+ g(['ext_texture_integer-getteximage-clamping'], 'getteximage-clamping')
g(['ext_texture_integer-getteximage-clamping', 'GL_ARB_texture_rg'],
- 'getteximage-clamping GL_ARB_texture_rg', run_concurrent=True)
+ 'getteximage-clamping GL_ARB_texture_rg')
g(['ext_texture_integer-texture_integer_glsl130'],
- 'texture_integer_glsl130', run_concurrent=True)
+ 'texture_integer_glsl130')
g(['fbo-integer'], run_concurrent=False)
# TODO: unsupported for int yet
- # g(['fbo-clear-formats', 'GL_EXT_texture_integer'], 'fbo-clear-formats', run_concurrent=True)
+ # g(['fbo-clear-formats', 'GL_EXT_texture_integer'], 'fbo-clear-formats')
add_msaa_formats_tests(g, 'GL_EXT_texture_integer')
add_texwrap_format_tests(g, 'GL_EXT_texture_integer')
@@ -3284,7 +3044,7 @@ with profile.group_manager(
g(['rg-teximage-02'], run_concurrent=False)
g(['texture-rg'], run_concurrent=False)
# TODO: unsupported for int yet
- # g(['fbo-clear-formats', 'GL_ARB_texture_rg-int'], 'fbo-clear-formats-int', run_concurrent=True)
+ # g(['fbo-clear-formats', 'GL_ARB_texture_rg-int'], # 'fbo-clear-formats-int')
add_msaa_formats_tests(g, 'GL_ARB_texture_rg')
add_msaa_formats_tests(g, 'GL_ARB_texture_rg-int')
add_msaa_formats_tests(g, 'GL_ARB_texture_rg-float')
@@ -3293,7 +3053,7 @@ with profile.group_manager(
add_texwrap_format_tests(g, 'GL_ARB_texture_rg-int', '-int')
for format in ['GL_RED', 'GL_R8', 'GL_R16', 'GL_RG', 'GL_RG8', 'GL_RG16']:
- g(['fbo-rg', format], "fbo-rg-{}".format(format), run_concurrent=True)
+ g(['fbo-rg', format], "fbo-rg-{}".format(format))
add_fbo_formats_tests(g, 'GL_ARB_texture_rg')
add_fbo_formats_tests(g, 'GL_ARB_texture_rg-float', '-float')
@@ -3301,14 +3061,14 @@ with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_texture_rgb10_a2ui')) as g:
g(['ext_texture_integer-fbo-blending', 'GL_ARB_texture_rgb10_a2ui'],
- 'fbo-blending', run_concurrent=True)
+ 'fbo-blending')
add_texwrap_format_tests(g, 'GL_ARB_texture_rgb10_a2ui')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'ext_texture_shared_exponent')) as g:
g(['fbo-generatemipmap-formats', 'GL_EXT_texture_shared_exponent'],
- 'fbo-generatemipmap-formats', run_concurrent=True)
+ 'fbo-generatemipmap-formats')
add_texwrap_format_tests(g, 'GL_EXT_texture_shared_exponent')
with profile.group_manager(
@@ -3322,31 +3082,28 @@ with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'ext_texture_srgb')) as g:
g(['fbo-srgb'], run_concurrent=False)
g(['tex-srgb'], run_concurrent=False)
- g(['arb_texture_compression-invalid-formats', 'srgb'], 'invalid formats',
- run_concurrent=True)
+ g(['arb_texture_compression-invalid-formats', 'srgb'], 'invalid formats')
g(['fbo-generatemipmap-formats', 'GL_EXT_texture_sRGB'],
- 'fbo-generatemipmap-formats', run_concurrent=True)
+ 'fbo-generatemipmap-formats')
g(['fbo-generatemipmap-formats', 'GL_EXT_texture_sRGB-s3tc'],
- 'fbo-generatemipmap-formats-s3tc', run_concurrent=True)
+ 'fbo-generatemipmap-formats-s3tc')
# TODO: also use GL_ARB_framebuffer_sRGB:
- # g(['fbo-blending-formats', 'GL_EXT_texture_sRGB'], 'fbo-blending-formats', run_concurrent=True)
- g(['fbo-alphatest-formats', 'GL_EXT_texture_sRGB'],
- 'fbo-alphatest-formats', run_concurrent=True)
+ # g(['fbo-blending-formats', 'GL_EXT_texture_sRGB'], # 'fbo-blending-formats')
+ g(['fbo-alphatest-formats', 'GL_EXT_texture_sRGB'], 'fbo-alphatest-formats')
add_msaa_formats_tests(g, 'GL_EXT_texture_sRGB')
add_texwrap_format_tests(g, 'GL_EXT_texture_sRGB')
add_texwrap_format_tests(g, 'GL_EXT_texture_sRGB-s3tc', '-s3tc')
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'ext_timer_query')) as g:
- g(['ext_timer_query-time-elapsed'], 'time-elapsed', run_concurrent=True)
+ g(['ext_timer_query-time-elapsed'], 'time-elapsed')
g(['timer_query'], run_concurrent=False)
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'arb_timer_query')) as g:
- g(['ext_timer_query-time-elapsed', 'timestamp'], 'query GL_TIMESTAMP',
- run_concurrent=True)
- g(['ext_timer_query-lifetime'], 'query-lifetime', run_concurrent=True)
- g(['arb_timer_query-timestamp-get'], 'timestamp-get', run_concurrent=True)
+ g(['ext_timer_query-time-elapsed', 'timestamp'], 'query GL_TIMESTAMP')
+ g(['ext_timer_query-lifetime'], 'query-lifetime')
+ g(['arb_timer_query-timestamp-get'], 'timestamp-get')
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'ext_transform_feedback')) as g:
@@ -3368,8 +3125,7 @@ with profile.group_manager(
'useprogstage_noactive', 'useprogstage_active',
'bind_pipeline']:
g(['ext_transform_feedback-api-errors', mode],
- 'api-errors {}'.format(mode),
- run_concurrent=True)
+ 'api-errors {}'.format(mode))
for varying in ['gl_Color', 'gl_SecondaryColor', 'gl_TexCoord',
'gl_FogFragCoord', 'gl_Position', 'gl_PointSize',
@@ -3388,22 +3144,20 @@ with profile.group_manager(
for mode in ['main_binding', 'indexed_binding', 'buffer_start',
'buffer_size']:
g(['ext_transform_feedback-get-buffer-size', mode],
- 'get-buffer-size {}'.format(mode), run_concurrent=True)
+ 'get-buffer-size {}'.format(mode))
g(['ext_transform_feedback-get-buffer-state', mode],
- 'get-buffer-state {}'.format(mode), run_concurrent=True)
+ 'get-buffer-state {}'.format(mode))
for mode in ['output', 'prims_generated', 'prims_written']:
g(['ext_transform_feedback-intervening-read', mode],
- 'intervening-read {0}'.format(mode),
- run_concurrent=True)
+ 'intervening-read {0}'.format(mode))
g(['ext_transform_feedback-intervening-read', mode, 'use_gs'],
- 'intervening-read {0} use_gs'.format(mode),
- run_concurrent=True)
+ 'intervening-read {0} use_gs'.format(mode))
for drawcall in ['arrays', 'elements']:
for mode in ['triangles', 'lines', 'points']:
g(['ext_transform_feedback-order', drawcall, mode],
- 'order {0} {1}'.format(drawcall, mode), run_concurrent=True)
+ 'order {0} {1}'.format(drawcall, mode))
for draw_mode in ['points', 'lines', 'line_loop', 'line_strip',
'triangles', 'triangle_strip', 'triangle_fan',
@@ -3413,12 +3167,11 @@ with profile.group_manager(
shade_mode == 'wireframe'):
continue
g(['ext_transform_feedback-tessellation', draw_mode, shade_mode],
- 'tessellation {0} {1}'.format(draw_mode, shade_mode),
- run_concurrent=True)
+ 'tessellation {0} {1}'.format(draw_mode, shade_mode))
for alignment in [0, 4, 8, 12]:
g(['ext_transform_feedback-alignment', str(alignment)],
- 'alignment {0}'.format(alignment), run_concurrent=True)
+ 'alignment {0}'.format(alignment))
for output_type in ['float', 'vec2', 'vec3', 'vec4', 'mat2', 'mat2x3',
'mat2x4', 'mat3x2', 'mat3', 'mat3x4', 'mat4x2', 'mat4x3',
@@ -3426,17 +3179,16 @@ with profile.group_manager(
'uvec3', 'uvec4']:
for suffix in ['', '[2]', '[2]-no-subscript']:
g(['ext_transform_feedback-output-type', output_type, suffix],
- 'output-type {0}{1}'.format(output_type, suffix),
- run_concurrent=True)
+ 'output-type {0}{1}'.format(output_type, suffix))
for mode in ['discard', 'buffer', 'prims_generated', 'prims_written']:
g(['ext_transform_feedback-generatemipmap', mode],
- 'generatemipmap {0}'.format(mode), run_concurrent=True)
+ 'generatemipmap {0}'.format(mode))
for test_case in ['base-shrink', 'base-grow', 'offset-shrink', 'offset-grow',
'range-shrink', 'range-grow']:
g(['ext_transform_feedback-change-size', test_case],
- 'change-size {0}'.format(test_case), run_concurrent=True)
+ 'change-size {0}'.format(test_case))
for api_suffix, possible_options in [('', [[], ['interface']]),
('_gles3', [[]])]:
@@ -3449,100 +3201,83 @@ with profile.group_manager(
g(['ext_transform_feedback-structs{0}'.format(api_suffix),
subtest, mode] + options,
'structs{0} {1}'.format(
- api_suffix, ' '.join([subtest, mode] + options)),
- run_concurrent=True)
-
- g(['ext_transform_feedback-buffer-usage'], 'buffer-usage',
- run_concurrent=True)
- g(['ext_transform_feedback-discard-api'], 'discard-api',
- run_concurrent=True)
- g(['ext_transform_feedback-discard-bitmap'], 'discard-bitmap',
- run_concurrent=True)
- g(['ext_transform_feedback-discard-clear'], 'discard-clear',
- run_concurrent=True)
- g(['ext_transform_feedback-discard-copypixels'], 'discard-copypixels',
- run_concurrent=True)
- g(['ext_transform_feedback-discard-drawarrays'], 'discard-drawarrays',
- run_concurrent=True)
- g(['ext_transform_feedback-discard-drawpixels'], 'discard-drawpixels',
- run_concurrent=True)
- g(['ext_transform_feedback-immediate-reuse'], 'immediate-reuse',
- run_concurrent=True)
+ api_suffix, ' '.join([subtest, mode] + options)))
+
+ g(['ext_transform_feedback-buffer-usage'], 'buffer-usage')
+ g(['ext_transform_feedback-discard-api'], 'discard-api')
+ g(['ext_transform_feedback-discard-bitmap'], 'discard-bitmap')
+ g(['ext_transform_feedback-discard-clear'], 'discard-clear')
+ g(['ext_transform_feedback-discard-copypixels'], 'discard-copypixels')
+ g(['ext_transform_feedback-discard-drawarrays'], 'discard-drawarrays')
+ g(['ext_transform_feedback-discard-drawpixels'], 'discard-drawpixels')
+ g(['ext_transform_feedback-immediate-reuse'], 'immediate-reuse')
g(['ext_transform_feedback-immediate-reuse-index-buffer'],
- 'immediate-reuse-index-buffer', run_concurrent=True)
+ 'immediate-reuse-index-buffer')
g(['ext_transform_feedback-immediate-reuse-uniform-buffer'],
- 'immediate-reuse-uniform-buffer', run_concurrent=True)
- g(['ext_transform_feedback-max-varyings'], 'max-varyings',
- run_concurrent=True)
- g(['ext_transform_feedback-nonflat-integral'], 'nonflat-integral',
- run_concurrent=True)
- g(['ext_transform_feedback-overflow-edge-cases'], 'overflow-edge-cases',
- run_concurrent=True)
+ 'immediate-reuse-uniform-buffer')
+ g(['ext_transform_feedback-max-varyings'], 'max-varyings')
+ g(['ext_transform_feedback-nonflat-integral'], 'nonflat-integral')
+ g(['ext_transform_feedback-overflow-edge-cases'], 'overflow-edge-cases')
g(['ext_transform_feedback-overflow-edge-cases', 'use_gs'],
- 'overflow-edge-cases use_gs', run_concurrent=True)
- g(['ext_transform_feedback-points'], 'points', run_concurrent=True)
- g(['ext_transform_feedback-points', 'large'], 'points-large',
- run_concurrent=True)
- g(['ext_transform_feedback-position'], 'position-readback-bufferbase',
- run_concurrent=True)
+ 'overflow-edge-cases use_gs')
+ g(['ext_transform_feedback-points'], 'points')
+ g(['ext_transform_feedback-points', 'large'], 'points-large')
+ g(['ext_transform_feedback-position'], 'position-readback-bufferbase')
g(['ext_transform_feedback-position', 'discard'],
- 'position-readback-bufferbase-discard', run_concurrent=True)
+ 'position-readback-bufferbase-discard')
g(['ext_transform_feedback-position', 'offset'],
- 'position-readback-bufferoffset', run_concurrent=True)
+ 'position-readback-bufferoffset')
g(['ext_transform_feedback-position', 'offset', 'discard'],
- 'position-readback-bufferoffset-discard', run_concurrent=True)
+ 'position-readback-bufferoffset-discard')
g(['ext_transform_feedback-position', 'range'],
- 'position-readback-bufferrange', run_concurrent=True)
+ 'position-readback-bufferrange')
g(['ext_transform_feedback-position', 'range', 'discard'],
- 'position-readback-bufferrange-discard', run_concurrent=True)
- g(['ext_transform_feedback-negative-prims'], 'negative-prims',
- run_concurrent=True)
+ 'position-readback-bufferrange-discard')
+ g(['ext_transform_feedback-negative-prims'], 'negative-prims')
g(['ext_transform_feedback-primgen'],
- 'primgen-query transform-feedback-disabled', run_concurrent=True)
+ 'primgen-query transform-feedback-disabled')
g(['ext_transform_feedback-pipeline-basic-primgen'],
- 'pipeline-basic-primgen', run_concurrent=True)
+ 'pipeline-basic-primgen')
g(['ext_transform_feedback-position', 'render'],
- 'position-render-bufferbase', run_concurrent=True)
+ 'position-render-bufferbase')
g(['ext_transform_feedback-position', 'render', 'discard'],
- 'position-render-bufferbase-discard', run_concurrent=True)
+ 'position-render-bufferbase-discard')
g(['ext_transform_feedback-position', 'render', 'offset'],
- 'position-render-bufferoffset', run_concurrent=True)
+ 'position-render-bufferoffset')
g(['ext_transform_feedback-position', 'render', 'offset', 'discard'],
- 'position-render-bufferoffset-discard', run_concurrent=True)
+ 'position-render-bufferoffset-discard')
g(['ext_transform_feedback-position', 'render', 'range'],
- 'position-render-bufferrange', run_concurrent=True)
+ 'position-render-bufferrange')
g(['ext_transform_feedback-position', 'render', 'range', 'discard'],
- 'position-render-bufferrange-discard', run_concurrent=True)
+ 'position-render-bufferrange-discard')
g(['ext_transform_feedback-position', 'primgen'],
- 'query-primitives_generated-bufferbase', run_concurrent=True)
+ 'query-primitives_generated-bufferbase')
g(['ext_transform_feedback-position', 'primgen', 'discard'],
- 'query-primitives_generated-bufferbase-discard', run_concurrent=True)
+ 'query-primitives_generated-bufferbase-discard')
g(['ext_transform_feedback-position', 'primgen', 'offset'],
- 'query-primitives_generated-bufferoffset', run_concurrent=True)
+ 'query-primitives_generated-bufferoffset')
g(['ext_transform_feedback-position', 'primgen', 'offset', 'discard'],
- 'query-primitives_generated-bufferoffset-discard', run_concurrent=True)
+ 'query-primitives_generated-bufferoffset-discard')
g(['ext_transform_feedback-position', 'primgen', 'range'],
- 'query-primitives_generated-bufferrange', run_concurrent=True)
+ 'query-primitives_generated-bufferrange')
g(['ext_transform_feedback-position', 'primgen', 'range', 'discard'],
- 'query-primitives_generated-bufferrange-discard', run_concurrent=True)
+ 'query-primitives_generated-bufferrange-discard')
g(['ext_transform_feedback-position', 'primwritten'],
- 'query-primitives_written-bufferbase', run_concurrent=True)
+ 'query-primitives_written-bufferbase')
g(['ext_transform_feedback-position', 'primwritten', 'discard'],
- 'query-primitives_written-bufferbase-discard', run_concurrent=True)
+ 'query-primitives_written-bufferbase-discard')
g(['ext_transform_feedback-position', 'primwritten', 'offset'],
- 'query-primitives_written-bufferoffset', run_concurrent=True)
+ 'query-primitives_written-bufferoffset')
g(['ext_transform_feedback-position', 'primwritten', 'offset', 'discard'],
- 'query-primitives_written-bufferoffset-discard', run_concurrent=True)
+ 'query-primitives_written-bufferoffset-discard')
g(['ext_transform_feedback-position', 'primwritten', 'range'],
- 'query-primitives_written-bufferrange', run_concurrent=True)
+ 'query-primitives_written-bufferrange')
g(['ext_transform_feedback-position', 'primwritten', 'range', 'discard'],
- 'query-primitives_written-bufferrange-discard', run_concurrent=True)
- g(['ext_transform_feedback-interleaved'], 'interleaved-attribs',
- run_concurrent=True)
- g(['ext_transform_feedback-separate'], 'separate-attribs',
- run_concurrent=True)
+ 'query-primitives_written-bufferrange-discard')
+ g(['ext_transform_feedback-interleaved'], 'interleaved-attribs')
+ g(['ext_transform_feedback-separate'], 'separate-attribs')
g(['ext_transform_feedback-geometry-shaders-basic'],
- 'geometry-shaders-basic', run_concurrent=True)
+ 'geometry-shaders-basic')
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'arb_transform_feedback2')) as g:
@@ -3557,13 +3292,11 @@ with profile.group_manager(
g(['arb_transform_feedback2-istransformfeedback'], 'istranformfeedback',
run_concurrent=False)
g(['arb_transform_feedback2-gen-names-only'],
- 'glGenTransformFeedbacks names only', run_concurrent=True)
+ 'glGenTransformFeedbacks names only')
g(['arb_transform_feedback2-cannot-bind-when-active'],
- 'cannot bind when another object is active', run_concurrent=True)
- g(['arb_transform_feedback2-api-queries'], 'misc. API queries',
- run_concurrent=True)
- g(['arb_transform_feedback2-pause-counting'], 'counting with pause',
- run_concurrent=True)
+ 'cannot bind when another object is active')
+ g(['arb_transform_feedback2-api-queries'], 'misc. API queries')
+ g(['arb_transform_feedback2-pause-counting'], 'counting with pause')
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'ext_transform_instanced')) as g:
@@ -3601,87 +3334,69 @@ with profile.group_manager(
'gl_SkipComponents3', 'gl_SkipComponents4',
'gl_NextBuffer-gl_SkipComponents1-gl_NextBuffer',
'gl_NextBuffer-gl_NextBuffer', 'gl_SkipComponents1234']:
- g(['ext_transform_feedback-output-type', param], param,
- run_concurrent=True)
+ g(['ext_transform_feedback-output-type', param], param)
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_uniform_buffer_object')) as g:
g(['arb_uniform_buffer_object-bindbuffer-general-point'],
- 'bindbuffer-general-point', run_concurrent=True)
- g(['arb_uniform_buffer_object-buffer-targets'], 'buffer-targets',
- run_concurrent=True)
- g(['arb_uniform_buffer_object-bufferstorage'], 'bufferstorage',
- run_concurrent=True)
- g(['arb_uniform_buffer_object-deletebuffers'], 'deletebuffers',
- run_concurrent=True)
- g(['arb_uniform_buffer_object-dlist'], 'dlist', run_concurrent=True)
+ 'bindbuffer-general-point')
+ g(['arb_uniform_buffer_object-buffer-targets'], 'buffer-targets')
+ g(['arb_uniform_buffer_object-bufferstorage'], 'bufferstorage')
+ g(['arb_uniform_buffer_object-deletebuffers'], 'deletebuffers')
+ g(['arb_uniform_buffer_object-dlist'], 'dlist')
g(['arb_uniform_buffer_object-getactiveuniformblockiv-uniform-block-data-size'],
- 'getactiveuniformblockiv-uniform-block-data-size', run_concurrent=True)
+ 'getactiveuniformblockiv-uniform-block-data-size')
g(['arb_uniform_buffer_object-getactiveuniformblockname'],
- 'getactiveuniformblockname', run_concurrent=True)
+ 'getactiveuniformblockname')
g(['arb_uniform_buffer_object-getactiveuniformname'],
- 'getactiveuniformname', run_concurrent=True)
+ 'getactiveuniformname')
g(['arb_uniform_buffer_object-getactiveuniformsiv-uniform-array-stride'],
- 'getactiveuniformsiv-uniform-array-stride', run_concurrent=True)
+ 'getactiveuniformsiv-uniform-array-stride')
g(['arb_uniform_buffer_object-getactiveuniformsiv-uniform-block-index'],
- 'getactiveuniformsiv-uniform-block-index', run_concurrent=True)
+ 'getactiveuniformsiv-uniform-block-index')
g(['arb_uniform_buffer_object-getactiveuniformsiv-uniform-matrix-stride'],
- 'getactiveuniformsiv-uniform-matrix-stride', run_concurrent=True)
+ 'getactiveuniformsiv-uniform-matrix-stride')
g(['arb_uniform_buffer_object-getactiveuniformsiv-uniform-type'],
- 'getactiveuniformsiv-uniform-type', run_concurrent=True)
- g(['arb_uniform_buffer_object-getintegeri_v'], 'getintegeri_v',
- run_concurrent=True)
- g(['arb_uniform_buffer_object-getprogramiv'], 'getprogramiv',
- run_concurrent=True)
+ 'getactiveuniformsiv-uniform-type')
+ g(['arb_uniform_buffer_object-getintegeri_v'], 'getintegeri_v')
+ g(['arb_uniform_buffer_object-getprogramiv'], 'getprogramiv')
g(['arb_uniform_buffer_object-getuniformblockindex'],
- 'getuniformblockindex', run_concurrent=True)
- g(['arb_uniform_buffer_object-getuniformindices'], 'getuniformindices',
- run_concurrent=True)
- g(['arb_uniform_buffer_object-getuniformlocation'], 'getuniformlocation',
- run_concurrent=True)
- g(['arb_uniform_buffer_object-layout-std140'], 'layout-std140',
- run_concurrent=True)
+ 'getuniformblockindex')
+ g(['arb_uniform_buffer_object-getuniformindices'], 'getuniformindices')
+ g(['arb_uniform_buffer_object-getuniformlocation'], 'getuniformlocation')
+ g(['arb_uniform_buffer_object-layout-std140'], 'layout-std140')
g(['arb_uniform_buffer_object-layout-std140-base-size-and-alignment'],
- 'layout-std140-base-size-and-alignment', run_concurrent=True)
+ 'layout-std140-base-size-and-alignment')
g(['arb_uniform_buffer_object-link-mismatch-blocks'],
- 'link-mismatch-blocks', run_concurrent=True)
- g(['arb_uniform_buffer_object-maxblocks'], 'maxblocks',
- run_concurrent=True)
- g(['arb_uniform_buffer_object-minmax'], 'minmax', run_concurrent=True)
+ 'link-mismatch-blocks')
+ g(['arb_uniform_buffer_object-maxblocks'], 'maxblocks')
+ g(['arb_uniform_buffer_object-minmax'], 'minmax')
g(['arb_uniform_buffer_object-negative-bindbuffer-index'],
- 'negative-bindbuffer-index', run_concurrent=True)
+ 'negative-bindbuffer-index')
g(['arb_uniform_buffer_object-negative-bindbuffer-target'],
- 'negative-bindbuffer-target', run_concurrent=True)
+ 'negative-bindbuffer-target')
g(['arb_uniform_buffer_object-negative-bindbufferrange-range'],
- 'negative-bindbufferrange-range', run_concurrent=True)
+ 'negative-bindbufferrange-range')
g(['arb_uniform_buffer_object-negative-getactiveuniformblockiv'],
- 'negative-getactiveuniformblockiv', run_concurrent=True)
+ 'negative-getactiveuniformblockiv')
g(['arb_uniform_buffer_object-negative-getactiveuniformsiv'],
- 'negative-getactiveuniformsiv', run_concurrent=True)
+ 'negative-getactiveuniformsiv')
g(['arb_uniform_buffer_object-referenced-by-shader'],
- 'referenced-by-shader', run_concurrent=True)
- g(['arb_uniform_buffer_object-rendering'], 'rendering',
- run_concurrent=True)
- g(['arb_uniform_buffer_object-rendering', 'offset'], 'rendering-offset',
- run_concurrent=True)
- g(['arb_uniform_buffer_object-row-major'], 'row-major',
- run_concurrent=True)
- g(['arb_uniform_buffer_object-uniformblockbinding'], 'uniformblockbinding',
- run_concurrent=True)
+ 'referenced-by-shader')
+ g(['arb_uniform_buffer_object-rendering'], 'rendering')
+ g(['arb_uniform_buffer_object-rendering', 'offset'], 'rendering-offset')
+ g(['arb_uniform_buffer_object-row-major'], 'row-major')
+ g(['arb_uniform_buffer_object-uniformblockbinding'], 'uniformblockbinding')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_uniform_buffer_object',
'maxuniformblocksize')) as g:
- g(['arb_uniform_buffer_object-maxuniformblocksize', 'vs'], 'vs',
- run_concurrent=True)
- g(['arb_uniform_buffer_object-maxuniformblocksize', 'vsexceed'], 'vsexceed',
- run_concurrent=True)
- g(['arb_uniform_buffer_object-maxuniformblocksize', 'fs'], 'fs',
- run_concurrent=True)
- g(['arb_uniform_buffer_object-maxuniformblocksize', 'fsexceed'], 'fsexceed',
- run_concurrent=True)
+ g(['arb_uniform_buffer_object-maxuniformblocksize', 'vs'], 'vs')
+ g(['arb_uniform_buffer_object-maxuniformblocksize', 'vsexceed'], 'vsexceed')
+ g(['arb_uniform_buffer_object-maxuniformblocksize', 'fs'], 'fs')
+ g(['arb_uniform_buffer_object-maxuniformblocksize', 'fsexceed'], 'fsexceed')
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'ati_draw_buffers')) as g:
@@ -3706,39 +3421,37 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_internalformat_query')) as g:
- g(['arb_internalformat_query-api-errors'], 'misc. API error checks',
- run_concurrent=True)
- g(['arb_internalformat_query-overrun'], 'buffer over-run checks',
- run_concurrent=True)
- g(['arb_internalformat_query-minmax'], 'minmax', run_concurrent=True)
+ g(['arb_internalformat_query-api-errors'], 'misc. API error checks')
+ g(['arb_internalformat_query-overrun'], 'buffer over-run checks')
+ g(['arb_internalformat_query-minmax'], 'minmax')
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'arb_map_buffer_range')) as g:
g(['map_buffer_range_error_check'], run_concurrent=False)
g(['map_buffer_range_test'], run_concurrent=False)
g(['map_buffer_range-invalidate', 'MAP_INVALIDATE_RANGE_BIT', 'offset=0'],
- 'MAP_INVALIDATE_RANGE_BIT offset=0', run_concurrent=True)
+ 'MAP_INVALIDATE_RANGE_BIT offset=0')
g(['map_buffer_range-invalidate', 'MAP_INVALIDATE_RANGE_BIT', 'increment-offset'],
- 'MAP_INVALIDATE_RANGE_BIT increment-offset', run_concurrent=True)
+ 'MAP_INVALIDATE_RANGE_BIT increment-offset')
g(['map_buffer_range-invalidate', 'MAP_INVALIDATE_RANGE_BIT', 'decrement-offset'],
- 'MAP_INVALIDATE_RANGE_BIT decrement-offset', run_concurrent=True)
+ 'MAP_INVALIDATE_RANGE_BIT decrement-offset')
g(['map_buffer_range-invalidate', 'MAP_INVALIDATE_BUFFER_BIT', 'offset=0'],
- 'MAP_INVALIDATE_BUFFER_BIT offset=0', run_concurrent=True)
+ 'MAP_INVALIDATE_BUFFER_BIT offset=0')
g(['map_buffer_range-invalidate', 'MAP_INVALIDATE_BUFFER_BIT', 'increment-offset'],
- 'MAP_INVALIDATE_BUFFER_BIT increment-offset', run_concurrent=True)
+ 'MAP_INVALIDATE_BUFFER_BIT increment-offset')
g(['map_buffer_range-invalidate', 'MAP_INVALIDATE_BUFFER_BIT', 'decrement-offset'],
- 'MAP_INVALIDATE_BUFFER_BIT decrement-offset', run_concurrent=True)
+ 'MAP_INVALIDATE_BUFFER_BIT decrement-offset')
g(['map_buffer_range-invalidate', 'CopyBufferSubData', 'offset=0'],
- 'CopyBufferSubData offset=0', run_concurrent=True)
+ 'CopyBufferSubData offset=0')
g(['map_buffer_range-invalidate', 'CopyBufferSubData', 'increment-offset'],
- 'CopyBufferSubData increment-offset', run_concurrent=True)
+ 'CopyBufferSubData increment-offset')
g(['map_buffer_range-invalidate', 'CopyBufferSubData', 'decrement-offset'],
- 'CopyBufferSubData decrement-offset', run_concurrent=True)
+ 'CopyBufferSubData decrement-offset')
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'arb_multisample')) as g:
- g(['arb_multisample-beginend'], 'beginend', run_concurrent=True)
- g(['arb_multisample-pushpop'], 'pushpop', run_concurrent=True)
+ g(['arb_multisample-beginend'], 'beginend')
+ g(['arb_multisample-pushpop'], 'pushpop')
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'arb_seamless_cube_map')) as g:
@@ -3776,7 +3489,7 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'amd_vertex_shader_viewport_index')) as g:
- g(['amd_vertex_shader_viewport_index-render'], run_concurrent=True)
+ g(['amd_vertex_shader_viewport_index-render'])
with profile.group_manager(
PiglitGLTest,
@@ -3791,9 +3504,8 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'nv_conditional_render')) as g:
- g(['nv_conditional_render-begin-while-active'], 'begin-while-active',
- run_concurrent=True)
- g(['nv_conditional_render-begin-zero'], 'begin-zero', run_concurrent=True)
+ g(['nv_conditional_render-begin-while-active'], 'begin-while-active')
+ g(['nv_conditional_render-begin-zero'], 'begin-zero')
g(['nv_conditional_render-bitmap'], 'bitmap', run_concurrent=False)
g(['nv_conditional_render-blitframebuffer'], 'blitframebuffer',
run_concurrent=False)
@@ -3814,334 +3526,266 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'oes_matrix_get')) as g:
- g(['oes_matrix_get-api'], 'All queries', run_concurrent=True)
+ g(['oes_matrix_get-api'], 'All queries')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'oes_fixed_point')) as g:
- g(['oes_fixed_point-attribute-arrays'], 'attribute-arrays',
- run_concurrent=True)
+ g(['oes_fixed_point-attribute-arrays'], 'attribute-arrays')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_clear_buffer_object')) as g:
- g(['arb_clear_buffer_object-formats'], run_concurrent=True)
- g(['arb_clear_buffer_object-invalid-internal-format'], run_concurrent=True)
- g(['arb_clear_buffer_object-invalid-size'], run_concurrent=True)
- g(['arb_clear_buffer_object-mapped'], run_concurrent=True)
- g(['arb_clear_buffer_object-no-bound-buffer'], run_concurrent=True)
- g(['arb_clear_buffer_object-null-data'], run_concurrent=True)
- g(['arb_clear_buffer_object-sub-invalid-size'], run_concurrent=True)
- g(['arb_clear_buffer_object-sub-mapped'], run_concurrent=True)
- g(['arb_clear_buffer_object-sub-overlap'], run_concurrent=True)
- g(['arb_clear_buffer_object-sub-simple'], run_concurrent=True)
- g(['arb_clear_buffer_object-zero-size'], run_concurrent=True)
+ g(['arb_clear_buffer_object-formats'])
+ g(['arb_clear_buffer_object-invalid-internal-format'])
+ g(['arb_clear_buffer_object-invalid-size'])
+ g(['arb_clear_buffer_object-mapped'])
+ g(['arb_clear_buffer_object-no-bound-buffer'])
+ g(['arb_clear_buffer_object-null-data'])
+ g(['arb_clear_buffer_object-sub-invalid-size'])
+ g(['arb_clear_buffer_object-sub-mapped'])
+ g(['arb_clear_buffer_object-sub-overlap'])
+ g(['arb_clear_buffer_object-sub-simple'])
+ g(['arb_clear_buffer_object-zero-size'])
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_clear_texture')) as g:
- g(['arb_clear_texture-simple'], run_concurrent=True)
- g(['arb_clear_texture-error'], run_concurrent=True)
- g(['arb_clear_texture-3d'], run_concurrent=True)
- g(['arb_clear_texture-cube'], run_concurrent=True)
- g(['arb_clear_texture-multisample'], run_concurrent=True)
- g(['arb_clear_texture-integer'], run_concurrent=True)
- g(['arb_clear_texture-base-formats'], run_concurrent=True)
- g(['arb_clear_texture-sized-formats'], run_concurrent=True)
- g(['arb_clear_texture-float'], run_concurrent=True)
- g(['arb_clear_texture-rg'], run_concurrent=True)
- g(['arb_clear_texture-depth-stencil'], run_concurrent=True)
- g(['arb_clear_texture-srgb'], run_concurrent=True)
+ g(['arb_clear_texture-simple'])
+ g(['arb_clear_texture-error'])
+ g(['arb_clear_texture-3d'])
+ g(['arb_clear_texture-cube'])
+ g(['arb_clear_texture-multisample'])
+ g(['arb_clear_texture-integer'])
+ g(['arb_clear_texture-base-formats'])
+ g(['arb_clear_texture-sized-formats'])
+ g(['arb_clear_texture-float'])
+ g(['arb_clear_texture-rg'])
+ g(['arb_clear_texture-depth-stencil'])
+ g(['arb_clear_texture-srgb'])
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_copy_buffer')) as g:
g(['copy_buffer_coherency'], run_concurrent=False)
g(['copybuffersubdata'], run_concurrent=False)
- g(['arb_copy_buffer-data-sync'], 'data-sync', run_concurrent=True)
- g(['arb_copy_buffer-dlist'], 'dlist', run_concurrent=True)
- g(['arb_copy_buffer-get'], 'get', run_concurrent=True)
- g(['arb_copy_buffer-negative-bound-zero'], 'negative-bound-zero',
- run_concurrent=True)
- g(['arb_copy_buffer-negative-bounds'], 'negative-bounds',
- run_concurrent=True)
- g(['arb_copy_buffer-negative-mapped'], 'negative-mapped',
- run_concurrent=True)
- g(['arb_copy_buffer-overlap'], 'overlap', run_concurrent=True)
- g(['arb_copy_buffer-targets'], 'targets', run_concurrent=True)
- g(['arb_copy_buffer-subdata-sync'], 'subdata-sync', run_concurrent=True)
+ g(['arb_copy_buffer-data-sync'], 'data-sync')
+ g(['arb_copy_buffer-dlist'], 'dlist')
+ g(['arb_copy_buffer-get'], 'get')
+ g(['arb_copy_buffer-negative-bound-zero'], 'negative-bound-zero')
+ g(['arb_copy_buffer-negative-bounds'], 'negative-bounds')
+ g(['arb_copy_buffer-negative-mapped'], 'negative-mapped')
+ g(['arb_copy_buffer-overlap'], 'overlap')
+ g(['arb_copy_buffer-targets'], 'targets')
+ g(['arb_copy_buffer-subdata-sync'], 'subdata-sync')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_copy_image')) as g:
- g(['arb_copy_image-simple', '--tex-to-tex'], run_concurrent=True)
- g(['arb_copy_image-simple', '--rb-to-tex'], run_concurrent=True)
- g(['arb_copy_image-simple', '--rb-to-rb'], run_concurrent=True)
- g(['arb_copy_image-srgb-copy'], run_concurrent=True)
+ g(['arb_copy_image-simple', '--tex-to-tex'])
+ g(['arb_copy_image-simple', '--rb-to-tex'])
+ g(['arb_copy_image-simple', '--rb-to-rb'])
+ g(['arb_copy_image-srgb-copy'])
g(['arb_copy_image-targets', 'GL_TEXTURE_1D', '32', '1', '1',
'GL_TEXTURE_1D', '32', '1', '1', '11', '0', '0', '5', '0', '0', '14',
- '1', '1'],
- run_concurrent=True)
+ '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_1D', '32', '1', '1',
'GL_TEXTURE_1D_ARRAY', '32', '1', '12', '11', '0', '0', '5', '0', '9',
- '14', '1', '1'],
- run_concurrent=True)
+ '14', '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_1D', '32', '1', '1',
'GL_TEXTURE_2D', '32', '32', '1', '11', '0', '0', '5', '13', '0', '14',
- '1', '1'],
- run_concurrent=True)
+ '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_1D', '32', '1', '1',
'GL_TEXTURE_RECTANGLE', '32', '32', '1', '11', '0', '0', '5', '13',
- '0', '14', '1', '1'],
- run_concurrent=True)
+ '0', '14', '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_1D', '32', '1', '1',
'GL_TEXTURE_2D_ARRAY', '32', '32', '10', '11', '0', '0', '5', '13',
- '4', '14', '1', '1'],
- run_concurrent=True)
+ '4', '14', '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_1D', '32', '1', '1',
'GL_TEXTURE_CUBE_MAP', '32', '32', '6', '11', '0', '0', '5', '13', '4',
- '14', '1', '1'],
- run_concurrent=True)
+ '14', '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_1D', '32', '1', '1',
'GL_TEXTURE_CUBE_MAP_ARRAY', '32', '32', '30', '11', '0', '0', '5',
- '13', '8', '14', '1', '1'],
- run_concurrent=True)
+ '13', '8', '14', '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_1D', '32', '1', '1',
'GL_TEXTURE_3D', '32', '32', '32', '11', '0', '0', '5', '13', '4',
- '14', '1', '1'],
- run_concurrent=True)
+ '14', '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_1D_ARRAY', '32', '1', '12',
'GL_TEXTURE_1D', '32', '1', '1', '11', '0', '7', '5', '0', '0', '14',
- '1', '1'],
- run_concurrent=True)
+ '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_1D_ARRAY', '32', '1', '12',
'GL_TEXTURE_1D_ARRAY', '32', '1', '16', '11', '0', '3', '5', '0', '7',
- '14', '1', '8'],
- run_concurrent=True)
+ '14', '1', '8'])
g(['arb_copy_image-targets', 'GL_TEXTURE_1D_ARRAY', '32', '1', '12',
'GL_TEXTURE_2D', '32', '16', '1', '11', '0', '3', '5', '7', '0', '14',
- '1', '1'],
- run_concurrent=True)
+ '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_1D_ARRAY', '32', '1', '12',
'GL_TEXTURE_RECTANGLE', '32', '16', '1', '11', '0', '3', '5', '7', '0',
- '14', '1', '1'],
- run_concurrent=True)
+ '14', '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_1D_ARRAY', '32', '1', '12',
'GL_TEXTURE_2D_ARRAY', '32', '16', '18', '11', '0', '3', '5', '9', '7',
- '14', '1', '8'],
- run_concurrent=True)
+ '14', '1', '8'])
g(['arb_copy_image-targets', 'GL_TEXTURE_1D_ARRAY', '32', '1', '12',
'GL_TEXTURE_CUBE_MAP', '32', '32', '6', '11', '0', '3', '5', '17', '2',
- '14', '1', '3'],
- run_concurrent=True)
+ '14', '1', '3'])
g(['arb_copy_image-targets', 'GL_TEXTURE_1D_ARRAY', '32', '1', '12',
'GL_TEXTURE_CUBE_MAP_ARRAY', '32', '32', '18', '11', '0', '3', '5',
- '17', '2', '14', '1', '7'],
- run_concurrent=True)
+ '17', '2', '14', '1', '7'])
g(['arb_copy_image-targets', 'GL_TEXTURE_1D_ARRAY', '32', '1', '12',
'GL_TEXTURE_3D', '32', '16', '18', '11', '0', '3', '5', '9', '2', '14',
- '1', '7'],
- run_concurrent=True)
+ '1', '7'])
g(['arb_copy_image-targets', 'GL_TEXTURE_2D', '32', '32', '1',
'GL_TEXTURE_1D', '32', '1', '1', '11', '23', '0', '5', '0', '0', '14',
- '1', '1'],
- run_concurrent=True)
+ '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_2D', '32', '32', '1',
'GL_TEXTURE_1D_ARRAY', '32', '1', '16', '11', '2', '0', '5', '0', '7',
- '14', '1', '1'],
- run_concurrent=True)
+ '14', '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_2D', '32', '32', '1',
'GL_TEXTURE_2D', '32', '16', '1', '11', '12', '0', '5', '7', '0', '14',
- '9', '1'],
- run_concurrent=True)
+ '9', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_2D', '32', '32', '1',
'GL_TEXTURE_RECTANGLE', '32', '16', '1', '11', '12', '0', '5', '7',
- '0', '14', '9', '1'],
- run_concurrent=True)
+ '0', '14', '9', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_2D', '32', '32', '1',
'GL_TEXTURE_2D_ARRAY', '32', '16', '15', '11', '12', '0', '5', '7',
- '12', '14', '8', '1'],
- run_concurrent=True)
+ '12', '14', '8', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_2D', '32', '32', '1',
'GL_TEXTURE_CUBE_MAP', '32', '32', '6', '11', '5', '0', '5', '9', '2',
- '14', '7', '1'],
- run_concurrent=True)
+ '14', '7', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_2D', '32', '32', '1',
'GL_TEXTURE_CUBE_MAP_ARRAY', '32', '32', '18', '11', '5', '0', '5',
- '9', '7', '14', '7', '1'],
- run_concurrent=True)
+ '9', '7', '14', '7', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_2D', '32', '32', '1',
'GL_TEXTURE_3D', '32', '16', '18', '11', '5', '0', '5', '9', '7', '14',
- '7', '1'],
- run_concurrent=True)
+ '7', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_RECTANGLE', '32', '32', '1',
'GL_TEXTURE_1D', '32', '1', '1', '11', '23', '0', '5', '0', '0', '14',
- '1', '1'],
- run_concurrent=True)
+ '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_RECTANGLE', '32', '32', '1',
'GL_TEXTURE_1D_ARRAY', '32', '1', '16', '11', '2', '0', '5', '0', '7',
- '14', '1', '1'],
- run_concurrent=True)
+ '14', '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_RECTANGLE', '32', '32', '1',
'GL_TEXTURE_2D', '32', '16', '1', '11', '12', '0', '5', '7', '0', '14',
- '7', '1'],
- run_concurrent=True)
+ '7', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_RECTANGLE', '32', '32', '1',
'GL_TEXTURE_RECTANGLE', '32', '16', '1', '11', '12', '0', '5', '7',
- '0', '14', '9', '1'],
- run_concurrent=True)
+ '0', '14', '9', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_RECTANGLE', '32', '32', '1',
'GL_TEXTURE_2D_ARRAY', '32', '16', '15', '11', '12', '0', '5', '7',
- '12', '14', '8', '1'],
- run_concurrent=True)
+ '12', '14', '8', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_RECTANGLE', '32', '32', '1',
'GL_TEXTURE_CUBE_MAP', '32', '32', '6', '11', '5', '0', '5', '9', '2',
- '14', '7', '1'],
- run_concurrent=True)
+ '14', '7', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_RECTANGLE', '32', '32', '1',
'GL_TEXTURE_CUBE_MAP_ARRAY', '32', '32', '18', '11', '5', '0', '5',
- '9', '7', '14', '7', '1'],
- run_concurrent=True)
+ '9', '7', '14', '7', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_RECTANGLE', '32', '32', '1',
'GL_TEXTURE_3D', '32', '16', '18', '11', '5', '0', '5', '9', '7', '14',
- '7', '1'],
- run_concurrent=True)
+ '7', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_2D_ARRAY', '32', '32', '15',
'GL_TEXTURE_1D', '32', '1', '1', '11', '23', '7', '5', '0', '0', '14',
- '1', '1'],
- run_concurrent=True)
+ '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_2D_ARRAY', '32', '32', '15',
'GL_TEXTURE_1D_ARRAY', '32', '1', '16', '11', '2', '5', '5', '0', '7',
- '14', '1', '7'],
- run_concurrent=True)
+ '14', '1', '7'])
g(['arb_copy_image-targets', 'GL_TEXTURE_2D_ARRAY', '32', '32', '15',
'GL_TEXTURE_2D', '32', '16', '1', '11', '12', '13', '5', '4', '0',
- '14', '10', '1'],
- run_concurrent=True)
+ '14', '10', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_2D_ARRAY', '32', '32', '15',
'GL_TEXTURE_RECTANGLE', '32', '16', '1', '11', '12', '13', '5', '7',
- '0', '14', '7', '1'],
- run_concurrent=True)
+ '0', '14', '7', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_2D_ARRAY', '32', '32', '15',
'GL_TEXTURE_2D_ARRAY', '32', '16', '15', '11', '12', '5', '5', '7',
- '2', '14', '9', '9'],
- run_concurrent=True)
+ '2', '14', '9', '9'])
g(['arb_copy_image-targets', 'GL_TEXTURE_2D_ARRAY', '32', '32', '15',
'GL_TEXTURE_CUBE_MAP', '32', '32', '6', '11', '5', '1', '5', '9', '2',
- '14', '7', '3'],
- run_concurrent=True)
+ '14', '7', '3'])
g(['arb_copy_image-targets', 'GL_TEXTURE_2D_ARRAY', '32', '32', '15',
'GL_TEXTURE_CUBE_MAP_ARRAY', '32', '32', '18', '11', '5', '2', '5',
- '9', '7', '14', '7', '11'],
- run_concurrent=True)
+ '9', '7', '14', '7', '11'])
g(['arb_copy_image-targets', 'GL_TEXTURE_2D_ARRAY', '32', '32', '15',
'GL_TEXTURE_3D', '32', '16', '18', '11', '5', '2', '5', '9', '7', '14',
- '7', '11'],
- run_concurrent=True)
+ '7', '11'])
g(['arb_copy_image-targets', 'GL_TEXTURE_CUBE_MAP', '32', '32', '6',
'GL_TEXTURE_1D', '32', '1', '1', '11', '23', '3', '5', '0', '0', '14',
- '1', '1'],
- run_concurrent=True)
+ '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_CUBE_MAP', '32', '32', '6',
'GL_TEXTURE_1D_ARRAY', '32', '1', '16', '11', '2', '3', '5', '0', '7',
- '14', '1', '2'],
- run_concurrent=True)
+ '14', '1', '2'])
g(['arb_copy_image-targets', 'GL_TEXTURE_CUBE_MAP', '32', '32', '6',
'GL_TEXTURE_2D', '32', '16', '1', '11', '12', '3', '5', '7', '0', '14',
- '9', '1'],
- run_concurrent=True)
+ '9', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_CUBE_MAP', '32', '32', '6',
'GL_TEXTURE_RECTANGLE', '32', '16', '1', '11', '12', '3', '5', '3',
- '0', '14', '12', '1'],
- run_concurrent=True)
+ '0', '14', '12', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_CUBE_MAP', '32', '32', '6',
'GL_TEXTURE_2D_ARRAY', '32', '16', '15', '11', '12', '1', '5', '3',
- '2', '14', '11', '4'],
- run_concurrent=True)
+ '2', '14', '11', '4'])
g(['arb_copy_image-targets', 'GL_TEXTURE_CUBE_MAP', '32', '32', '6',
'GL_TEXTURE_CUBE_MAP', '32', '32', '6', '11', '5', '1', '5', '9', '2',
- '14', '7', '3'],
- run_concurrent=True)
+ '14', '7', '3'])
g(['arb_copy_image-targets', 'GL_TEXTURE_CUBE_MAP', '32', '32', '6',
'GL_TEXTURE_CUBE_MAP_ARRAY', '32', '32', '18', '11', '5', '1', '5',
- '9', '9', '14', '7', '5'],
- run_concurrent=True)
+ '9', '9', '14', '7', '5'])
g(['arb_copy_image-targets', 'GL_TEXTURE_CUBE_MAP', '32', '32', '6',
'GL_TEXTURE_3D', '32', '16', '18', '11', '5', '0', '5', '9', '7', '14',
- '7', '4'],
- run_concurrent=True)
+ '7', '4'])
g(['arb_copy_image-targets', 'GL_TEXTURE_CUBE_MAP_ARRAY', '32', '32', '18',
'GL_TEXTURE_1D', '32', '1', '1', '11', '23', '7', '5', '0', '0', '14',
- '1', '1'],
- run_concurrent=True)
+ '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_CUBE_MAP_ARRAY', '32', '32', '18',
'GL_TEXTURE_1D_ARRAY', '32', '1', '16', '11', '2', '5', '5', '0', '7',
- '14', '1', '7'],
- run_concurrent=True)
+ '14', '1', '7'])
g(['arb_copy_image-targets', 'GL_TEXTURE_CUBE_MAP_ARRAY', '32', '32', '18',
'GL_TEXTURE_2D', '32', '16', '1', '11', '12', '13', '5', '7', '0',
- '14', '8', '1'],
- run_concurrent=True)
+ '14', '8', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_CUBE_MAP_ARRAY', '32', '32', '18',
'GL_TEXTURE_RECTANGLE', '32', '16', '1', '11', '12', '13', '5', '7',
- '0', '14', '6', '1'],
- run_concurrent=True)
+ '0', '14', '6', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_CUBE_MAP_ARRAY', '32', '32', '18',
'GL_TEXTURE_2D_ARRAY', '32', '16', '15', '11', '12', '5', '5', '1',
- '2', '14', '15', '9'],
- run_concurrent=True)
+ '2', '14', '15', '9'])
g(['arb_copy_image-targets', 'GL_TEXTURE_CUBE_MAP_ARRAY', '32', '32', '18',
'GL_TEXTURE_CUBE_MAP', '16', '16', '6', '11', '5', '1', '5', '9', '2',
- '5', '7', '3'],
- run_concurrent=True)
+ '5', '7', '3'])
g(['arb_copy_image-targets', 'GL_TEXTURE_CUBE_MAP_ARRAY', '32', '32', '18',
'GL_TEXTURE_CUBE_MAP_ARRAY', '16', '16', '18', '11', '5', '2', '5',
- '9', '7', '5', '7', '11'],
- run_concurrent=True)
+ '9', '7', '5', '7', '11'])
g(['arb_copy_image-targets', 'GL_TEXTURE_CUBE_MAP_ARRAY', '32', '32', '18',
'GL_TEXTURE_3D', '32', '16', '18', '11', '5', '2', '5', '9', '7', '14',
- '7', '11'],
- run_concurrent=True)
+ '7', '11'])
g(['arb_copy_image-targets', 'GL_TEXTURE_3D', '32', '32', '17',
'GL_TEXTURE_1D', '32', '1', '1', '11', '23', '7', '5', '0', '0', '14',
- '1', '1'],
- run_concurrent=True)
+ '1', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_3D', '32', '32', '17',
'GL_TEXTURE_1D_ARRAY', '32', '1', '16', '11', '2', '5', '5', '0', '7',
- '14', '1', '7'],
- run_concurrent=True)
+ '14', '1', '7'])
g(['arb_copy_image-targets', 'GL_TEXTURE_3D', '32', '32', '17',
'GL_TEXTURE_2D', '32', '16', '1', '11', '12', '13', '5', '7', '0',
- '14', '7', '1'],
- run_concurrent=True)
+ '14', '7', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_3D', '32', '32', '17',
'GL_TEXTURE_RECTANGLE', '32', '16', '1', '11', '12', '13', '5', '7',
- '0', '14', '9', '1'],
- run_concurrent=True)
+ '0', '14', '9', '1'])
g(['arb_copy_image-targets', 'GL_TEXTURE_3D', '32', '32', '17',
'GL_TEXTURE_2D_ARRAY', '32', '16', '15', '11', '12', '5', '5', '3',
- '2', '14', '13', '9'],
- run_concurrent=True)
+ '2', '14', '13', '9'])
g(['arb_copy_image-targets', 'GL_TEXTURE_3D', '32', '32', '17',
'GL_TEXTURE_CUBE_MAP', '16', '16', '6', '11', '5', '1', '5', '9', '2',
- '5', '7', '3'],
- run_concurrent=True)
+ '5', '7', '3'])
g(['arb_copy_image-targets', 'GL_TEXTURE_3D', '32', '32', '17',
'GL_TEXTURE_CUBE_MAP_ARRAY', '16', '16', '18', '11', '5', '2', '5',
- '9', '7', '5', '7', '11'],
- run_concurrent=True)
+ '9', '7', '5', '7', '11'])
g(['arb_copy_image-targets', 'GL_TEXTURE_3D', '32', '32', '17',
'GL_TEXTURE_3D', '32', '16', '18', '11', '5', '2', '5', '9', '7', '14',
- '7', '11'],
- run_concurrent=True)
- g(['arb_copy_image-formats'], run_concurrent=True)
- g(['arb_copy_image-formats', '--samples=2'], run_concurrent=True)
- g(['arb_copy_image-formats', '--samples=4'], run_concurrent=True)
- g(['arb_copy_image-formats', '--samples=8'], run_concurrent=True)
+ '7', '11'])
+ g(['arb_copy_image-formats'])
+ g(['arb_copy_image-formats', '--samples=2'])
+ g(['arb_copy_image-formats', '--samples=4'])
+ g(['arb_copy_image-formats', '--samples=8'])
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'arb_cull_distance')) as g:
- g(['arb_cull_distance-max-distances'], run_concurrent=True)
+ g(['arb_cull_distance-max-distances'])
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'arb_half_float_vertex')) as g:
@@ -4153,15 +3797,14 @@ with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_vertex_type_2_10_10_10_rev')) as g:
g(['draw-vertices-2101010'], run_concurrent=False)
- g(['attribs', 'GL_ARB_vertex_type_2_10_10_10_rev'], 'attribs',
- run_concurrent=True)
- g(['arb_vertex_type_2_10_10_10_rev-array_types'], run_concurrent=True)
+ g(['attribs', 'GL_ARB_vertex_type_2_10_10_10_rev'], 'attribs')
+ g(['arb_vertex_type_2_10_10_10_rev-array_types'])
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_vertex_type_10f_11f_11f_rev')) as g:
g(['arb_vertex_type_10f_11f_11f_rev-api-errors'], run_concurrent=False)
- g(['arb_vertex_type_10f_11f_11f_rev-draw-vertices'], run_concurrent=True)
+ g(['arb_vertex_type_10f_11f_11f_rev-draw-vertices'])
with profile.group_manager(
PiglitGLTest,
@@ -4198,23 +3841,19 @@ with profile.group_manager(
grouptools.join('spec', 'arb_base_instance')) as g:
g(['arb_base_instance-baseinstance-doesnt-affect-gl-instance-id'],
run_concurrent=False)
- g(['arb_base_instance-drawarrays'], run_concurrent=True)
+ g(['arb_base_instance-drawarrays'])
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_buffer_storage')) as g:
- g(['bufferstorage-persistent', 'draw'], run_concurrent=True)
- g(['bufferstorage-persistent', 'draw', 'coherent'], run_concurrent=True)
- g(['bufferstorage-persistent', 'draw', 'client-storage'],
- run_concurrent=True)
- g(['bufferstorage-persistent', 'draw', 'coherent', 'client-storage'],
- run_concurrent=True)
- g(['bufferstorage-persistent', 'read'], run_concurrent=True)
- g(['bufferstorage-persistent', 'read', 'coherent'], run_concurrent=True)
- g(['bufferstorage-persistent', 'read', 'client-storage'],
- run_concurrent=True)
- g(['bufferstorage-persistent', 'read', 'coherent', 'client-storage'],
- run_concurrent=True)
+ g(['bufferstorage-persistent', 'draw'])
+ g(['bufferstorage-persistent', 'draw', 'coherent'])
+ g(['bufferstorage-persistent', 'draw', 'client-storage'])
+ g(['bufferstorage-persistent', 'draw', 'coherent', 'client-storage'])
+ g(['bufferstorage-persistent', 'read'])
+ g(['bufferstorage-persistent', 'read', 'coherent'])
+ g(['bufferstorage-persistent', 'read', 'client-storage'])
+ g(['bufferstorage-persistent', 'read', 'coherent', 'client-storage'])
with profile.group_manager(
PiglitGLTest,
@@ -4269,35 +3908,29 @@ with profile.group_manager(
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_geometry_shader4')) as g:
- g(['arb_geometry_shader4-program-parameter-input-type'],
- run_concurrent=True)
- g(['arb_geometry_shader4-program-parameter-input-type-draw'],
- run_concurrent=True)
- g(['arb_geometry_shader4-program-parameter-output-type'],
- run_concurrent=True)
- g(['arb_geometry_shader4-vertices-in'], run_concurrent=True)
+ g(['arb_geometry_shader4-program-parameter-input-type'])
+ g(['arb_geometry_shader4-program-parameter-input-type-draw'])
+ g(['arb_geometry_shader4-program-parameter-output-type'])
+ g(['arb_geometry_shader4-vertices-in'])
for draw in ['', 'indexed']:
for prim in ['GL_LINES_ADJACENCY', 'GL_LINE_STRIP_ADJACENCY', 'GL_TRIANGLES_ADJACENCY', 'GL_TRIANGLE_STRIP_ADJACENCY']:
- g(['arb_geometry_shader4-ignore-adjacent-vertices', draw, prim],
- run_concurrent=True)
+ g(['arb_geometry_shader4-ignore-adjacent-vertices', draw, prim])
for mode in ['1', 'tf 1', 'max', 'tf max']:
- g(['arb_geometry_shader4-program-parameter-vertices-out', mode],
- run_concurrent=True)
+ g(['arb_geometry_shader4-program-parameter-vertices-out', mode])
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_compute_shader')) as g:
- g(['arb_compute_shader-api_errors'], 'api_errors', run_concurrent=True)
- g(['arb_compute_shader-minmax'], 'minmax', run_concurrent=True)
+ g(['arb_compute_shader-api_errors'], 'api_errors')
+ g(['arb_compute_shader-minmax'], 'minmax')
g(['built-in-constants',
os.path.join(TESTS_DIR, 'spec', 'arb_compute_shader',
'minimum-maximums.txt')],
- 'built-in constants', run_concurrent=True)
+ 'built-in constants')
g(['arb_compute_shader-work_group_size_too_large'],
- grouptools.join('compiler', 'work_group_size_too_large'),
- run_concurrent=True)
+ grouptools.join('compiler', 'work_group_size_too_large'))
with profile.group_manager(
PiglitGLTest,
@@ -4342,40 +3975,35 @@ with profile.group_manager(PiglitGLTest, 'hiz') as g:
g(['hiz-stencil-test-window-depth1'], run_concurrent=False)
with profile.group_manager(PiglitGLTest, 'fast_color_clear') as g:
- g(['fcc-blit-between-clears'], run_concurrent=True)
+ g(['fcc-blit-between-clears'])
g(['fcc-read-to-pbo-after-clear'], run_concurrent=False)
for subtest in ('sample', 'read_pixels', 'blit', 'copy'):
for buffer_type in ('rb', 'tex'):
if subtest == 'sample' and buffer_type == 'rb':
continue
- g(['fcc-read-after-clear', subtest, buffer_type],
- run_concurrent=True)
+ g(['fcc-read-after-clear', subtest, buffer_type])
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'ext_unpack_subimage')) as g:
- g(['ext_unpack_subimage'], 'basic', run_concurrent=True)
+ g(['ext_unpack_subimage'], 'basic')
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'oes_draw_texture')) as g:
- g(['oes_draw_texture'], run_concurrent=True)
+ g(['oes_draw_texture'])
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'oes_compressed_etc1_rgb8_texture')) as g:
- g(['oes_compressed_etc1_rgb8_texture-basic'], 'basic', run_concurrent=True)
- g(['oes_compressed_etc1_rgb8_texture-miptree'], 'miptree',
- run_concurrent=True)
+ g(['oes_compressed_etc1_rgb8_texture-basic'], 'basic')
+ g(['oes_compressed_etc1_rgb8_texture-miptree'], 'miptree')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'oes_compressed_paletted_texture')) as g:
- g(['oes_compressed_paletted_texture-api'], 'basic API',
- run_concurrent=True)
- g(['arb_texture_compression-invalid-formats', 'paletted'],
- 'invalid formats', run_concurrent=True)
- g(['oes_compressed_paletted_texture-api'], 'basic API',
- run_concurrent=True)
+ g(['oes_compressed_paletted_texture-api'], 'basic API')
+ g(['arb_texture_compression-invalid-formats', 'paletted'], 'invalid formats')
+ g(['oes_compressed_paletted_texture-api'], 'basic API')
with profile.group_manager(
PiglitGLTest,
@@ -4458,7 +4086,7 @@ with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'egl_mesa_configless_context'),
exclude_platforms=['glx']) as g:
- g(['egl-configless-context'], 'basic', run_concurrent=True)
+ g(['egl-configless-context'], 'basic')
with profile.group_manager(
PiglitGLTest,
@@ -4466,38 +4094,35 @@ with profile.group_manager(
exclude_platforms=['glx']) as g:
for i in [1, 2, 3]:
g(['egl_ext_client_extensions', str(i)],
- 'conformance test {0}'.format(i),
- run_concurrent=True)
+ 'conformance test {0}'.format(i))
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'egl_khr_fence_sync'),
exclude_platforms=['glx']) as g:
- g(['egl_khr_fence_sync'], 'conformance', run_concurrent=True)
+ g(['egl_khr_fence_sync'], 'conformance')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'egl_chromium_sync_control'),
exclude_platforms=['glx']) as g:
- g(['egl_chromium_sync_control'], 'conformance', run_concurrent=True)
+ g(['egl_chromium_sync_control'], 'conformance')
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', '!opengl ES 2.0')) as g:
- g(['glsl-fs-pointcoord_gles2'], 'glsl-fs-pointcoord', run_concurrent=True)
- g(['invalid-es3-queries_gles2'], run_concurrent=True)
- g(['link-no-vsfs_gles2'], 'link-no-vsfs', run_concurrent=True)
- g(['minmax_gles2'], run_concurrent=True)
- g(['multiple-shader-objects_gles2'], run_concurrent=True)
- g(['fbo_discard_gles2'], run_concurrent=True)
- g(['draw_buffers_gles2'], run_concurrent=True)
+ g(['glsl-fs-pointcoord_gles2'], 'glsl-fs-pointcoord')
+ g(['invalid-es3-queries_gles2'])
+ g(['link-no-vsfs_gles2'], 'link-no-vsfs')
+ g(['minmax_gles2'])
+ g(['multiple-shader-objects_gles2'])
+ g(['fbo_discard_gles2'])
+ g(['draw_buffers_gles2'])
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', '!opengl ES 3.0')) as g:
- g(['minmax_gles3'], 'minmax', run_concurrent=True)
- g(['texture-immutable-levels_gles3'], 'texture-immutable-levels',
- run_concurrent=True)
- g(['gles-3.0-drawarrays-vertexid'], 'gl_VertexID used with glDrawArrays',
- run_concurrent=True)
+ g(['minmax_gles3'], 'minmax')
+ g(['texture-immutable-levels_gles3'], 'texture-immutable-levels')
+ g(['gles-3.0-drawarrays-vertexid'], 'gl_VertexID used with glDrawArrays')
for test_mode in ['teximage', 'texsubimage']:
g(['ext_texture_array-compressed_gles3', test_mode, '-fbo'],
@@ -4506,121 +4131,87 @@ with profile.group_manager(
for tex_format in ['rgb8', 'srgb8', 'rgba8', 'srgb8-alpha8', 'r11', 'rg11',
'rgb8-punchthrough-alpha1', 'srgb8-punchthrough-alpha1']:
- g(['oes_compressed_etc2_texture-miptree_gles3', tex_format],
- run_concurrent=True)
+ g(['oes_compressed_etc2_texture-miptree_gles3', tex_format])
with profile.group_manager(
PiglitGLTest, grouptools.join('spec', 'arb_es3_compatibility')) as g:
- g(['es3-primrestart-fixedindex'], run_concurrent=True)
- g(['es3-drawarrays-primrestart-fixedindex'], run_concurrent=True)
+ g(['es3-primrestart-fixedindex'])
+ g(['es3-drawarrays-primrestart-fixedindex'])
for tex_format in ['rgb8', 'srgb8', 'rgba8', 'srgb8-alpha8', 'r11', 'rg11',
'rgb8-punchthrough-alpha1', 'srgb8-punchthrough-alpha1']:
for context in ['core', 'compat']:
- g(['oes_compressed_etc2_texture-miptree', tex_format, context],
- run_concurrent=True)
+ g(['oes_compressed_etc2_texture-miptree', tex_format, context])
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_shader_atomic_counters')) as g:
- g(['arb_shader_atomic_counters-active-counters'], 'active-counters',
- run_concurrent=True)
- g(['arb_shader_atomic_counters-array-indexing'], 'array-indexing',
- run_concurrent=True)
- g(['arb_shader_atomic_counters-buffer-binding'], 'buffer-binding',
- run_concurrent=True)
- g(['arb_shader_atomic_counters-default-partition'], 'default-partition',
- run_concurrent=True)
- g(['arb_shader_atomic_counters-fragment-discard'], 'fragment-discard',
- run_concurrent=True)
- g(['arb_shader_atomic_counters-function-argument'], 'function-argument',
- run_concurrent=True)
- g(['arb_shader_atomic_counters-max-counters'], 'max-counters',
- run_concurrent=True)
- g(['arb_shader_atomic_counters-minmax'], 'minmax',
- run_concurrent=True)
- g(['arb_shader_atomic_counters-multiple-defs'], 'multiple-defs',
- run_concurrent=True)
- g(['arb_shader_atomic_counters-semantics'], 'semantics',
- run_concurrent=True)
- g(['arb_shader_atomic_counters-unique-id'], 'unique-id',
- run_concurrent=True)
- g(['arb_shader_atomic_counters-unused-result'], 'unused-result',
- run_concurrent=True)
- g(['arb_shader_atomic_counters-respecify-buffer'], 'respecify-buffer',
- run_concurrent=True)
+ g(['arb_shader_atomic_counters-active-counters'], 'active-counters')
+ g(['arb_shader_atomic_counters-array-indexing'], 'array-indexing')
+ g(['arb_shader_atomic_counters-buffer-binding'], 'buffer-binding')
+ g(['arb_shader_atomic_counters-default-partition'], 'default-partition')
+ g(['arb_shader_atomic_counters-fragment-discard'], 'fragment-discard')
+ g(['arb_shader_atomic_counters-function-argument'], 'function-argument')
+ g(['arb_shader_atomic_counters-max-counters'], 'max-counters')
+ g(['arb_shader_atomic_counters-minmax'], 'minmax')
+ g(['arb_shader_atomic_counters-multiple-defs'], 'multiple-defs')
+ g(['arb_shader_atomic_counters-semantics'], 'semantics')
+ g(['arb_shader_atomic_counters-unique-id'], 'unique-id')
+ g(['arb_shader_atomic_counters-unused-result'], 'unused-result')
+ g(['arb_shader_atomic_counters-respecify-buffer'], 'respecify-buffer')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_direct_state_access')) as g:
- g(['arb_direct_state_access-texturesubimage'], 'texturesubimage',
- run_concurrent=True)
- g(['arb_direct_state_access-bind-texture-unit'], 'bind-texture-unit',
- run_concurrent=True)
- g(['arb_direct_state_access-create-textures'], 'create-textures',
- run_concurrent=True)
- g(['arb_direct_state_access-texture-storage'], 'textures-storage',
- run_concurrent=True)
- g(['arb_direct_state_access-texunits'], 'texunits',
- run_concurrent=True)
- g(['arb_direct_state_access-texture-params'], 'texture-params',
- run_concurrent=True)
- g(['arb_direct_state_access-copytexturesubimage'], 'copytexturesubimage',
- run_concurrent=True)
- g(['arb_direct_state_access-texture-errors'], 'texture-errors',
- run_concurrent=True)
- g(['arb_direct_state_access-get-textures'], 'get-textures',
- run_concurrent=True)
+ g(['arb_direct_state_access-texturesubimage'], 'texturesubimage')
+ g(['arb_direct_state_access-bind-texture-unit'], 'bind-texture-unit')
+ g(['arb_direct_state_access-create-textures'], 'create-textures')
+ g(['arb_direct_state_access-texture-storage'], 'textures-storage')
+ g(['arb_direct_state_access-texunits'], 'texunits')
+ g(['arb_direct_state_access-texture-params'], 'texture-params')
+ g(['arb_direct_state_access-copytexturesubimage'], 'copytexturesubimage')
+ g(['arb_direct_state_access-texture-errors'], 'texture-errors')
+ g(['arb_direct_state_access-get-textures'], 'get-textures')
g(['arb_direct_state_access-gettextureimage-formats'],
- 'gettextureimage-formats', run_concurrent=True)
+ 'gettextureimage-formats')
g(['arb_direct_state_access-gettextureimage-formats init-by-rendering'],
- 'foramts init-by-rendering', run_concurrent=True)
+ 'foramts init-by-rendering')
g(['arb_direct_state_access-gettextureimage-luminance'],
- 'gettextureimage-luminance', run_concurrent=True)
+ 'gettextureimage-luminance')
g(['arb_direct_state_access-gettextureimage-simple'],
- 'gettextureimage-simple', run_concurrent=True)
+ 'gettextureimage-simple')
g(['arb_direct_state_access-gettextureimage-targets'],
- 'gettextureimage-targets', run_concurrent=True)
+ 'gettextureimage-targets')
g(['arb_direct_state_access-compressedtextureimage GL_COMPRESSED_RGBA_FXT1_3DFX'],
- 'compressedtextureimage GL_COMPRESSED_RGBA_FXT1_3DFX',
- run_concurrent=True)
+ 'compressedtextureimage GL_COMPRESSED_RGBA_FXT1_3DFX')
g(['arb_direct_state_access-getcompressedtextureimage'],
- 'getcompressedtextureimage', run_concurrent=True)
+ 'getcompressedtextureimage')
g(['arb_direct_state_access-texture-storage-multisample'],
- 'texture-storage-multisample', run_concurrent=True)
- g(['arb_direct_state_access-texture-buffer'], 'texture-buffer',
- run_concurrent=True)
+ 'texture-storage-multisample')
+ g(['arb_direct_state_access-texture-buffer'], 'texture-buffer')
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_shader_image_load_store')) as g:
- g(['arb_shader_image_load_store-atomicity'], 'atomicity',
- run_concurrent=True)
- g(['arb_shader_image_load_store-bitcast'], 'bitcast', run_concurrent=True)
- g(['arb_shader_image_load_store-coherency'], 'coherency',
- run_concurrent=True)
- g(['arb_shader_image_load_store-dead-fragments'], 'dead-fragments',
- run_concurrent=True)
- g(['arb_shader_image_load_store-early-z'], 'early-z', run_concurrent=True)
- g(['arb_shader_image_load_store-host-mem-barrier'], 'host-mem-barrier',
- run_concurrent=True)
- g(['arb_shader_image_load_store-indexing'], 'indexing', run_concurrent=True)
- g(['arb_shader_image_load_store-invalid'], 'invalid', run_concurrent=True)
- g(['arb_shader_image_load_store-layer'], 'layer', run_concurrent=True)
- g(['arb_shader_image_load_store-level'], 'level', run_concurrent=True)
- g(['arb_shader_image_load_store-max-images'], 'max-images',
- run_concurrent=True)
- g(['arb_shader_image_load_store-max-size'], 'max-size', run_concurrent=True)
- g(['arb_shader_image_load_store-minmax'], 'minmax', run_concurrent=True)
- g(['arb_shader_image_load_store-qualifiers'], 'qualifiers',
- run_concurrent=True)
- g(['arb_shader_image_load_store-restrict'], 'restrict', run_concurrent=True)
- g(['arb_shader_image_load_store-semantics'], 'semantics',
- run_concurrent=True)
- g(['arb_shader_image_load_store-shader-mem-barrier'], 'shader-mem-barrier',
- run_concurrent=True)
- g(['arb_shader_image_load_store-state'], 'state', run_concurrent=True)
- g(['arb_shader_image_load_store-unused'], 'unused', run_concurrent=True)
+ g(['arb_shader_image_load_store-atomicity'], 'atomicity')
+ g(['arb_shader_image_load_store-bitcast'], 'bitcast')
+ g(['arb_shader_image_load_store-coherency'], 'coherency')
+ g(['arb_shader_image_load_store-dead-fragments'], 'dead-fragments')
+ g(['arb_shader_image_load_store-early-z'], 'early-z')
+ g(['arb_shader_image_load_store-host-mem-barrier'], 'host-mem-barrier')
+ g(['arb_shader_image_load_store-indexing'], 'indexing')
+ g(['arb_shader_image_load_store-invalid'], 'invalid')
+ g(['arb_shader_image_load_store-layer'], 'layer')
+ g(['arb_shader_image_load_store-level'], 'level')
+ g(['arb_shader_image_load_store-max-images'], 'max-images')
+ g(['arb_shader_image_load_store-max-size'], 'max-size')
+ g(['arb_shader_image_load_store-minmax'], 'minmax')
+ g(['arb_shader_image_load_store-qualifiers'], 'qualifiers')
+ g(['arb_shader_image_load_store-restrict'], 'restrict')
+ g(['arb_shader_image_load_store-semantics'], 'semantics')
+ g(['arb_shader_image_load_store-shader-mem-barrier'], 'shader-mem-barrier')
+ g(['arb_shader_image_load_store-state'], 'state')
+ g(['arb_shader_image_load_store-unused'], 'unused')
if platform.system() is 'Windows':
# FIXME: Is this correct?
diff --git a/tests/quick.py b/tests/quick.py
index f86bb04..41790c5 100644
--- a/tests/quick.py
+++ b/tests/quick.py
@@ -12,16 +12,13 @@ GleanTest.GLOBAL_PARAMS += ["--quick"]
with profile.group_manager(
PiglitGLTest,
grouptools.join('spec', 'arb_shader_image_load_store')) as g:
- g(['arb_shader_image_load_store-coherency', '--quick'], 'coherency',
- run_concurrent=True)
+ g(['arb_shader_image_load_store-coherency', '--quick'], 'coherency')
g(['arb_shader_image_load_store-host-mem-barrier', '--quick'],
- 'host-mem-barrier', run_concurrent=True)
- g(['arb_shader_image_load_store-max-size', '--quick'], 'max-size',
- run_concurrent=True)
- g(['arb_shader_image_load_store-semantics', '--quick'], 'semantics',
- run_concurrent=True)
+ 'host-mem-barrier')
+ g(['arb_shader_image_load_store-max-size', '--quick'], 'max-size')
+ g(['arb_shader_image_load_store-semantics', '--quick'], 'semantics')
g(['arb_shader_image_load_store-shader-mem-barrier', '--quick'],
- 'shader-mem-barrier', run_concurrent=True)
+ 'shader-mem-barrier')
# These take too long
profile.filter_tests(lambda n, _: '-explosion' not in n)
--
2.3.0
More information about the Piglit
mailing list