def gen_checks(type_str, size):
vals_list = append_fp_postfix(type_str, Data.vals_list_dict[size])
if 'double' in type_str or 'half' in type_str or 'float' in type_str:
vals_list = Data.vals_list_dict_float[size]
reverse_vals_list = vals_list[::-1]
kernel_name = 'KERNEL_API_' + type_str + str(size)
test_string = vector_api_template.substitute(
type=type_str,
size=size,
vals=', '.join(vals_list),
reversed_vals=', '.join(reverse_vals_list),
swizIndexes=', '.join(Data.swizzle_elem_list_dict[size][::-1]))
if 'double' in type_str:
test_string += 'check_convert_as_all_dims<' + type_str + ',' + str(
size) + ', double>(inputVec);\n'
if 'half' in type_str:
test_string += 'check_convert_as_all_dims<' + type_str + ',' + str(
size) + ', sycl::half>(inputVec);\n'
if size != 1:
test_string += lo_hi_odd_even_template.substitute(
type=type_str, vals=', '.join(vals_list))
string = wrap_with_kernel(
type_str, kernel_name,
'API test for sycl::vec<' + type_str + ', ' + str(size) + '>',
test_string)
return wrap_with_test_func(TEST_NAME, type_str, string, str(size))
def gen_alias_test(type_str, size):
alias_vec_name = Data.alias_dict[type_str] + str(size)
test_string = alias_test_template.substitute(
aliasVecName=alias_vec_name, typeName=type_str, size=size)
string = wrap_with_kernel(
type_str, 'KERNEL_alias_' + alias_vec_name.replace('sycl::', ''),
'Alias vector test: ' + alias_vec_name, test_string)
return wrap_with_test_func(TEST_NAME, type_str, string, str(size))
def gen_test(type_str, size):
"""Generates all tests for xyzw, rgba, and elem up to the given size"""
string = ''
# Generate xyzw, rgba tests only for size 1, 2, 3, 4 vecs
if size <= 4:
string += gen_xyzw_str(type_str, size)
if size == 4:
string += gen_rgba_str(type_str, size)
string += gen_elem_str(type_str, size)
return wrap_with_test_func(TEST_NAME, type_str, string, str(size))
def generate_operator_tests(type_str, input_file, output_file):
""""""
test_func_str = ''
func_calls = ''
is_opencl_type = type_str in ReverseData.rev_opencl_type_dict
for size in Data.standard_sizes:
test_str = generate_all_type_test(type_str, size)
test_func_str += wrap_with_test_func(TEST_NAME + '_ALL_TYPES',
type_str, test_str, str(size))
func_calls += make_func_call(TEST_NAME + '_ALL_TYPES', type_str,
str(size))
if is_opencl_type:
test_str = generate_all_types_specific_return_type_test(
type_str, size)
test_func_str += wrap_with_test_func(
TEST_NAME + '_SPECIFIC_RETURN_TYPES', type_str, test_str,
str(size))
func_calls += make_func_call(TEST_NAME + '_SPECIFIC_RETURN_TYPES',
type_str, str(size))
if not type_str in [
'float', 'double', 'cl::sycl::half', 'cl::sycl::cl_float',
'cl::sycl::cl_double', 'cl::sycl::cl_half'
]:
test_str = generate_non_fp_assignment_test(type_str, size)
test_func_str += wrap_with_test_func(
TEST_NAME + '_NON_FP_ASSIGNMENT', type_str, test_str,
str(size))
func_calls += make_func_call(TEST_NAME + '_NON_FP_ASSIGNMENT',
type_str, str(size))
test_str = generate_non_fp_bitwise_test(type_str, size)
test_func_str += wrap_with_test_func(TEST_NAME + '_NON_FP_BITWISE',
type_str, test_str, str(size))
func_calls += make_func_call(TEST_NAME + '_NON_FP_BITWISE',
type_str, str(size))
test_str = generate_non_fp_arithmetic_test(type_str, size)
test_func_str += wrap_with_test_func(
TEST_NAME + '_NON_FP_ARITHMETIC', type_str, test_str,
str(size))
func_calls += make_func_call(TEST_NAME + '_NON_FP_ARITHMETIC',
type_str, str(size))
write_source_file(test_func_str, func_calls, TEST_NAME, input_file,
output_file, type_str)
def gen_optional_checks(type_str, size, dest, dest_type, TEST_NAME_OP):
kernel_name = 'KERNEL_CONVERT_AS_' + type_str + str(size) + dest
test_string = as_convert_call_template.substitute(
type=type_str,
size=size,
vals=', '.join(type_str, Data.vals_list_dict_float[size]),
dest_type=dest_type)
string = wrap_with_kernel(
dest_type, kernel_name, 'convert() as() test for sycl::vec<' +
type_str + ', ' + str(size) + '> to ' + dest, test_string)
return wrap_with_test_func(TEST_NAME_OP, type_str, string, str(size))
def gen_load_store_test(type_str, size):
no_whitespace_type_str = remove_namespaces_whitespaces(type_str)
test_string = load_store_test_template.substitute(
type=type_str,
type_as_str=no_whitespace_type_str,
size=size,
val=Data.value_default_dict[type_str],
in_order_vals=', '.join(
append_fp_postfix(type_str, Data.vals_list_dict[size])),
reverse_order_vals=', '.join(
append_fp_postfix(type_str, Data.vals_list_dict[size][::-1])),
kernelName=gen_kernel_name(type_str, size),
swizVals=', '.join(Data.swizzle_elem_list_dict[size]))
return wrap_with_test_func(
TEST_NAME, type_str, wrap_with_extension_checks(type_str, test_string),
str(size))
def gen_interop_checks(type_str, reverse_type_str, size):
vals_list = append_fp_postfix(type_str, Data.vals_list_dict[size])
reverse_vals_list = vals_list[::-1]
kernel_name = make_interop_kernel_name(type_str, size)
test_string = vector_api_template.substitute(
type=type_str,
size=size,
vals=', '.join(vals_list),
reversed_vals=', '.join(reverse_vals_list),
convertType=reverse_type_str,
asType=reverse_type_str,
swizIndexes=', '.join(Data.swizzle_elem_list_dict[size][::-1]))
if size != 1:
test_string += lo_hi_odd_even_template.substitute(type=type_str)
string = wrap_with_kernel(
type_str, kernel_name,
'API test for cl::sycl::vec<' + type_str + ', ' + str(size) + '>',
test_string)
return wrap_with_test_func(TEST_NAME, type_str, string, str(size))
def generate_constructor_tests(type_str, input_file, output_file):
"""Generates a string for each constructor type containing each combination of test
Constructor types: default, explicit, vec, opencl
A cross section of variadic constructors are provided by the template"""
test_str = ''
test_func_str = ''
func_calls = ''
vector_sizes = Data.standard_sizes
for size in vector_sizes:
test_str += generate_default(type_str, size)
test_str += generate_explicit(type_str, size)
test_str += generate_vec(type_str, size)
test_func_str += wrap_with_test_func(TEST_NAME, type_str, test_str,
str(size))
test_str = ''
func_calls += make_func_call(TEST_NAME, type_str, str(size))
write_source_file(test_func_str, func_calls, TEST_NAME, input_file,
output_file, type_str)
def gen_host_checks(type_str, reverse_type_str, size):
"""Uses the above string templates to generate tests for each vec api function except load and store.
Load and store are handled separately.
lo() hi() odd() and even() are handled with a separate function and template to other api functions
as they can only be performed on vectors of size 2 or greater."""
vals_list = append_fp_postfix(type_str, Data.vals_list_dict[size])
reverse_vals_list = vals_list[::-1]
kernel_name = make_host_kernel_name(type_str, size)
test_string = vector_api_template.substitute(
type=type_str,
size=size,
vals=', '.join(vals_list),
reversed_vals=', '.join(reverse_vals_list),
convertType=reverse_type_str,
asType=reverse_type_str,
swizIndexes=', '.join(Data.swizzle_elem_list_dict[size][::-1]))
if size != 1:
test_string += lo_hi_odd_even_template.substitute(type=type_str)
string = wrap_with_kernel(
type_str, kernel_name,
'API test for cl::sycl::vec<' + type_str + ', ' + str(size) + '>',
test_string)
return wrap_with_test_func(TEST_NAME, type_str, string, str(size))