framework/test/opengl.py

   1 # Copyright (c) 2015-2016 Intel Corporation
   2
   3 # Permission is hereby granted, free of charge, to any person obtaining a copy
   4 # of this software and associated documentation files (the "Software"), to deal
   5 # in the Software without restriction, including without limitation the rights
   6 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   7 # copies of the Software, and to permit persons to whom the Software is
   8 # furnished to do so, subject to the following conditions:
   9
  10 # The above copyright notice and this permission notice shall be included in
  11 # all copies or substantial portions of the Software.
  12
  13 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  18 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  19 # SOFTWARE.
  20
  21 """Mixins for OpenGL derived tests."""
  22
  23 from __future__ import (
  24     absolute_import, division, print_function, unicode_literals
  25 )
  26 import os
  27 import warnings
  28
  29 import six
  30
  31 from framework import wflinfo
  32 from .base import TestIsSkip
  33
  34 # pylint: disable=too-few-public-methods
  35
  36 __all__ = [
  37     'FastSkip',
  38     'FastSkipMixin',
  39 ]
  40
  41
  42 class FastSkip(object):
  43     """A class for testing OpenGL requirements.
  44
  45     This class provides a mechanism for testing OpenGL requirements, and
  46     skipping tests that have unmet requirements
  47
  48     This requires wflinfo to be installed and accessible to provide its
  49     functionality, however, it will no-op if wflinfo is not accessible.
  50
  51     The design of this function is conservative. The design goal is that it
  52     it is better to run a few tests that could have been skipped, than to skip
  53     all the tests that could have, but also a few that should have run.
  54
  55     Keyword Arguments:
  56     gl_required     -- This is a set of extensions that are required for
  57                        running the test.
  58     gl_version      -- A float that is the required version number for an
  59                        OpenGL test.
  60     gles_version    -- A float that is the required version number for an
  61                        OpenGL ES test
  62     glsl_version    -- A float that is the required version number of OpenGL
  63                        Shader Language for a test
  64     glsl_es_version -- A float that is the required version number of OpenGL ES
  65                        Shader Language for a test
  66     """
  67     __slots__ = ['gl_required', 'gl_version', 'gles_version', 'glsl_version',
  68                  'glsl_es_version']
  69
  70     info = wflinfo.WflInfo()
  71
  72     def __init__(self, gl_required=None, gl_version=None, gles_version=None,
  73                  glsl_version=None, glsl_es_version=None):
  74         self.gl_required = gl_required or set()
  75         self.gl_version = gl_version
  76         self.gles_version = gles_version
  77         self.glsl_version = glsl_version
  78         self.glsl_es_version = glsl_es_version
  79
  80     def test(self):
  81         """Skip this test if any of its feature requirements are unmet.
  82
  83         If no extensions were calculated (if wflinfo isn't installed) then run
  84         all tests.
  85
  86         Raises:
  87         TestIsSkip   -- if any of the conditions passed to self are false
  88         """
  89         if self.info.gl_extensions:
  90             for extension in self.gl_required:
  91                 if extension not in self.info.gl_extensions:
  92                     raise TestIsSkip(
  93                         'Test requires extension {} '
  94                         'which is not available'.format(extension))
  95
  96         # TODO: Be able to handle any operator
  97         if (self.info.gl_version is not None
  98                 and self.gl_version is not None
  99                 and self.gl_version > self.info.gl_version):
 100             raise TestIsSkip(
 101                 'Test requires OpenGL version {}, '
 102                 'but only {} is available'.format(
 103                     self.gl_version, self.info.gl_version))
 104
 105         # TODO: Be able to handle any operator
 106         if (self.info.gles_version is not None
 107                 and self.gles_version is not None
 108                 and self.gles_version > self.info.gles_version):
 109             raise TestIsSkip(
 110                 'Test requires OpenGL ES version {}, '
 111                 'but only {} is available'.format(
 112                     self.gles_version, self.info.gles_version))
 113
 114         # TODO: Be able to handle any operator
 115         if (self.info.glsl_version is not None
 116                 and self.glsl_version is not None
 117                 and self.glsl_version > self.info.glsl_version):
 118             raise TestIsSkip(
 119                 'Test requires OpenGL Shader Language version {}, '
 120                 'but only {} is available'.format(
 121                     self.glsl_version, self.info.glsl_version))
 122
 123         # TODO: Be able to handle any operator
 124         if (self.info.glsl_es_version is not None
 125                 and self.glsl_es_version is not None
 126                 and self.glsl_es_version > self.info.glsl_es_version):
 127             raise TestIsSkip(
 128                 'Test requires OpenGL ES Shader Language version {}, '
 129                 'but only {} is available'.format(
 130                     self.glsl_es_version, self.info.glsl_es_version))
 131
 132
 133 class FastSkipMixin(object):
 134     """Fast test skipping for OpenGL based suites.
 135
 136     This provides an is_skip() method which will skip the test if any of its
 137     requirements are not met.
 138
 139     This is a wrapper around the FastSkip object which makes it easier to
 140     integrate into existing classes (and maintains API compatibility). It thus
 141     has all of the same requirements as that class.
 142
 143     It also provides new attributes:
 144     gl_required     -- This is a set of extensions that are required for
 145                        running the test.
 146     gl_version      -- A float that is the required version number for an
 147                        OpenGL test.
 148     gles_version    -- A float that is the required version number for an
 149                        OpenGL ES test
 150     glsl_version    -- A float that is the required version number of OpenGL
 151                        Shader Language for a test
 152     glsl_es_version -- A float that is the required version number of OpenGL ES
 153                        Shader Language for a test
 154     """
 155
 156     def __init__(self, command, gl_required=None, gl_version=None,
 157                  gles_version=None, glsl_version=None, glsl_es_version=None,
 158                  **kwargs):  # pylint: disable=too-many-arguments
 159         super(FastSkipMixin, self).__init__(command, **kwargs)
 160         self.__skiper = FastSkip(gl_required=gl_required,
 161                                  gl_version=gl_version,
 162                                  gles_version=gles_version,
 163                                  glsl_version=glsl_version,
 164                                  glsl_es_version=glsl_es_version)
 165
 166     @property
 167     def gl_required(self):
 168         return self.__skiper.gl_required
 169
 170     @gl_required.setter
 171     def gl_required(self, new):
 172         self.__skiper.gl_required = new
 173
 174     @property
 175     def gl_version(self):
 176         return self.__skiper.gl_version
 177
 178     @gl_version.setter
 179     def gl_version(self, new):
 180         self.__skiper.gl_version = new
 181
 182     @property
 183     def gles_version(self):
 184         return self.__skiper.gles_version
 185
 186     @gles_version.setter
 187     def gles_version(self, new):
 188         self.__skiper.gles_version = new
 189
 190     @property
 191     def glsl_version(self):
 192         return self.__skiper.glsl_version
 193
 194     @glsl_version.setter
 195     def glsl_version(self, new):
 196         self.__skiper.glsl_version = new
 197
 198     @property
 199     def glsl_es_version(self):
 200         return self.__skiper.glsl_es_version
 201
 202     @glsl_es_version.setter
 203     def glsl_es_version(self, new):
 204         self.__skiper.glsl_es_version = new
 205
 206     def is_skip(self):
 207         """Skip this test if any of its feature requirements are unmet.
 208
 209         If no extensions were calculated (if wflinfo isn't installed) then run
 210         all tests.
 211         """
 212         self.__skiper.test()
 213
 214         super(FastSkipMixin, self).is_skip()
 215
 216
 217 class FastSkipDisabled(object):
 218     """A no-op version of FastSkip."""
 219
 220     __slots__ = ['gl_required', 'gl_version', 'gles_version', 'glsl_version',
 221                  'glsl_es_version']
 222
 223     def __init__(self, gl_required=None, gl_version=None, gles_version=None,
 224                  glsl_version=None, glsl_es_version=None):
 225         self.gl_required = gl_required or set()
 226         self.gl_version = gl_version
 227         self.gles_version = gles_version
 228         self.glsl_version = glsl_version
 229         self.glsl_es_version = glsl_es_version
 230
 231     def test(self):
 232         pass
 233
 234
 235 class FastSkipMixinDisabled(object):
 236     def __init__(self, command, gl_required=None, gl_version=None,
 237                  gles_version=None, glsl_version=None, glsl_es_version=None,
 238                  **kwargs):  # pylint: disable=too-many-arguments
 239         # Tests that implement the FastSkipMixin expect to have these values
 240         # set, so just fill them in with the default values.
 241         self.gl_required = set()
 242         self.gl_version = None
 243         self.gles_version = None
 244         self.glsl_version = None
 245         self.glsl_es_version = None
 246
 247         super(FastSkipMixinDisabled, self).__init__(command, **kwargs)
 248
 249
 250 # Shadow the real FastSkipMixin with the Disabled version if
 251 # PIGLIT_NO_FAST_SKIP is truthy
 252 if bool(os.environ.get('PIGLIT_NO_FAST_SKIP', False)):
 253     warnings.warn('Fast Skipping Disabled')
 254     # TODO: we can probably get rid of the FastSkipMixinDisabled and just rely
 255     # on the FastSkipDisabled
 256     # pylint: disable=invalid-name
 257     FastSkipMixin = FastSkipMixinDisabled
 258     FastSkip = FastSkipDisabled