unittests/framework/test_wflinfo.py

   1 # coding=utf-8
   2 # Copyright (c) 2015-2016, 2019 Intel Corporation
   3
   4 # Permission is hereby granted, free of charge, to any person obtaining a copy
   5 # of this software and associated documentation files (the "Software"), to deal
   6 # in the Software without restriction, including without limitation the rights
   7 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8 # copies of the Software, and to permit persons to whom the Software is
   9 # furnished to do so, subject to the following conditions:
  10
  11 # The above copyright notice and this permission notice shall be included in
  12 # all copies or substantial portions of the Software.
  13
  14 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  20 # SOFTWARE.
  21
  22 """Test the wflinfo module."""
  23
  24 import subprocess
  25 import textwrap
  26 try:
  27     from unittest import mock
  28 except ImportError:
  29     import mock
  30
  31 import pytest
  32
  33 from framework import wflinfo
  34
  35 # pylint: disable=no-self-use,attribute-defined-outside-init,protected-access
  36
  37
  38 def _has_wflinfo():
  39     """Return True if wflinfo is available in PATH."""
  40     try:
  41         subprocess.check_call(['wflinfo', '--help'])
  42     except subprocess.CalledProcessError:
  43         return False
  44     except OSError as e:
  45         if e.errno != 2:
  46             raise
  47         return False
  48     return True
  49
  50
  51 @pytest.mark.skipif(not _has_wflinfo(), reason="Tests require wflinfo binary.")
  52 class TestWflInfo(object):
  53     """Tests for the WflInfo class."""
  54
  55     class TestAttributes(object):
  56         """test for attribute assignments."""
  57
  58         @pytest.fixture(autouse=True)
  59         def patch(self):
  60             """Mock a few things for testing purposes."""
  61             # This is pretty ugly, but as a Borb with a private shared state,
  62             # the only way to test this module is to actually replace the
  63             # shared_state with a mock value so it's reset after each test
  64             with mock.patch.dict('framework.wflinfo.OPTIONS.env',
  65                                  {'PIGLIT_PLATFORM': 'foo'}), \
  66                     mock.patch(
  67                         'framework.wflinfo.WflInfo._WflInfo__shared_state',
  68                         {}):
  69                 yield
  70
  71         def setup(self):
  72             """Setup each instance, patching necissary bits."""
  73             self._test = wflinfo.WflInfo()
  74
  75         def test_extension(self):
  76             """wflinfo.WflInfo.<api>.extensions: Provides list of gl
  77             extensions.
  78             """
  79             rv = textwrap.dedent("""\
  80                 foo
  81                 bar
  82                 boink
  83                 OpenGL version string: 1.1
  84                 OpenGL shading language: 1.1
  85                 OpenGL extensions: GL_foobar GL_ham_sandwhich
  86             """).encode('utf-8')
  87             expected = set(['GL_foobar', 'GL_ham_sandwhich'])
  88
  89             with mock.patch('framework.wflinfo.subprocess.check_output',
  90                             mock.Mock(return_value=rv)):
  91                 assert self._test.compat.extensions == expected
  92
  93         def test_api_version(self):
  94             """wflinfo.WflInfo.<api>.api_version: Provides a version number."""
  95             rv = textwrap.dedent("""\
  96                 Waffle platform: gbm
  97                 Waffle api: gl
  98                 OpenGL vendor string: Intel Open Source Technology Center
  99                 OpenGL renderer string: Mesa DRI Intel(R) Haswell Mobile
 100                 OpenGL context flags: 0x0
 101                 OpenGL shading language: 1.1
 102                 OpenGL extensions: GL_foobar GL_ham_sandwhich
 103                 OpenGL version string: 18 (Compat Profile) Mesa 11.0.4
 104             """).encode('utf-8')
 105             with mock.patch('framework.wflinfo.subprocess.check_output',
 106                             mock.Mock(return_value=rv)):
 107                 assert self._test.compat.api_version == 18.0
 108
 109         def test_api_version_gles(self):
 110             """wflinfo.WflInfo.<es>.api_version: Provides a version number.
 111
 112             The format for GLES is different than for Desktop GL.
 113             """
 114             rv = textwrap.dedent("""\
 115                 Waffle platform: gbm
 116                 Waffle api: gles3
 117                 OpenGL vendor string: Intel Open Source Technology Center
 118                 OpenGL renderer string: Mesa DRI Intel(R) Haswell Mobile
 119                 OpenGL version string: OpenGL ES 7.1 Mesa 11.0.4
 120                 OpenGL shading language: 1.1
 121                 OpenGL extensions: GL_foobar GL_ham_sandwhich
 122             """).encode('utf-8')
 123             with mock.patch('framework.wflinfo.subprocess.check_output',
 124                             mock.Mock(return_value=rv)):
 125                 assert self._test.es2.api_version == 7.1
 126
 127         def test_glsl_version(self):
 128             """wflinfo.WflInfo.<api>.shader_version: Provides a version number."""
 129             rv = textwrap.dedent("""\
 130                 Waffle platform: gbm
 131                 Waffle api: gl
 132                 OpenGL vendor string: Intel Open Source Technology Center
 133                 OpenGL renderer string: Mesa DRI Intel(R) Haswell Mobile
 134                 OpenGL version string: 1.1 (Core Profile) Mesa 11.0.4
 135                 OpenGL context flags: 0x0
 136                 OpenGL shading language version string: 9.30
 137                 OpenGL extensions: this is some extension strings.
 138             """).encode('utf-8')
 139             with mock.patch('framework.wflinfo.subprocess.check_output',
 140                             mock.Mock(return_value=rv)):
 141                 assert self._test.core.shader_version == 9.3
 142
 143         def test_glsl_es_version(self):
 144             """wflinfo.WflInfo.<es>.shader_version: works with gles2."""
 145             rv = textwrap.dedent("""\
 146                 Waffle platform: gbm
 147                 Waffle api: gles2
 148                 Wflinfo vendor string: Intel Open Source Technology Center
 149                 OpenGL renderer string: Mesa DRI Intel(R) Haswell Mobile
 150                 OpenGL version string: OpenGL ES 3.0 Mesa 11.0.4
 151                 OpenGL shading language version string: OpenGL ES GLSL ES 1.0.17
 152                 OpenGL version string: 1.1 (Core Profile) Mesa 11.0.4
 153                 OpenGL extensions: this is some extension strings.
 154             """).encode('utf-8')
 155             with mock.patch('framework.wflinfo.subprocess.check_output',
 156                             mock.Mock(return_value=rv)):
 157                 assert self._test.es2.shader_version == 1.0
 158
 159         def test_gl_version_patch(self):
 160             """wflinfo.WflInfo.*.api_version: Works with patch versions."""
 161             rv = textwrap.dedent("""\
 162                 Waffle platform: gbm
 163                 Waffle api: gl
 164                 OpenGL vendor string: Intel Open Source Technology Center
 165                 OpenGL renderer string: Mesa DRI Intel(R) Haswell Mobile
 166                 OpenGL version string: 18.0.1 (Core Profile) Mesa 11.0.4
 167                 OpenGL shading language version string: OpenGL ES GLSL ES 5.00
 168                 OpenGL extensions: this is some extension strings.
 169                 OpenGL context flags: 0x0
 170             """).encode('utf-8')
 171             with mock.patch('framework.wflinfo.subprocess.check_output',
 172                             mock.Mock(return_value=rv)):
 173                 assert self._test.core.api_version == 18.0
 174
 175         def test_glsl_version_patch(self):
 176             """wflinfo.WflInfo.*.shader_version: Works with patch versions."""
 177             rv = textwrap.dedent("""\
 178                 Waffle platform: gbm
 179                 Waffle api: gl
 180                 OpenGL vendor string: Intel Open Source Technology Center
 181                 OpenGL renderer string: Mesa DRI Intel(R) Haswell Mobile
 182                 OpenGL version string: 1.1 (Core Profile) Mesa 11.0.4
 183                 OpenGL context flags: 0x0
 184                 OpenGL shading language version string: 9.30.7
 185                 OpenGL extensions: this is some extension strings.
 186             """).encode('utf-8')
 187             with mock.patch('framework.wflinfo.subprocess.check_output',
 188                             mock.Mock(return_value=rv)):
 189                 assert self._test.core.shader_version == 9.3
 190
 191         def test_leading_junk(self):
 192             """wflinfo.WflInfo.*.api_version: Handles leading junk."""
 193             rv = textwrap.dedent("""\
 194                 Warning: I'm a big fat warnngs
 195                 Waffle platform: gbm
 196                 Waffle api: gl
 197                 OpenGL vendor string: Intel Open Source Technology Center
 198                 OpenGL renderer string: Mesa DRI Intel(R) Haswell Mobile
 199                 OpenGL version string: 18.0.1 (Core Profile) Mesa 11.0.4
 200                 OpenGL context flags: 0x0
 201                 OpenGL shading language version string: 9.30.7
 202                 OpenGL extensions: ARB_ham_sandwich
 203             """).encode('utf-8')
 204             with mock.patch('framework.wflinfo.subprocess.check_output',
 205                             mock.Mock(return_value=rv)):
 206                 assert self._test.core.api_version == 18.0
 207
 208         def test_mixed_junk(self):
 209             """wflinfo.WflInfo.*.api_version: Handles mixed junk."""
 210             rv = textwrap.dedent("""\
 211                 Waffle platform: gbm
 212                 Waffle api: gl
 213                 Warning: I'm a big fat warnngs
 214                 OpenGL vendor string: Intel Open Source Technology Center
 215                 OpenGL renderer string: Mesa DRI Intel(R) Haswell Mobile
 216                 Warning: I'm a big fat warnngs
 217                 Warning: I'm a big fat warnngs
 218                 OpenGL version string: 18.0.1 (Core Profile) Mesa 11.0.4
 219                 OpenGL context flags: 0x0
 220                 OpenGL shading language version string: 9.30.7
 221                 OpenGL extensions: ARB_ham_sandwich
 222             """).encode('utf-8')
 223             with mock.patch('framework.wflinfo.subprocess.check_output',
 224                             mock.Mock(return_value=rv)):
 225                 assert self._test.core.api_version == 18.0
 226
 227     class TestWAFFLEINFO_GL_ERROR(object):
 228         """Test class for WflInfo when "WFLINFO_GL_ERROR" is returned."""
 229
 230         @pytest.fixture(autouse=True)
 231         def patch(self):
 232             """Setup each instance, patching necissary bits."""
 233             rv = textwrap.dedent("""\
 234                 Waffle platform: glx
 235                 Waffle api: gles3
 236                 OpenGL vendor string: WFLINFO_GL_ERROR
 237                 OpenGL renderer string: Mesa DRI Intel(R) Haswell Mobile
 238                 OpenGL version string: WFLINFO_GL_ERROR
 239                 OpenGL context flags: 0x0\n
 240                 OpenGL shading language version string: WFLINFO_GL_ERROR
 241                 OpenGL extensions: WFLINFO_GL_ERROR
 242             """).encode('utf-8')
 243
 244             with mock.patch.dict('framework.wflinfo.OPTIONS.env',
 245                                  {'PIGLIT_PLATFORM': 'foo'}), \
 246                     mock.patch(
 247                         'framework.wflinfo.subprocess.check_output',
 248                         mock.Mock(return_value=rv)):
 249                 yield
 250
 251         @pytest.fixture(scope='class')
 252         def inst(self):
 253             return wflinfo.WflInfo()
 254
 255         def test_gl_version(self, inst):
 256             """wflinfo.WflInfo.gl_version: handles WFLINFO_GL_ERROR
 257             correctly.
 258             """
 259             assert inst.core.api_version == 0.0
 260
 261         def test_glsl_version(self, inst):
 262             """wflinfo.WflInfo.glsl_version: handles WFLINFO_GL_ERROR
 263             correctly.
 264             """
 265             assert inst.core.shader_version == 0.0
 266
 267         def test_gl_extensions(self, inst):
 268             """wflinfo.WflInfo.gl_extensions: handles WFLINFO_GL_ERROR
 269             correctly.
 270             """
 271             assert inst.core.extensions == set()
 272
 273     class TestOSError(object):
 274         """Tests for the Wflinfo functions to handle OSErrors."""
 275
 276         # pylint: disable=pointless-statement
 277
 278         @pytest.fixture(autouse=True, scope='class')
 279         def patch(self):
 280             """Setup the class, patching as necessary."""
 281             # pylint: disable=bad-continuation
 282             with mock.patch.dict(
 283                     'framework.wflinfo.OPTIONS.env',
 284                     {'PIGLIT_PLATFORM': 'foo'}), \
 285                     mock.patch(
 286                         'framework.wflinfo.subprocess.check_output',
 287                         mock.Mock(side_effect=OSError(2, 'foo'))), \
 288                     mock.patch(
 289                         'framework.wflinfo.WflInfo._WflInfo__shared_state',
 290                         {}):
 291                 yield
 292
 293         @pytest.fixture
 294         def inst(self):
 295             return wflinfo.WflInfo()
 296
 297         def test_gl_extensions(self, inst):
 298             """wflinfo.WflInfo.gl_extensions: Handles OSError "no file"
 299             gracefully.
 300             """
 301             assert inst.core.extensions == set()
 302
 303         def test_gl_version(self, inst):
 304             """wflinfo.WflInfo.get_gl_version: Handles OSError "no file"
 305             graceful.
 306             """
 307             assert inst.core.api_version == 0.0
 308
 309         def test_glsl_version(self, inst):
 310             """wflinfo.WflInfo.glsl_version: Handles OSError "no file"
 311             gracefully.
 312             """
 313             assert inst.core.shader_version == 0.0
 314
 315     class TestCalledProcessError(object):
 316         """Tests for the WflInfo functions to handle OSErrors."""
 317
 318         # pylint: disable=pointless-statement
 319
 320         @pytest.fixture(autouse=True, scope='class')
 321         def patch(self):
 322             """Setup the class, patching as necessary."""
 323             # pylint: disable=bad-continuation
 324             with mock.patch.dict(
 325                     'framework.wflinfo.OPTIONS.env',
 326                     {'PIGLIT_PLATFORM': 'foo'}), \
 327                     mock.patch(
 328                         # pylint: disable=line-too-long
 329                         'framework.wflinfo.subprocess.check_output',
 330                         mock.Mock(side_effect=subprocess.CalledProcessError(1, 'foo'))), \
 331                     mock.patch(
 332                         'framework.wflinfo.WflInfo._WflInfo__shared_state',
 333                         {}):
 334                 yield
 335
 336         @pytest.fixture
 337         def inst(self):
 338             return wflinfo.WflInfo()
 339
 340         def test_gl_extensions(self, inst):
 341             """wflinfo.WflInfo.gl_extensions: Handles CalledProcessError
 342             gracefully.
 343             """
 344             assert inst.core.extensions == set()
 345
 346         def test_gl_version(self, inst):
 347             """wflinfo.WflInfo.get_gl_version: Handles CalledProcessError
 348             gracefully.
 349             """
 350             assert inst.core.api_version == 0.0
 351
 352         def test_glsl_version(self, inst):
 353             """wflinfo.WflInfo.glsl_version: Handles CalledProcessError
 354             gracefully.
 355             """
 356             assert inst.core.shader_version == 0.0