def dump(self): from PIL import Image outputprefix = path.join(self._output_dir, path.basename(self._trace_path)) gfxrecon_replay_bin = core.get_option( 'PIGLIT_REPLAY_GFXRECON_REPLAY_BINARY', ('replay', 'gfxrecon-replay_bin'), default='gfxrecon-replay') self._check_version(gfxrecon_replay_bin) if not self._calls: self._calls = [str(self._get_last_frame_call())] gfxrecon_replay_extra_args = core.get_option( 'PIGLIT_REPLAY_GFXRECON_REPLAY_EXTRA_ARGS', ('replay', 'gfxrecon-replay_extra_args'), default='').split() cmd = ([gfxrecon_replay_bin] + gfxrecon_replay_extra_args + ['--screenshots', ','.join(self._calls), '--screenshot-dir', self._output_dir, self._trace_path]) self._run_logged_command(cmd, None) for c in self._calls: bmp = '{}_frame_{}.bmp'.format(path.join(self._output_dir, 'screenshot'), c) outputfile = '{}-{}.png'.format(outputprefix, c) print('Writing: {} to {}'.format(bmp, outputfile)) Image.open(bmp).save(outputfile) os.remove(bmp)
def _deprecated_get(env_, conf_, dep_env=None, dep_conf=('', ''), **kwargs): """Attempt to get deprecated values, then modern vaules. If a deprecated value is found give the user a warning, this uses deqp_get_option internally for both the deprecated and undeprecated paths, but prefers the old version and issues a warning if they are encountered. The old version is looked up unconditionally, if it is not found then the new version will be looked up unconditionally, with the default and requires keywords (which the first will not have). """ val = None if dep_env is not None and dep_conf is not None: val = core.get_option(dep_env, dep_conf) if dep_env is not None and os.environ.get(dep_env) is not None: # see if the old environment variable was set, if it is uses it, # and give a deprecation warning warnings.warn( '{} has been replaced by {} and will be removed. You should ' 'update any scripts using the old environment variable'.format( dep_env, env_)) elif dep_conf != ('', '') and core.PIGLIT_CONFIG.has_option(*dep_conf): warnings.warn( '{} has been replaced by {} and will be removed. You should ' 'update any scripts using the old conf variable'.format( ':'.join(dep_conf), ':'.join(conf_))) return val if val is not None else core.get_option(env_, conf_, **kwargs)
def dump(self): from PIL import Image outputprefix = path.join(self._output_dir, path.basename(self._trace_path)) if not self._calls: # FIXME: The VK_LAYER_LUNARG_screenshot numbers the calls from 0 to # (total-num-calls - 1) while gfxreconstruct does it from 1 to # total-num-calls: # https://github.com/LunarG/gfxreconstruct/issues/284 self._calls = [str(max(-1, self._get_last_frame_call() - 1))] gfxrecon_replay_bin = core.get_option( 'PIGLIT_REPLAY_GFXRECON_REPLAY_BINARY', ('replay', 'gfxrecon-replay_bin'), default='gfxrecon-replay') gfxrecon_replay_extra_args = core.get_option( 'PIGLIT_REPLAY_GFXRECON_REPLAY_EXTRA_ARGS', ('replay', 'gfxrecon-replay_extra_args'), default='').split() cmd = ([gfxrecon_replay_bin] + gfxrecon_replay_extra_args + [self._trace_path]) env = os.environ.copy() env['VK_INSTANCE_LAYERS'] = 'VK_LAYER_LUNARG_screenshot' env['VK_SCREENSHOT_FRAMES'] = ','.join(self._calls) env['VK_SCREENSHOT_DIR'] = self._output_dir self._run_logged_command(cmd, env) for c in self._calls: ppm = '{}.ppm'.format(path.join(self._output_dir, c)) outputfile = '{}-{}.png'.format(outputprefix, c) print('Writing: {} to {}'.format(ppm, outputfile)) Image.open(ppm).save(outputfile) os.remove(ppm)
def test_get_option_required(self, mocker): """core.get_option: dies if a required option cannot be retrieved.""" mocker.patch('framework.core.os.environ', {}, True) with pytest.raises(exceptions.PiglitFatalError): core.get_option('NOT_REAL', ('fake', 'fake'), default='', required=True)
def test_from_default(self): """core.get_option: if env is set it overrides piglit.conf.""" # The mock means that only the first value matters actual = core.get_option('foo', ('foo', 'foo'), default=mock.sentinel.good) assert actual is mock.sentinel.good
def test_from_env(self, env, conf): """core.get_option: if env is set it overrides piglit.conf.""" conf.return_value = mock.sentinel.bad env['TEST'] = mock.sentinel.good # The mock means that only the first value matters actual = core.get_option('TEST', ('foo', 'foo')) assert actual is mock.sentinel.good
def test_from_conf(self, conf): """core.get_option: if env is not set a value is taken from piglit.conf. """ conf.return_value = mock.sentinel # The mock means that these values don't actually matter actual = core.get_option('foo', ('foo', 'foo')) assert actual is mock.sentinel
def _get_last_frame_call(self): cmd_wrapper = self._retrace_cmd[:-1] if cmd_wrapper: apitrace_bin = core.get_option( 'PIGLIT_REPLAY_WINE_APITRACE_BINARY', ('replay', 'wine_apitrace_bin'), default='apitrace') else: apitrace_bin = core.get_option('PIGLIT_REPLAY_APITRACE_BINARY', ('replay', 'apitrace_bin'), default='apitrace') cmd = cmd_wrapper + [ apitrace_bin, 'dump', '--calls=frame', self._trace_path ] ret = subprocess.run(cmd, stdout=subprocess.PIPE) logoutput = '[dump_trace_images] Running: {}\n'.format( ' '.join(cmd)) + ret.stdout.decode(errors='replace') print(logoutput) for l in reversed(ret.stdout.decode(errors='replace').splitlines()): s = l.split(None, 1) if s and s[0].isnumeric(): return int(s[0]) return -1
def _get_last_frame_call(self): gfxrecon_info_bin = core.get_option( 'PIGLIT_REPLAY_GFXRECON_INFO_BINARY', ('replay', 'gfxrecon-info_bin'), default='gfxrecon-info') cmd = [gfxrecon_info_bin, self._trace_path] ret = subprocess.run(cmd, stdout=subprocess.PIPE) lines = ret.stdout.decode(errors='replace').splitlines() print(ret.stdout.decode(errors='replace')) try: frames = re.search(_TOTAL_FRAMES_RE, lines[2]) return int(frames.group(1)) except: return -1
def _get_last_frame_call(self): gfxrecon_info_bin = core.get_option( 'PIGLIT_REPLAY_GFXRECON_INFO_BINARY', ('replay', 'gfxrecon-info_bin'), default='gfxrecon-info') cmd = [gfxrecon_info_bin, self._trace_path] ret = subprocess.run(cmd, stdout=subprocess.PIPE) lines = ret.stdout.decode(errors='replace').splitlines() print(ret.stdout.decode(errors='replace')) if lines: c = lines[0].split(': ', 1) if len(c) > 1 and c[1].isnumeric(): return int(c[1]) return -1
def __init__(self, trace_path, output_dir=None, calls=None, **kwargs): super(APITraceBackend, self).__init__(trace_path, output_dir, calls, **kwargs) extension = path.splitext(self._trace_path)[1] if extension == '.trace': eglretrace_bin = core.get_option('PIGLIT_REPLAY_EGLRETRACE_BINARY', ('replay', 'eglretrace_bin'), default='eglretrace') self._retrace_cmd = [eglretrace_bin] elif extension == '.trace-dxgi': wine_bin = core.get_option('PIGLIT_REPLAY_WINE_BINARY', ('replay', 'wine_bin'), default='wine') wine_d3dretrace_bin = core.get_option( 'PIGLIT_REPLAY_WINE_D3DRETRACE_BINARY', ('replay', 'wine_d3dretrace_bin'), default='d3dretrace') self._retrace_cmd = [wine_bin, wine_d3dretrace_bin] else: raise exceptions.PiglitFatalError( 'Invalid trace_path: "{}" tried to be dumped ' 'by the APITraceBackend.\n'.format(self._trace_path))
def get_mode(): """Return the key value of the correct compressor to use. Try the environment variable PIGLIT_COMPRESSION; then check the PIGLIT_CONFIG section 'core', option 'compression'; finally fall back to DEFAULT. This will raise an UnsupportedCompressionError if there isn't a compressor for that mode. It is the job of the caller to handle this exceptions """ # This is provided as a function rather than a constant because as a # function it can honor changes to the PIGLIT_CONFIG instance, or the # PIGLIT_COMPRESSION environment variable. method = core.get_option('PIGLIT_COMPRESSION', ('core', 'compression'), default=DEFAULT) if method not in COMPRESSORS: raise UnsupportedCompressor(method) return method
Alternatively (or in addition, since environment variables have precedence), one could set: PIGLIT_CTS_GL_BIN -- environment equivalent of [cts_gl]:bin PIGLIT_CTS_GL_EXTRA_ARGS -- environment equivalent of [cts_gl]:extra_args """ import itertools from framework import core from framework.test import deqp __all__ = ['profile'] _CTS_BIN = core.get_option('PIGLIT_CTS_GL_BIN', ('cts_gl', 'bin'), required=True) _EXTRA_ARGS = core.get_option('PIGLIT_CTS_GL_EXTRA_ARGS', ('cts_gl', 'extra_args'), default='').split() class DEQPCTSTest(deqp.DEQPBaseTest): deqp_bin = _CTS_BIN @property def extra_args(self): return super(DEQPCTSTest, self).extra_args + \ [x for x in _EXTRA_ARGS if not x.startswith('--deqp-case')] profile = deqp.make_profile( # pylint: disable=invalid-name itertools.chain(
import os import subprocess from framework import core, grouptools, exceptions from framework import options from framework.profile import TestProfile from framework.test.base import Test, is_crash_returncode, TestRunError __all__ = [ 'DEQPBaseTest', 'gen_caselist_txt', 'iter_deqp_test_cases', 'make_profile', ] _EXTRA_ARGS = core.get_option('PIGLIT_DEQP_EXTRA_ARGS', ('deqp', 'extra_args'), default='').split() def select_source(bin_, filename, mustpass, extra_args): """Return either the mustpass list or the generated list.""" if options.OPTIONS.deqp_mustpass: return gen_mustpass_tests(mustpass) else: return iter_deqp_test_cases( gen_caselist_txt(bin_, filename, extra_args)) def make_profile(test_list, test_class): """Create a TestProfile instance.""" profile = TestProfile() for testname in test_list:
# SOFTWARE. """Piglit integrations for the official Khronos Vulkan CTS. upstream: https://github.com/KhronosGroup/Vulkan-CTS """ import re from framework import core from framework.test import deqp __all__ = ['profile'] # Path to the deqp-gles3 executable. _DEQP_VK_BIN = core.get_option('PIGLIT_DEQP_VK_BIN', ('deqp-vk', 'bin'), required=True) _EXTRA_ARGS = core.get_option('PIGLIT_DEQP_VK_EXTRA_ARGS', ('deqp-vk', 'extra_args'), default='').split() _DEQP_ASSERT = re.compile( r'deqp-vk: external/vulkancts/.*: Assertion `.*\' failed.') class DEQPVKTest(deqp.DEQPBaseTest): """Test representation for Khronos Vulkan CTS.""" timeout = 60 deqp_bin = _DEQP_VK_BIN @property
Alternatively (or in addition, since environment variables have precedence), one could set: PIGLIT_KHR_NOCTX_BIN -- environment equivalent of [khr_noctx]:bin PIGLIT_KHR_NOCTX_EXTRA_ARGS -- environment equivalent of [khr_noctx]:extra_args """ import itertools from framework import core from framework.test import deqp __all__ = ['profile'] _KHR_BIN = core.get_option('PIGLIT_KHR_NOCTX_BIN', ('khr_noctx', 'bin'), required=True) _EXTRA_ARGS = core.get_option('PIGLIT_KHR_NOCTX_EXTRA_ARGS', ('khr_noctx', 'extra_args'), default='').split() class DEQPKHRTest(deqp.DEQPBaseTest): deqp_bin = _KHR_BIN @property def extra_args(self): return super(DEQPKHRTest, self).extra_args + \ [x for x in _EXTRA_ARGS if not x.startswith('--deqp-case')]
import os import subprocess import tempfile try: from lxml import etree except ImportError: import xml.etree.ElementTree as etree from framework import grouptools, backends, core, exceptions from framework import status from framework.profile import TestProfile, Test __all__ = ['profile'] crucible_bin = core.get_option('PIGLIT_CRUCIBLE_BIN', ('crucible', 'bin'), required=True) class CrucibleTest(Test): """Test representation for Crucible""" def __init__(self, case_name): self.__out_xml = tempfile.NamedTemporaryFile(delete=True).name command = [ crucible_bin, 'run', '--junit-xml={}'.format(self.__out_xml), case_name ] self._case = case_name super(CrucibleTest, self).__init__(command) def interpret_result(self): try:
Alternatively (or in addition, since environment variables have precedence), one could set: PIGLIT_KHR_GL_BIN -- environment equivalent of [khr_gl45]:bin PIGLIT_KHR_GL_EXTRA_ARGS -- environment equivalent of [khr_gl45]:extra_args """ import itertools from framework import core from framework.test import deqp from framework.options import OPTIONS __all__ = ['profile'] _KHR_BIN = core.get_option('PIGLIT_KHR_GL_BIN', ('khr_gl45', 'bin'), required=True) _KHR_MUSTPASS = core.get_option('PIGLIT_KHRGL45_MUSTPASS', ('khr_gl45', 'mustpasslist'), required=OPTIONS.deqp_mustpass) _EXTRA_ARGS = core.get_option('PIGLIT_KHR_GL_EXTRA_ARGS', ('khr_gl45', 'extra_args'), default='').split() class DEQPKHRTest(deqp.DEQPBaseTest): deqp_bin = _KHR_BIN @property def extra_args(self): return super(DEQPKHRTest, self).extra_args + \
Alternatively (or in addition, since environment variables have precedence), one could set: PIGLIT_GTF_GLES_BIN -- environment equivalent of [gtf_gles]:bin PIGLIT_GTF_GLES_EXTRA_ARGS -- environment equivalent of [gtf_gles]:extra_args """ import itertools from framework import core from framework.test import deqp __all__ = ['profile'] _GTF_BIN = core.get_option('PIGLIT_GTF_GLES_BIN', ('gtf_gles', 'bin'), required=True) _EXTRA_ARGS = core.get_option('PIGLIT_GTF_GLES_EXTRA_ARGS', ('gtf_gles', 'extra_args'), default='').split() class DEQPGTFTest(deqp.DEQPBaseTest): deqp_bin = _GTF_BIN @property def extra_args(self): return super(DEQPGTFTest, self).extra_args + \ [x for x in _EXTRA_ARGS if not x.startswith('--deqp-case')] # Add all of the suites by default, users can use filters to remove them.
""" import collections from os import path from framework import core, exceptions, grouptools, profile, status from framework.replay import query_traces_yaml as qty from framework.test.base import DummyTest from framework.test.piglit_test import PiglitReplayerTest __all__ = ['profile'] _DESCRIPTION_FILE = core.get_option('PIGLIT_REPLAY_DESCRIPTION_FILE', ('replay', 'description_file'), required=True) _DEVICE_NAME = core.get_option('PIGLIT_REPLAY_DEVICE_NAME', ('replay', 'device_name'), required=True) _EXTRA_ARGS = core.get_option('PIGLIT_REPLAY_EXTRA_ARGS', ('replay', 'extra_args'), default='').split() class ReplayProfile(object): def __init__(self, filename, device_name): try: with open(filename, 'r') as f:
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. """Piglit integrations for dEQP EGL tests.""" from framework import core from framework.test import deqp from framework.options import OPTIONS __all__ = ['profile'] _EGL_BIN = core.get_option('PIGLIT_DEQP_EGL_BIN', ('deqp-egl', 'bin'), required=True) _DEQP_MUSTPASS = core.get_option('PIGLIT_DEQP_EGL_MUSTPASS', ('deqp-egl', 'mustpasslist'), required=OPTIONS.deqp_mustpass) _EXTRA_ARGS = core.get_option('PIGLIT_DEQP_EGL_EXTRA_ARGS', ('deqp-egl', 'extra_args'), default='').split() class DEQPEGLTest(deqp.DEQPBaseTest): deqp_bin = _EGL_BIN @property def extra_args(self):