mirror of
https://github.com/KhronosGroup/SPIRV-Tools
synced 2024-10-19 11:30:15 +00:00
07f80c4df1
Updated script to work with python3 and python2. Added required tools. We added a section to the readme to mention the tools that are needed to build and test spirv-tools. For the compiler, the compilers used by the bots are mentioned. The bots have been changed. The windows bots will not use python 3.6 for testing. The other bots will still use python 2.7. Both Python2 and Python3 will be tested. Fixes #2407. Fixes #1856.
681 lines
26 KiB
Python
Executable File
681 lines
26 KiB
Python
Executable File
# Copyright (c) 2018 Google LLC
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
"""A number of common spirv result checks coded in mixin classes.
|
|
|
|
A test case can use these checks by declaring their enclosing mixin classes
|
|
as superclass and providing the expected_* variables required by the check_*()
|
|
methods in the mixin classes.
|
|
"""
|
|
import difflib
|
|
import functools
|
|
import os
|
|
import re
|
|
import subprocess
|
|
import traceback
|
|
from spirv_test_framework import SpirvTest
|
|
from builtins import bytes
|
|
|
|
def convert_to_unix_line_endings(source):
|
|
"""Converts all line endings in source to be unix line endings."""
|
|
result = source.replace('\r\n', '\n').replace('\r', '\n')
|
|
return result
|
|
|
|
|
|
def substitute_file_extension(filename, extension):
|
|
"""Substitutes file extension, respecting known shader extensions.
|
|
|
|
foo.vert -> foo.vert.[extension] [similarly for .frag, .comp, etc.]
|
|
foo.glsl -> foo.[extension]
|
|
foo.unknown -> foo.[extension]
|
|
foo -> foo.[extension]
|
|
"""
|
|
if filename[-5:] not in [
|
|
'.vert', '.frag', '.tesc', '.tese', '.geom', '.comp', '.spvasm'
|
|
]:
|
|
return filename.rsplit('.', 1)[0] + '.' + extension
|
|
else:
|
|
return filename + '.' + extension
|
|
|
|
|
|
def get_object_filename(source_filename):
|
|
"""Gets the object filename for the given source file."""
|
|
return substitute_file_extension(source_filename, 'spv')
|
|
|
|
|
|
def get_assembly_filename(source_filename):
|
|
"""Gets the assembly filename for the given source file."""
|
|
return substitute_file_extension(source_filename, 'spvasm')
|
|
|
|
|
|
def verify_file_non_empty(filename):
|
|
"""Checks that a given file exists and is not empty."""
|
|
if not os.path.isfile(filename):
|
|
return False, 'Cannot find file: ' + filename
|
|
if not os.path.getsize(filename):
|
|
return False, 'Empty file: ' + filename
|
|
return True, ''
|
|
|
|
|
|
class ReturnCodeIsZero(SpirvTest):
|
|
"""Mixin class for checking that the return code is zero."""
|
|
|
|
def check_return_code_is_zero(self, status):
|
|
if status.returncode:
|
|
return False, 'Non-zero return code: {ret}\n'.format(
|
|
ret=status.returncode)
|
|
return True, ''
|
|
|
|
|
|
class NoOutputOnStdout(SpirvTest):
|
|
"""Mixin class for checking that there is no output on stdout."""
|
|
|
|
def check_no_output_on_stdout(self, status):
|
|
if status.stdout:
|
|
return False, 'Non empty stdout: {out}\n'.format(out=status.stdout)
|
|
return True, ''
|
|
|
|
|
|
class NoOutputOnStderr(SpirvTest):
|
|
"""Mixin class for checking that there is no output on stderr."""
|
|
|
|
def check_no_output_on_stderr(self, status):
|
|
if status.stderr:
|
|
return False, 'Non empty stderr: {err}\n'.format(err=status.stderr)
|
|
return True, ''
|
|
|
|
|
|
class SuccessfulReturn(ReturnCodeIsZero, NoOutputOnStdout, NoOutputOnStderr):
|
|
"""Mixin class for checking that return code is zero and no output on
|
|
stdout and stderr."""
|
|
pass
|
|
|
|
|
|
class NoGeneratedFiles(SpirvTest):
|
|
"""Mixin class for checking that there is no file generated."""
|
|
|
|
def check_no_generated_files(self, status):
|
|
all_files = os.listdir(status.directory)
|
|
input_files = status.input_filenames
|
|
if all([f.startswith(status.directory) for f in input_files]):
|
|
all_files = [os.path.join(status.directory, f) for f in all_files]
|
|
generated_files = set(all_files) - set(input_files)
|
|
if len(generated_files) == 0:
|
|
return True, ''
|
|
else:
|
|
return False, 'Extra files generated: {}'.format(generated_files)
|
|
|
|
|
|
class CorrectBinaryLengthAndPreamble(SpirvTest):
|
|
"""Provides methods for verifying preamble for a SPIR-V binary."""
|
|
|
|
def verify_binary_length_and_header(self, binary, spv_version=0x10000):
|
|
"""Checks that the given SPIR-V binary has valid length and header.
|
|
|
|
Returns:
|
|
False, error string if anything is invalid
|
|
True, '' otherwise
|
|
Args:
|
|
binary: a bytes object containing the SPIR-V binary
|
|
spv_version: target SPIR-V version number, with same encoding
|
|
as the version word in a SPIR-V header.
|
|
"""
|
|
|
|
def read_word(binary, index, little_endian):
|
|
"""Reads the index-th word from the given binary file."""
|
|
word = binary[index * 4:(index + 1) * 4]
|
|
if little_endian:
|
|
word = reversed(word)
|
|
return functools.reduce(lambda w, b: (w << 8) | b, word, 0)
|
|
|
|
def check_endianness(binary):
|
|
"""Checks the endianness of the given SPIR-V binary.
|
|
|
|
Returns:
|
|
True if it's little endian, False if it's big endian.
|
|
None if magic number is wrong.
|
|
"""
|
|
first_word = read_word(binary, 0, True)
|
|
if first_word == 0x07230203:
|
|
return True
|
|
first_word = read_word(binary, 0, False)
|
|
if first_word == 0x07230203:
|
|
return False
|
|
return None
|
|
|
|
num_bytes = len(binary)
|
|
if num_bytes % 4 != 0:
|
|
return False, ('Incorrect SPV binary: size should be a multiple'
|
|
' of words')
|
|
if num_bytes < 20:
|
|
return False, 'Incorrect SPV binary: size less than 5 words'
|
|
|
|
preamble = binary[0:19]
|
|
little_endian = check_endianness(preamble)
|
|
# SPIR-V module magic number
|
|
if little_endian is None:
|
|
return False, 'Incorrect SPV binary: wrong magic number'
|
|
|
|
# SPIR-V version number
|
|
version = read_word(preamble, 1, little_endian)
|
|
# TODO(dneto): Recent Glslang uses version word 0 for opengl_compat
|
|
# profile
|
|
|
|
if version != spv_version and version != 0:
|
|
return False, 'Incorrect SPV binary: wrong version number'
|
|
# Shaderc-over-Glslang (0x000d....) or
|
|
# SPIRV-Tools (0x0007....) generator number
|
|
if read_word(preamble, 2, little_endian) != 0x000d0007 and \
|
|
read_word(preamble, 2, little_endian) != 0x00070000:
|
|
return False, ('Incorrect SPV binary: wrong generator magic ' 'number')
|
|
# reserved for instruction schema
|
|
if read_word(preamble, 4, little_endian) != 0:
|
|
return False, 'Incorrect SPV binary: the 5th byte should be 0'
|
|
|
|
return True, ''
|
|
|
|
|
|
class CorrectObjectFilePreamble(CorrectBinaryLengthAndPreamble):
|
|
"""Provides methods for verifying preamble for a SPV object file."""
|
|
|
|
def verify_object_file_preamble(self, filename, spv_version=0x10000):
|
|
"""Checks that the given SPIR-V binary file has correct preamble."""
|
|
|
|
success, message = verify_file_non_empty(filename)
|
|
if not success:
|
|
return False, message
|
|
|
|
with open(filename, 'rb') as object_file:
|
|
object_file.seek(0, os.SEEK_END)
|
|
num_bytes = object_file.tell()
|
|
|
|
object_file.seek(0)
|
|
|
|
binary = bytes(object_file.read())
|
|
return self.verify_binary_length_and_header(binary, spv_version)
|
|
|
|
return True, ''
|
|
|
|
|
|
class CorrectAssemblyFilePreamble(SpirvTest):
|
|
"""Provides methods for verifying preamble for a SPV assembly file."""
|
|
|
|
def verify_assembly_file_preamble(self, filename):
|
|
success, message = verify_file_non_empty(filename)
|
|
if not success:
|
|
return False, message
|
|
|
|
with open(filename) as assembly_file:
|
|
line1 = assembly_file.readline()
|
|
line2 = assembly_file.readline()
|
|
line3 = assembly_file.readline()
|
|
|
|
if (line1 != '; SPIR-V\n' or line2 != '; Version: 1.0\n' or
|
|
(not line3.startswith('; Generator: Google Shaderc over Glslang;'))):
|
|
return False, 'Incorrect SPV assembly'
|
|
|
|
return True, ''
|
|
|
|
|
|
class ValidObjectFile(SuccessfulReturn, CorrectObjectFilePreamble):
|
|
"""Mixin class for checking that every input file generates a valid SPIR-V 1.0
|
|
object file following the object file naming rule, and there is no output on
|
|
stdout/stderr."""
|
|
|
|
def check_object_file_preamble(self, status):
|
|
for input_filename in status.input_filenames:
|
|
object_filename = get_object_filename(input_filename)
|
|
success, message = self.verify_object_file_preamble(
|
|
os.path.join(status.directory, object_filename))
|
|
if not success:
|
|
return False, message
|
|
return True, ''
|
|
|
|
|
|
class ValidObjectFile1_3(ReturnCodeIsZero, CorrectObjectFilePreamble):
|
|
"""Mixin class for checking that every input file generates a valid SPIR-V 1.3
|
|
object file following the object file naming rule, and there is no output on
|
|
stdout/stderr."""
|
|
|
|
def check_object_file_preamble(self, status):
|
|
for input_filename in status.input_filenames:
|
|
object_filename = get_object_filename(input_filename)
|
|
success, message = self.verify_object_file_preamble(
|
|
os.path.join(status.directory, object_filename), 0x10300)
|
|
if not success:
|
|
return False, message
|
|
return True, ''
|
|
|
|
|
|
class ValidObjectFileWithAssemblySubstr(SuccessfulReturn,
|
|
CorrectObjectFilePreamble):
|
|
"""Mixin class for checking that every input file generates a valid object
|
|
|
|
file following the object file naming rule, there is no output on
|
|
stdout/stderr, and the disassmbly contains a specified substring per
|
|
input.
|
|
"""
|
|
|
|
def check_object_file_disassembly(self, status):
|
|
for an_input in status.inputs:
|
|
object_filename = get_object_filename(an_input.filename)
|
|
obj_file = str(os.path.join(status.directory, object_filename))
|
|
success, message = self.verify_object_file_preamble(obj_file)
|
|
if not success:
|
|
return False, message
|
|
cmd = [status.test_manager.disassembler_path, '--no-color', obj_file]
|
|
process = subprocess.Popen(
|
|
args=cmd,
|
|
stdin=subprocess.PIPE,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE,
|
|
cwd=status.directory)
|
|
output = process.communicate(None)
|
|
disassembly = output[0]
|
|
if not isinstance(an_input.assembly_substr, str):
|
|
return False, 'Missing assembly_substr member'
|
|
if an_input.assembly_substr not in disassembly:
|
|
return False, ('Incorrect disassembly output:\n{asm}\n'
|
|
'Expected substring not found:\n{exp}'.format(
|
|
asm=disassembly, exp=an_input.assembly_substr))
|
|
return True, ''
|
|
|
|
|
|
class ValidNamedObjectFile(SuccessfulReturn, CorrectObjectFilePreamble):
|
|
"""Mixin class for checking that a list of object files with the given
|
|
names are correctly generated, and there is no output on stdout/stderr.
|
|
|
|
To mix in this class, subclasses need to provide expected_object_filenames
|
|
as the expected object filenames.
|
|
"""
|
|
|
|
def check_object_file_preamble(self, status):
|
|
for object_filename in self.expected_object_filenames:
|
|
success, message = self.verify_object_file_preamble(
|
|
os.path.join(status.directory, object_filename))
|
|
if not success:
|
|
return False, message
|
|
return True, ''
|
|
|
|
|
|
class ValidFileContents(SpirvTest):
|
|
"""Mixin class to test that a specific file contains specific text
|
|
To mix in this class, subclasses need to provide expected_file_contents as
|
|
the contents of the file and target_filename to determine the location."""
|
|
|
|
def check_file(self, status):
|
|
target_filename = os.path.join(status.directory, self.target_filename)
|
|
if not os.path.isfile(target_filename):
|
|
return False, 'Cannot find file: ' + target_filename
|
|
with open(target_filename, 'r') as target_file:
|
|
file_contents = target_file.read()
|
|
if isinstance(self.expected_file_contents, str):
|
|
if file_contents == self.expected_file_contents:
|
|
return True, ''
|
|
return False, ('Incorrect file output: \n{act}\n'
|
|
'Expected:\n{exp}'
|
|
'With diff:\n{diff}'.format(
|
|
act=file_contents,
|
|
exp=self.expected_file_contents,
|
|
diff='\n'.join(
|
|
list(
|
|
difflib.unified_diff(
|
|
self.expected_file_contents.split('\n'),
|
|
file_contents.split('\n'),
|
|
fromfile='expected_output',
|
|
tofile='actual_output')))))
|
|
elif isinstance(self.expected_file_contents, type(re.compile(''))):
|
|
if self.expected_file_contents.search(file_contents):
|
|
return True, ''
|
|
return False, ('Incorrect file output: \n{act}\n'
|
|
'Expected matching regex pattern:\n{exp}'.format(
|
|
act=file_contents,
|
|
exp=self.expected_file_contents.pattern))
|
|
return False, (
|
|
'Could not open target file ' + target_filename + ' for reading')
|
|
|
|
|
|
class ValidAssemblyFile(SuccessfulReturn, CorrectAssemblyFilePreamble):
|
|
"""Mixin class for checking that every input file generates a valid assembly
|
|
file following the assembly file naming rule, and there is no output on
|
|
stdout/stderr."""
|
|
|
|
def check_assembly_file_preamble(self, status):
|
|
for input_filename in status.input_filenames:
|
|
assembly_filename = get_assembly_filename(input_filename)
|
|
success, message = self.verify_assembly_file_preamble(
|
|
os.path.join(status.directory, assembly_filename))
|
|
if not success:
|
|
return False, message
|
|
return True, ''
|
|
|
|
|
|
class ValidAssemblyFileWithSubstr(ValidAssemblyFile):
|
|
"""Mixin class for checking that every input file generates a valid assembly
|
|
file following the assembly file naming rule, there is no output on
|
|
stdout/stderr, and all assembly files have the given substring specified
|
|
by expected_assembly_substr.
|
|
|
|
To mix in this class, subclasses need to provde expected_assembly_substr
|
|
as the expected substring.
|
|
"""
|
|
|
|
def check_assembly_with_substr(self, status):
|
|
for input_filename in status.input_filenames:
|
|
assembly_filename = get_assembly_filename(input_filename)
|
|
success, message = self.verify_assembly_file_preamble(
|
|
os.path.join(status.directory, assembly_filename))
|
|
if not success:
|
|
return False, message
|
|
with open(assembly_filename, 'r') as f:
|
|
content = f.read()
|
|
if self.expected_assembly_substr not in convert_to_unix_line_endings(
|
|
content):
|
|
return False, ('Incorrect assembly output:\n{asm}\n'
|
|
'Expected substring not found:\n{exp}'.format(
|
|
asm=content, exp=self.expected_assembly_substr))
|
|
return True, ''
|
|
|
|
|
|
class ValidAssemblyFileWithoutSubstr(ValidAssemblyFile):
|
|
"""Mixin class for checking that every input file generates a valid assembly
|
|
file following the assembly file naming rule, there is no output on
|
|
stdout/stderr, and no assembly files have the given substring specified
|
|
by unexpected_assembly_substr.
|
|
|
|
To mix in this class, subclasses need to provde unexpected_assembly_substr
|
|
as the substring we expect not to see.
|
|
"""
|
|
|
|
def check_assembly_for_substr(self, status):
|
|
for input_filename in status.input_filenames:
|
|
assembly_filename = get_assembly_filename(input_filename)
|
|
success, message = self.verify_assembly_file_preamble(
|
|
os.path.join(status.directory, assembly_filename))
|
|
if not success:
|
|
return False, message
|
|
with open(assembly_filename, 'r') as f:
|
|
content = f.read()
|
|
if self.unexpected_assembly_substr in convert_to_unix_line_endings(
|
|
content):
|
|
return False, ('Incorrect assembly output:\n{asm}\n'
|
|
'Unexpected substring found:\n{unexp}'.format(
|
|
asm=content, exp=self.unexpected_assembly_substr))
|
|
return True, ''
|
|
|
|
|
|
class ValidNamedAssemblyFile(SuccessfulReturn, CorrectAssemblyFilePreamble):
|
|
"""Mixin class for checking that a list of assembly files with the given
|
|
names are correctly generated, and there is no output on stdout/stderr.
|
|
|
|
To mix in this class, subclasses need to provide expected_assembly_filenames
|
|
as the expected assembly filenames.
|
|
"""
|
|
|
|
def check_object_file_preamble(self, status):
|
|
for assembly_filename in self.expected_assembly_filenames:
|
|
success, message = self.verify_assembly_file_preamble(
|
|
os.path.join(status.directory, assembly_filename))
|
|
if not success:
|
|
return False, message
|
|
return True, ''
|
|
|
|
|
|
class ErrorMessage(SpirvTest):
|
|
"""Mixin class for tests that fail with a specific error message.
|
|
|
|
To mix in this class, subclasses need to provide expected_error as the
|
|
expected error message.
|
|
|
|
The test should fail if the subprocess was terminated by a signal.
|
|
"""
|
|
|
|
def check_has_error_message(self, status):
|
|
if not status.returncode:
|
|
return False, ('Expected error message, but returned success from '
|
|
'command execution')
|
|
if status.returncode < 0:
|
|
# On Unix, a negative value -N for Popen.returncode indicates
|
|
# termination by signal N.
|
|
# https://docs.python.org/2/library/subprocess.html
|
|
return False, ('Expected error message, but command was terminated by '
|
|
'signal ' + str(status.returncode))
|
|
if not status.stderr:
|
|
return False, 'Expected error message, but no output on stderr'
|
|
if self.expected_error != convert_to_unix_line_endings(status.stderr):
|
|
return False, ('Incorrect stderr output:\n{act}\n'
|
|
'Expected:\n{exp}'.format(
|
|
act=status.stderr, exp=self.expected_error))
|
|
return True, ''
|
|
|
|
|
|
class ErrorMessageSubstr(SpirvTest):
|
|
"""Mixin class for tests that fail with a specific substring in the error
|
|
message.
|
|
|
|
To mix in this class, subclasses need to provide expected_error_substr as
|
|
the expected error message substring.
|
|
|
|
The test should fail if the subprocess was terminated by a signal.
|
|
"""
|
|
|
|
def check_has_error_message_as_substring(self, status):
|
|
if not status.returncode:
|
|
return False, ('Expected error message, but returned success from '
|
|
'command execution')
|
|
if status.returncode < 0:
|
|
# On Unix, a negative value -N for Popen.returncode indicates
|
|
# termination by signal N.
|
|
# https://docs.python.org/2/library/subprocess.html
|
|
return False, ('Expected error message, but command was terminated by '
|
|
'signal ' + str(status.returncode))
|
|
if not status.stderr:
|
|
return False, 'Expected error message, but no output on stderr'
|
|
if self.expected_error_substr not in convert_to_unix_line_endings(
|
|
status.stderr.decode('utf8')):
|
|
return False, ('Incorrect stderr output:\n{act}\n'
|
|
'Expected substring not found in stderr:\n{exp}'.format(
|
|
act=status.stderr, exp=self.expected_error_substr))
|
|
return True, ''
|
|
|
|
|
|
class WarningMessage(SpirvTest):
|
|
"""Mixin class for tests that succeed but have a specific warning message.
|
|
|
|
To mix in this class, subclasses need to provide expected_warning as the
|
|
expected warning message.
|
|
"""
|
|
|
|
def check_has_warning_message(self, status):
|
|
if status.returncode:
|
|
return False, ('Expected warning message, but returned failure from'
|
|
' command execution')
|
|
if not status.stderr:
|
|
return False, 'Expected warning message, but no output on stderr'
|
|
if self.expected_warning != convert_to_unix_line_endings(status.stderr.decode('utf8')):
|
|
return False, ('Incorrect stderr output:\n{act}\n'
|
|
'Expected:\n{exp}'.format(
|
|
act=status.stderr, exp=self.expected_warning))
|
|
return True, ''
|
|
|
|
|
|
class ValidObjectFileWithWarning(NoOutputOnStdout, CorrectObjectFilePreamble,
|
|
WarningMessage):
|
|
"""Mixin class for checking that every input file generates a valid object
|
|
file following the object file naming rule, with a specific warning message.
|
|
"""
|
|
|
|
def check_object_file_preamble(self, status):
|
|
for input_filename in status.input_filenames:
|
|
object_filename = get_object_filename(input_filename)
|
|
success, message = self.verify_object_file_preamble(
|
|
os.path.join(status.directory, object_filename))
|
|
if not success:
|
|
return False, message
|
|
return True, ''
|
|
|
|
|
|
class ValidAssemblyFileWithWarning(NoOutputOnStdout,
|
|
CorrectAssemblyFilePreamble, WarningMessage):
|
|
"""Mixin class for checking that every input file generates a valid assembly
|
|
file following the assembly file naming rule, with a specific warning
|
|
message."""
|
|
|
|
def check_assembly_file_preamble(self, status):
|
|
for input_filename in status.input_filenames:
|
|
assembly_filename = get_assembly_filename(input_filename)
|
|
success, message = self.verify_assembly_file_preamble(
|
|
os.path.join(status.directory, assembly_filename))
|
|
if not success:
|
|
return False, message
|
|
return True, ''
|
|
|
|
|
|
class StdoutMatch(SpirvTest):
|
|
"""Mixin class for tests that can expect output on stdout.
|
|
|
|
To mix in this class, subclasses need to provide expected_stdout as the
|
|
expected stdout output.
|
|
|
|
For expected_stdout, if it's True, then they expect something on stdout but
|
|
will not check what it is. If it's a string, expect an exact match. If it's
|
|
anything else, it is assumed to be a compiled regular expression which will
|
|
be matched against re.search(). It will expect
|
|
expected_stdout.search(status.stdout) to be true.
|
|
"""
|
|
|
|
def check_stdout_match(self, status):
|
|
# "True" in this case means we expect something on stdout, but we do not
|
|
# care what it is, we want to distinguish this from "blah" which means we
|
|
# expect exactly the string "blah".
|
|
if self.expected_stdout is True:
|
|
if not status.stdout:
|
|
return False, 'Expected something on stdout'
|
|
elif type(self.expected_stdout) == str:
|
|
if self.expected_stdout != convert_to_unix_line_endings(status.stdout.decode('utf8')):
|
|
return False, ('Incorrect stdout output:\n{ac}\n'
|
|
'Expected:\n{ex}'.format(
|
|
ac=status.stdout, ex=self.expected_stdout))
|
|
else:
|
|
converted = convert_to_unix_line_endings(status.stdout.decode('utf8'))
|
|
if not self.expected_stdout.search(converted):
|
|
return False, ('Incorrect stdout output:\n{ac}\n'
|
|
'Expected to match regex:\n{ex}'.format(
|
|
ac=status.stdout.decode('utf8'), ex=self.expected_stdout.pattern))
|
|
return True, ''
|
|
|
|
|
|
class StderrMatch(SpirvTest):
|
|
"""Mixin class for tests that can expect output on stderr.
|
|
|
|
To mix in this class, subclasses need to provide expected_stderr as the
|
|
expected stderr output.
|
|
|
|
For expected_stderr, if it's True, then they expect something on stderr,
|
|
but will not check what it is. If it's a string, expect an exact match.
|
|
If it's anything else, it is assumed to be a compiled regular expression
|
|
which will be matched against re.search(). It will expect
|
|
expected_stderr.search(status.stderr) to be true.
|
|
"""
|
|
|
|
def check_stderr_match(self, status):
|
|
# "True" in this case means we expect something on stderr, but we do not
|
|
# care what it is, we want to distinguish this from "blah" which means we
|
|
# expect exactly the string "blah".
|
|
if self.expected_stderr is True:
|
|
if not status.stderr:
|
|
return False, 'Expected something on stderr'
|
|
elif type(self.expected_stderr) == str:
|
|
if self.expected_stderr != convert_to_unix_line_endings(status.stderr.decode('utf8')):
|
|
return False, ('Incorrect stderr output:\n{ac}\n'
|
|
'Expected:\n{ex}'.format(
|
|
ac=status.stderr, ex=self.expected_stderr))
|
|
else:
|
|
if not self.expected_stderr.search(
|
|
convert_to_unix_line_endings(status.stderr.decode('utf8'))):
|
|
return False, ('Incorrect stderr output:\n{ac}\n'
|
|
'Expected to match regex:\n{ex}'.format(
|
|
ac=status.stderr, ex=self.expected_stderr.pattern))
|
|
return True, ''
|
|
|
|
|
|
class StdoutNoWiderThan80Columns(SpirvTest):
|
|
"""Mixin class for tests that require stdout to 80 characters or narrower.
|
|
|
|
To mix in this class, subclasses need to provide expected_stdout as the
|
|
expected stdout output.
|
|
"""
|
|
|
|
def check_stdout_not_too_wide(self, status):
|
|
if not status.stdout:
|
|
return True, ''
|
|
else:
|
|
for line in status.stdout.splitlines():
|
|
if len(line) > 80:
|
|
return False, ('Stdout line longer than 80 columns: %s' % line)
|
|
return True, ''
|
|
|
|
|
|
class NoObjectFile(SpirvTest):
|
|
"""Mixin class for checking that no input file has a corresponding object
|
|
file."""
|
|
|
|
def check_no_object_file(self, status):
|
|
for input_filename in status.input_filenames:
|
|
object_filename = get_object_filename(input_filename)
|
|
full_object_file = os.path.join(status.directory, object_filename)
|
|
print('checking %s' % full_object_file)
|
|
if os.path.isfile(full_object_file):
|
|
return False, (
|
|
'Expected no object file, but found: %s' % full_object_file)
|
|
return True, ''
|
|
|
|
|
|
class NoNamedOutputFiles(SpirvTest):
|
|
"""Mixin class for checking that no specified output files exist.
|
|
|
|
The expected_output_filenames member should be full pathnames."""
|
|
|
|
def check_no_named_output_files(self, status):
|
|
for object_filename in self.expected_output_filenames:
|
|
if os.path.isfile(object_filename):
|
|
return False, (
|
|
'Expected no output file, but found: %s' % object_filename)
|
|
return True, ''
|
|
|
|
|
|
class ExecutedListOfPasses(SpirvTest):
|
|
"""Mixin class for checking that a list of passes where executed.
|
|
|
|
It works by analyzing the output of the --print-all flag to spirv-opt.
|
|
|
|
For this mixin to work, the class member expected_passes should be a sequence
|
|
of pass names as returned by Pass::name().
|
|
"""
|
|
|
|
def check_list_of_executed_passes(self, status):
|
|
# Collect all the output lines containing a pass name.
|
|
pass_names = []
|
|
pass_name_re = re.compile(r'.*IR before pass (?P<pass_name>[\S]+)')
|
|
for line in status.stderr.decode('utf8').splitlines():
|
|
match = pass_name_re.match(line)
|
|
if match:
|
|
pass_names.append(match.group('pass_name'))
|
|
|
|
for (expected, actual) in zip(self.expected_passes, pass_names):
|
|
if expected != actual:
|
|
return False, (
|
|
'Expected pass "%s" but found pass "%s"\n' % (expected, actual))
|
|
|
|
return True, ''
|