test_exe = executable(
    'yasl-test',
    'test_lifecycle.c',
    include_directories: inc,
    link_with: yasl_lib.get_static_lib(),
    dependencies: deps,
)

add_test_setup('asan')
add_test_setup('tsan')
add_test_setup('msan')

test('basic', test_exe)

shared_dep = declare_dependency(
    link_with: yasl_lib.get_shared_lib(),
    include_directories: include_directories('../include'),
)

shared_api_test = executable(
    'yasl-shared-api-test',
    'test_lifecycle.c',
    dependencies: shared_dep,
)
test('shared-api', shared_api_test)

if add_languages('cpp', native: false, required: false)
    cpp = meson.get_compiler('cpp')
    cpp_api_test = executable(
        'yasl-cpp-api-test',
        'test_api.cpp',
        dependencies: shared_dep,
        cpp_args: cpp.get_supported_arguments('-pedantic-errors'),
        override_options: ['cpp_std=c++11'],
    )
    test('cpp-api', cpp_api_test)
endif

python = find_program('python3')
if system == 'linux'
    nm = find_program('nm')
    export_args = []
    if get_option('b_sanitize').contains('address')
        # Clang's ASan instrumentation exports these linker-generated markers.
        export_args += ['--allow-export=__start_asan_globals',
                        '--allow-export=__stop_asan_globals']
    endif
    test('public-exports', python,
        args: [files('helpers/check_exports.py')] + export_args +
              [nm, yasl_lib.get_shared_lib(),
               files('../include/yasl/yasl.h', '../include/yasl/timing.h',
                     '../include/yasl/loop.h', '../include/yasl/native.h')],
    )
endif

contracts_test = executable(
    'yasl-contracts-test',
    'common/test_contracts.c',
    include_directories: inc,
    dependencies: yasl_dep,
)
test('contracts', contracts_test)

timer_test = executable(
    'yasl-timer-test',
    'common/test_timers.c',
    include_directories: inc,
    dependencies: yasl_dep,
)
test('timers', timer_test)

input_alloc_test = executable(
    'yasl-input-alloc-test',
    ['common/test_input_alloc.c', '../src/common/input.c'],
    include_directories: inc,
    c_args: ['-Dmalloc=yasl_test_malloc'],
)
test('input-allocation-failure', input_alloc_test)

selection_test = executable(
    'yasl-selection-test',
    'common/test_selection.c',
    dependencies: yasl_dep,
)
test('selection', selection_test)

tablet_example_test = executable('yasl-tablet-example-test', 'common/test_tablet_example.c',
    dependencies: yasl_dep,
)
test('tablet-example', tablet_example_test)

if has_x11
    tablet_x11_test = executable('yasl-tablet-x11-test', 'x11/test_tablet.c',
        include_directories: inc, dependencies: yasl_dep,
    )
    test('tablet-x11', tablet_x11_test)
    if get_option('x11_tablet_tests')
        xorg = find_program('/usr/lib/Xorg', '/usr/lib/xorg/Xorg', 'Xorg')
        native_tablet_test = executable('yasl-tablet-x11-native-test', 'x11/test_tablet_native.c',
            dependencies: yasl_dep,
        )
        test('tablet-x11-native', python,
            args: [files('helpers/run_x11_tablet.py'), xorg, native_tablet_test], timeout: 30,
        )
    endif
elif get_option('x11_tablet_tests')
    error('Native X11 tablet tests require the X11 backend.')
endif

if has_wayland
    ime_test = executable('yasl-ime-test', 'wayland/test_input.c',
        include_directories: inc,
        dependencies: yasl_dep,
    )
    test('ime-ownership', ime_test)
    tablet_wayland_test = executable('yasl-tablet-wayland-test', 'wayland/test_tablet.c',
        include_directories: inc, dependencies: yasl_dep,
    )
    test('tablet-wayland', tablet_wayland_test)
    cursor_wayland_test = executable('yasl-cursor-wayland-test', 'wayland/test_cursor.c',
        include_directories: inc, dependencies: yasl_dep,
    )
    test('cursor-wayland', cursor_wayland_test)
endif

if get_option('integration_tests')
    if has_cocoa
        native_test = executable('yasl-native-test', 'cocoa/test_native.c',
            dependencies: shared_dep,
        )
        test('native', native_test, timeout: 20)
        ownership_test = executable('yasl-ownership-test', 'cocoa/test_ownership.m',
            dependencies: [shared_dep, deps],
        )
        test('native-ownership', ownership_test, timeout: 20)
        tablet_cocoa_test = executable('yasl-tablet-cocoa-test', 'cocoa/test_tablet.m',
            dependencies: [shared_dep, deps],
        )
        test('tablet-cocoa', tablet_cocoa_test, timeout: 20)
        cursor_cocoa_test = executable('yasl-cursor-cocoa-test', 'cocoa/test_cursor.m',
            dependencies: [shared_dep, deps],
        )
        test('cursor-cocoa', cursor_cocoa_test, timeout: 20)
        test('tablet-cocoa-window', tablet_example,
            args: ['--backend', 'cocoa', '--smoke-test'], timeout: 20,
        )
    else
        if not has_wayland or not has_x11
            error('Linux integration tests require Wayland and X11.')
        endif
        backend_test = executable(
            'yasl-backend-test',
            'common/test_backends.c',
            dependencies: [shared_dep, deps],
        )
        weston = find_program('weston')
        xwayland = find_program('Xwayland')
        test('backends', python,
            args: [files('helpers/run_backends.py'), weston, xwayland,
                   backend_test, timer_test, tablet_example],
            timeout: 60,
        )
    endif
endif