|
|
|
|
plugin_test_shell_desktop = shared_library(
|
|
|
|
|
'weston-test-desktop-shell',
|
|
|
|
|
'weston-test-desktop-shell.c',
|
|
|
|
|
include_directories: common_inc,
|
|
|
|
|
dependencies: [ dep_libweston_public, dep_libexec_weston, dep_shell_utils ],
|
|
|
|
|
name_prefix: '',
|
|
|
|
|
install: false
|
|
|
|
|
)
|
|
|
|
|
env_modmap += 'weston-test-desktop-shell.so=@0@;'.format(plugin_test_shell_desktop.full_path())
|
|
|
|
|
|
|
|
|
|
lib_test_runner = static_library(
|
|
|
|
|
'test-runner',
|
|
|
|
|
'weston-test-runner.c',
|
tests: thread-based client harness
This replaces the old test harness with a new one.
The old harness relied on fork()'ing each test which makes tests independent,
but makes debugging them harder. The new harness runs client code in a thread
instead of a new process. A side-effect of not fork()'ing anymore is that any
failure will stop running a test series short. Fortunately we do not have any
tests that are expected to crash or fail.
The old harness executed 'weston' from Meson, with lots of setup as both
command line options and environment variables. The new harness executes
wet_main() instead: the test program itself calls the compositor main function
to execute the compositor in-process. Command line arguments are configured in
the test program itself, not in meson.build. Environment variables aside, you
are able to run a test by simply executing the test program, even if it is a
plugin test.
The new harness adds a new type of iteration: fixtures. For now, fixtures are
used to set up the compositor for tests that need a compositor. If necessary, a
fixture setup may include a data array of arbitrary type for executing the test
series for each element in the array. This will be most useful for running
screenshooting tests with both Pixman- and GL-renderers.
The new harness outputs TAP formatted results into stdout. Meson is not
switched to consume TAP yet though, because it would require a Meson version
requirement bump and would not have any benefits at this time. OTOH outputting
TAP is trivial and sets up a clear precedent of random test chatter belonging
to stderr.
This commit migrates only few tests to actually make use of the new features:
roles is a basic client test, subsurface-shot is a client test that
demonstrates the fixture array, and plugin-registry is a plugin test. The rest
of the tests will be migrated later.
Once all tests are migrated, we can remove the test-specific setup from
meson.build, leaving only the actual build instructions in there.
The not migrated tests and stand-alone tests suffer only a minor change: they
no longer fork() for each TEST(), otherwise they keep running as before.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
5 years ago
|
|
|
dependencies: [
|
|
|
|
|
dep_libweston_private_h_deps,
|
|
|
|
|
dep_wayland_client,
|
CI: Never unload llvmpipe DSO whilst testing
This commit is truly horrible.
We want to run ASan with leak checking enabled in CI so we can catch
memory leaks before they're introduced. This works well with Pixman, and
with NIR-only drivers like iris or Panfrost.
But when we run under llvmpipe - which we do under CI - we start failing
because:
- Mesa pulls in llvmpipe via dlopen
- llvmpipe pulls in LLVM itself via DT_NEEDED
- initialising LLVM's global type/etc systems performs thread-local
allocations
- llvmpipe can't free those allocations since the application might
also be using LLVM
- Weston stops using GL and destroys all GL objects, leading to Mesa
unloading llvmpipe like it should
- with everything disappearing from the process's vmap, ASan can no
longer keep track of still-reachable pointers
- tests fail because LLVM is 'leaking'
Usually, an alternative is to LD_PRELOAD a shim which overrides
dlclose() to be a no-op. This is not usable here, because when
$LD_PRELOAD is not empty and ASan is not first in it, ASan immediately
errors out. Prepending ASan doesn't work, because we run our tests
through Meson (which also invokes Ninja), leading to LSan exploding
over CPython and Ninja, which is not what we're interested in.
It would be possible to inject _both_ ASan and a dlclose-does-nothing
shim DSO into the LD_PRELOAD environment for every test, but that seems
even worse, especially as Meson strongly discourages globbing for random
files in the root.
So, here we are, doing what we can: finding where swrast_dri.so (aka
llvmpipe) lives, stashing that in an environment variable, and
deliberately leaking a dlopen handle which we never close to ensure that
neither llvmpipe nor LLVM leave our process's address space before we
exit.
Signed-off-by: Daniel Stone <daniels@collabora.com>
3 years ago
|
|
|
dep_libdl,
|
tests: thread-based client harness
This replaces the old test harness with a new one.
The old harness relied on fork()'ing each test which makes tests independent,
but makes debugging them harder. The new harness runs client code in a thread
instead of a new process. A side-effect of not fork()'ing anymore is that any
failure will stop running a test series short. Fortunately we do not have any
tests that are expected to crash or fail.
The old harness executed 'weston' from Meson, with lots of setup as both
command line options and environment variables. The new harness executes
wet_main() instead: the test program itself calls the compositor main function
to execute the compositor in-process. Command line arguments are configured in
the test program itself, not in meson.build. Environment variables aside, you
are able to run a test by simply executing the test program, even if it is a
plugin test.
The new harness adds a new type of iteration: fixtures. For now, fixtures are
used to set up the compositor for tests that need a compositor. If necessary, a
fixture setup may include a data array of arbitrary type for executing the test
series for each element in the array. This will be most useful for running
screenshooting tests with both Pixman- and GL-renderers.
The new harness outputs TAP formatted results into stdout. Meson is not
switched to consume TAP yet though, because it would require a Meson version
requirement bump and would not have any benefits at this time. OTOH outputting
TAP is trivial and sets up a clear precedent of random test chatter belonging
to stderr.
This commit migrates only few tests to actually make use of the new features:
roles is a basic client test, subsurface-shot is a client test that
demonstrates the fixture array, and plugin-registry is a plugin test. The rest
of the tests will be migrated later.
Once all tests are migrated, we can remove the test-specific setup from
meson.build, leaving only the actual build instructions in there.
The not migrated tests and stand-alone tests suffer only a minor change: they
no longer fork() for each TEST(), otherwise they keep running as before.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
5 years ago
|
|
|
],
|
|
|
|
|
include_directories: common_inc,
|
|
|
|
|
install: false,
|
|
|
|
|
)
|
|
|
|
|
dep_test_runner = declare_dependency(
|
|
|
|
|
dependencies: dep_wayland_client,
|
|
|
|
|
link_with: lib_test_runner
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
lib_test_client = static_library(
|
|
|
|
|
'test-client',
|
tests: thread-based client harness
This replaces the old test harness with a new one.
The old harness relied on fork()'ing each test which makes tests independent,
but makes debugging them harder. The new harness runs client code in a thread
instead of a new process. A side-effect of not fork()'ing anymore is that any
failure will stop running a test series short. Fortunately we do not have any
tests that are expected to crash or fail.
The old harness executed 'weston' from Meson, with lots of setup as both
command line options and environment variables. The new harness executes
wet_main() instead: the test program itself calls the compositor main function
to execute the compositor in-process. Command line arguments are configured in
the test program itself, not in meson.build. Environment variables aside, you
are able to run a test by simply executing the test program, even if it is a
plugin test.
The new harness adds a new type of iteration: fixtures. For now, fixtures are
used to set up the compositor for tests that need a compositor. If necessary, a
fixture setup may include a data array of arbitrary type for executing the test
series for each element in the array. This will be most useful for running
screenshooting tests with both Pixman- and GL-renderers.
The new harness outputs TAP formatted results into stdout. Meson is not
switched to consume TAP yet though, because it would require a Meson version
requirement bump and would not have any benefits at this time. OTOH outputting
TAP is trivial and sets up a clear precedent of random test chatter belonging
to stderr.
This commit migrates only few tests to actually make use of the new features:
roles is a basic client test, subsurface-shot is a client test that
demonstrates the fixture array, and plugin-registry is a plugin test. The rest
of the tests will be migrated later.
Once all tests are migrated, we can remove the test-specific setup from
meson.build, leaving only the actual build instructions in there.
The not migrated tests and stand-alone tests suffer only a minor change: they
no longer fork() for each TEST(), otherwise they keep running as before.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
5 years ago
|
|
|
[
|
|
|
|
|
'weston-test-client-helper.c',
|
|
|
|
|
'weston-test-fixture-compositor.c',
|
|
|
|
|
weston_test_client_protocol_h,
|
|
|
|
|
weston_test_protocol_c,
|
|
|
|
|
weston_screenshooter_client_protocol_h,
|
|
|
|
|
weston_screenshooter_protocol_c,
|
|
|
|
|
viewporter_client_protocol_h,
|
|
|
|
|
viewporter_protocol_c,
|
|
|
|
|
'color_util.h',
|
|
|
|
|
'color_util.c',
|
tests: thread-based client harness
This replaces the old test harness with a new one.
The old harness relied on fork()'ing each test which makes tests independent,
but makes debugging them harder. The new harness runs client code in a thread
instead of a new process. A side-effect of not fork()'ing anymore is that any
failure will stop running a test series short. Fortunately we do not have any
tests that are expected to crash or fail.
The old harness executed 'weston' from Meson, with lots of setup as both
command line options and environment variables. The new harness executes
wet_main() instead: the test program itself calls the compositor main function
to execute the compositor in-process. Command line arguments are configured in
the test program itself, not in meson.build. Environment variables aside, you
are able to run a test by simply executing the test program, even if it is a
plugin test.
The new harness adds a new type of iteration: fixtures. For now, fixtures are
used to set up the compositor for tests that need a compositor. If necessary, a
fixture setup may include a data array of arbitrary type for executing the test
series for each element in the array. This will be most useful for running
screenshooting tests with both Pixman- and GL-renderers.
The new harness outputs TAP formatted results into stdout. Meson is not
switched to consume TAP yet though, because it would require a Meson version
requirement bump and would not have any benefits at this time. OTOH outputting
TAP is trivial and sets up a clear precedent of random test chatter belonging
to stderr.
This commit migrates only few tests to actually make use of the new features:
roles is a basic client test, subsurface-shot is a client test that
demonstrates the fixture array, and plugin-registry is a plugin test. The rest
of the tests will be migrated later.
Once all tests are migrated, we can remove the test-specific setup from
meson.build, leaving only the actual build instructions in there.
The not migrated tests and stand-alone tests suffer only a minor change: they
no longer fork() for each TEST(), otherwise they keep running as before.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
5 years ago
|
|
|
],
|
|
|
|
|
include_directories: common_inc,
|
|
|
|
|
dependencies: [
|
|
|
|
|
dep_libshared,
|
|
|
|
|
dep_wayland_client,
|
tests: thread-based client harness
This replaces the old test harness with a new one.
The old harness relied on fork()'ing each test which makes tests independent,
but makes debugging them harder. The new harness runs client code in a thread
instead of a new process. A side-effect of not fork()'ing anymore is that any
failure will stop running a test series short. Fortunately we do not have any
tests that are expected to crash or fail.
The old harness executed 'weston' from Meson, with lots of setup as both
command line options and environment variables. The new harness executes
wet_main() instead: the test program itself calls the compositor main function
to execute the compositor in-process. Command line arguments are configured in
the test program itself, not in meson.build. Environment variables aside, you
are able to run a test by simply executing the test program, even if it is a
plugin test.
The new harness adds a new type of iteration: fixtures. For now, fixtures are
used to set up the compositor for tests that need a compositor. If necessary, a
fixture setup may include a data array of arbitrary type for executing the test
series for each element in the array. This will be most useful for running
screenshooting tests with both Pixman- and GL-renderers.
The new harness outputs TAP formatted results into stdout. Meson is not
switched to consume TAP yet though, because it would require a Meson version
requirement bump and would not have any benefits at this time. OTOH outputting
TAP is trivial and sets up a clear precedent of random test chatter belonging
to stderr.
This commit migrates only few tests to actually make use of the new features:
roles is a basic client test, subsurface-shot is a client test that
demonstrates the fixture array, and plugin-registry is a plugin test. The rest
of the tests will be migrated later.
Once all tests are migrated, we can remove the test-specific setup from
meson.build, leaving only the actual build instructions in there.
The not migrated tests and stand-alone tests suffer only a minor change: they
no longer fork() for each TEST(), otherwise they keep running as before.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
5 years ago
|
|
|
dep_libexec_weston,
|
|
|
|
|
dep_pixman,
|
|
|
|
|
dependency('cairo'),
|
|
|
|
|
],
|
|
|
|
|
install: false,
|
|
|
|
|
)
|
|
|
|
|
dep_test_client = declare_dependency(
|
|
|
|
|
link_with: lib_test_client,
|
|
|
|
|
sources: [
|
|
|
|
|
viewporter_client_protocol_h,
|
|
|
|
|
],
|
|
|
|
|
dependencies: [
|
|
|
|
|
dep_wayland_client,
|
|
|
|
|
dep_test_runner,
|
|
|
|
|
dep_pixman,
|
|
|
|
|
dependency('libudev', version: '>= 136'),
|
|
|
|
|
]
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
lib_lcms_util = static_library(
|
|
|
|
|
'lib_lcms_util',
|
|
|
|
|
[ 'lcms_util.c' ],
|
|
|
|
|
include_directories: common_inc,
|
|
|
|
|
dependencies: [
|
|
|
|
|
dep_lcms2, dep_libm
|
|
|
|
|
],
|
|
|
|
|
build_by_default: false,
|
|
|
|
|
install: false,
|
|
|
|
|
)
|
|
|
|
|
dep_lcms_util = declare_dependency(
|
|
|
|
|
link_with: lib_lcms_util,
|
|
|
|
|
dependencies: [ dep_lcms2 ]
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
exe_plugin_test = shared_library(
|
|
|
|
|
'test-plugin',
|
|
|
|
|
'weston-test.c',
|
|
|
|
|
weston_test_server_protocol_h,
|
|
|
|
|
weston_test_protocol_c,
|
|
|
|
|
include_directories: common_inc,
|
tests: thread-based client harness
This replaces the old test harness with a new one.
The old harness relied on fork()'ing each test which makes tests independent,
but makes debugging them harder. The new harness runs client code in a thread
instead of a new process. A side-effect of not fork()'ing anymore is that any
failure will stop running a test series short. Fortunately we do not have any
tests that are expected to crash or fail.
The old harness executed 'weston' from Meson, with lots of setup as both
command line options and environment variables. The new harness executes
wet_main() instead: the test program itself calls the compositor main function
to execute the compositor in-process. Command line arguments are configured in
the test program itself, not in meson.build. Environment variables aside, you
are able to run a test by simply executing the test program, even if it is a
plugin test.
The new harness adds a new type of iteration: fixtures. For now, fixtures are
used to set up the compositor for tests that need a compositor. If necessary, a
fixture setup may include a data array of arbitrary type for executing the test
series for each element in the array. This will be most useful for running
screenshooting tests with both Pixman- and GL-renderers.
The new harness outputs TAP formatted results into stdout. Meson is not
switched to consume TAP yet though, because it would require a Meson version
requirement bump and would not have any benefits at this time. OTOH outputting
TAP is trivial and sets up a clear precedent of random test chatter belonging
to stderr.
This commit migrates only few tests to actually make use of the new features:
roles is a basic client test, subsurface-shot is a client test that
demonstrates the fixture array, and plugin-registry is a plugin test. The rest
of the tests will be migrated later.
Once all tests are migrated, we can remove the test-specific setup from
meson.build, leaving only the actual build instructions in there.
The not migrated tests and stand-alone tests suffer only a minor change: they
no longer fork() for each TEST(), otherwise they keep running as before.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
5 years ago
|
|
|
dependencies: [
|
|
|
|
|
dep_libexec_weston,
|
|
|
|
|
dep_libweston_private,
|
|
|
|
|
dep_threads
|
|
|
|
|
],
|
|
|
|
|
name_prefix: '',
|
|
|
|
|
install: false,
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
deps_zuc = [ dep_libshared ]
|
|
|
|
|
config_h.set10('ENABLE_JUNIT_XML', get_option('test-junit-xml'))
|
|
|
|
|
if get_option('test-junit-xml')
|
|
|
|
|
d = dependency('libxml-2.0', version: '>= 2.6', required: false)
|
|
|
|
|
if not d.found()
|
|
|
|
|
error('JUnit XML support requires libxml-2.0 >= 2.6 which was not found. Or, you can use \'-Dtest-junit-xml=false\'.')
|
|
|
|
|
endif
|
|
|
|
|
deps_zuc += d
|
|
|
|
|
endif
|
|
|
|
|
|
|
|
|
|
lib_zuc = static_library(
|
|
|
|
|
'zunitc',
|
|
|
|
|
'../tools/zunitc/inc/zunitc/zunitc.h',
|
|
|
|
|
'../tools/zunitc/inc/zunitc/zunitc_impl.h',
|
|
|
|
|
'../tools/zunitc/src/zuc_base_logger.c',
|
|
|
|
|
'../tools/zunitc/src/zuc_base_logger.h',
|
|
|
|
|
'../tools/zunitc/src/zuc_context.h',
|
|
|
|
|
'../tools/zunitc/src/zuc_event.h',
|
|
|
|
|
'../tools/zunitc/src/zuc_event_listener.h',
|
|
|
|
|
'../tools/zunitc/src/zuc_junit_reporter.c',
|
|
|
|
|
'../tools/zunitc/src/zuc_junit_reporter.h',
|
|
|
|
|
'../tools/zunitc/src/zuc_types.h',
|
|
|
|
|
'../tools/zunitc/src/zunitc_impl.c',
|
|
|
|
|
include_directories: [ common_inc, include_directories('../tools/zunitc/inc') ],
|
|
|
|
|
dependencies: deps_zuc,
|
|
|
|
|
)
|
|
|
|
|
dep_zuc = declare_dependency(
|
|
|
|
|
link_with: lib_zuc,
|
|
|
|
|
dependencies: dep_libshared,
|
|
|
|
|
include_directories: include_directories('../tools/zunitc/inc')
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
lib_zucmain = static_library(
|
|
|
|
|
'zunitcmain',
|
|
|
|
|
'../tools/zunitc/src/main.c',
|
|
|
|
|
include_directories: [ common_inc, include_directories('../tools/zunitc/inc') ],
|
|
|
|
|
dependencies: [ dep_libshared, dep_zuc ],
|
|
|
|
|
)
|
|
|
|
|
dep_zucmain = declare_dependency(
|
|
|
|
|
link_with: lib_zucmain,
|
|
|
|
|
dependencies: dep_zuc
|
|
|
|
|
)
|
|
|
|
|
|
tests: thread-based client harness
This replaces the old test harness with a new one.
The old harness relied on fork()'ing each test which makes tests independent,
but makes debugging them harder. The new harness runs client code in a thread
instead of a new process. A side-effect of not fork()'ing anymore is that any
failure will stop running a test series short. Fortunately we do not have any
tests that are expected to crash or fail.
The old harness executed 'weston' from Meson, with lots of setup as both
command line options and environment variables. The new harness executes
wet_main() instead: the test program itself calls the compositor main function
to execute the compositor in-process. Command line arguments are configured in
the test program itself, not in meson.build. Environment variables aside, you
are able to run a test by simply executing the test program, even if it is a
plugin test.
The new harness adds a new type of iteration: fixtures. For now, fixtures are
used to set up the compositor for tests that need a compositor. If necessary, a
fixture setup may include a data array of arbitrary type for executing the test
series for each element in the array. This will be most useful for running
screenshooting tests with both Pixman- and GL-renderers.
The new harness outputs TAP formatted results into stdout. Meson is not
switched to consume TAP yet though, because it would require a Meson version
requirement bump and would not have any benefits at this time. OTOH outputting
TAP is trivial and sets up a clear precedent of random test chatter belonging
to stderr.
This commit migrates only few tests to actually make use of the new features:
roles is a basic client test, subsurface-shot is a client test that
demonstrates the fixture array, and plugin-registry is a plugin test. The rest
of the tests will be migrated later.
Once all tests are migrated, we can remove the test-specific setup from
meson.build, leaving only the actual build instructions in there.
The not migrated tests and stand-alone tests suffer only a minor change: they
no longer fork() for each TEST(), otherwise they keep running as before.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
5 years ago
|
|
|
tests = [
|
|
|
|
|
{
|
|
|
|
|
'name': 'alpha-blending',
|
|
|
|
|
'dep_objs': dep_libm,
|
|
|
|
|
},
|
|
|
|
|
{ 'name': 'bad-buffer', },
|
|
|
|
|
{ 'name': 'buffer-transforms', },
|
|
|
|
|
{
|
|
|
|
|
'name': 'color-metadata-errors',
|
|
|
|
|
'dep_objs': dep_libexec_weston,
|
|
|
|
|
},
|
|
|
|
|
{ 'name': 'color-manager', },
|
|
|
|
|
{ 'name': 'devices', },
|
|
|
|
|
{
|
|
|
|
|
'name': 'drm-formats',
|
|
|
|
|
'dep_objs': dep_libdrm_headers,
|
|
|
|
|
},
|
|
|
|
|
{ 'name': 'drm-smoke', 'run_exclusive': true },
|
|
|
|
|
{ 'name': 'event', },
|
|
|
|
|
{ 'name': 'internal-screenshot', },
|
|
|
|
|
{
|
|
|
|
|
'name': 'keyboard',
|
|
|
|
|
'sources': [
|
|
|
|
|
'keyboard-test.c',
|
|
|
|
|
'input-timestamps-helper.c',
|
|
|
|
|
input_timestamps_unstable_v1_client_protocol_h,
|
|
|
|
|
input_timestamps_unstable_v1_protocol_c,
|
|
|
|
|
],
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
'name': 'linux-explicit-synchronization',
|
|
|
|
|
'sources': [
|
|
|
|
|
'linux-explicit-synchronization-test.c',
|
|
|
|
|
linux_explicit_synchronization_unstable_v1_client_protocol_h,
|
|
|
|
|
linux_explicit_synchronization_unstable_v1_protocol_c,
|
|
|
|
|
],
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
'name': 'matrix',
|
|
|
|
|
'dep_objs': [ dep_libm ]
|
|
|
|
|
},
|
|
|
|
|
{ 'name': 'output-damage', },
|
tests: add output transform tests
This goes through all output transforms with two different buffer transforms
and verifies the visual output against reference images.
This commit introduces a new test input image 'basic-test-card.png'. It is a
small image with deliberately odd and indivisible dimensions to provoke bad
assumptions about image sizes. It contains red, green and blue areas which are
actually text that makes it very obvious if you have e.g. color channels
swapped. It has a white thick circle to highlight aspect ratio issues, and an
orange cross to show a mixed color. The white border is for contrast and a 1px
wide detail. The whole design makes it clear if the image happens to be rotated
or flipped in any way.
The image has one pixel wide transparent border so that bilinear sampling
filter near the edges of the image would produce the same colors with both
Pixman- and GL-renderers which handle the out-of-image samples fundamentally
differently: Pixman assumes (0, 0, 0, 0) samples outside of the image, while
GL-renderer clamps sample coordinates to the edge essentially repeating the
edge pixels.
It would have been "easy" to create a full matrix of
every output scale & transform x every buffer scale & transform, but that
would have resulted in 2 renderers * 8 output transforms * 3 output scales *
8 buffer transforms * 3 buffer scales = 1152 test cases that would have all
ran strictly serially because our test harness has no parallelism inside one
test program. That would have been slow to run, and need a lot more reference
images too.
Instead, I chose to iterate separately through all output scales & transforms
(this patch) and all buffer scales & transforms (next patch). This limits the
number of test cases in this patch to 56, and allows the two test programs to
run in parallel.
I did not even pick all possible scale & transform combinations here, but just
what I think is a representative sub-set to hopefully exercise all the code
paths.
https://gitlab.freedesktop.org/wayland/weston/issues/52
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
5 years ago
|
|
|
{ 'name': 'output-transforms', },
|
tests: thread-based client harness
This replaces the old test harness with a new one.
The old harness relied on fork()'ing each test which makes tests independent,
but makes debugging them harder. The new harness runs client code in a thread
instead of a new process. A side-effect of not fork()'ing anymore is that any
failure will stop running a test series short. Fortunately we do not have any
tests that are expected to crash or fail.
The old harness executed 'weston' from Meson, with lots of setup as both
command line options and environment variables. The new harness executes
wet_main() instead: the test program itself calls the compositor main function
to execute the compositor in-process. Command line arguments are configured in
the test program itself, not in meson.build. Environment variables aside, you
are able to run a test by simply executing the test program, even if it is a
plugin test.
The new harness adds a new type of iteration: fixtures. For now, fixtures are
used to set up the compositor for tests that need a compositor. If necessary, a
fixture setup may include a data array of arbitrary type for executing the test
series for each element in the array. This will be most useful for running
screenshooting tests with both Pixman- and GL-renderers.
The new harness outputs TAP formatted results into stdout. Meson is not
switched to consume TAP yet though, because it would require a Meson version
requirement bump and would not have any benefits at this time. OTOH outputting
TAP is trivial and sets up a clear precedent of random test chatter belonging
to stderr.
This commit migrates only few tests to actually make use of the new features:
roles is a basic client test, subsurface-shot is a client test that
demonstrates the fixture array, and plugin-registry is a plugin test. The rest
of the tests will be migrated later.
Once all tests are migrated, we can remove the test-specific setup from
meson.build, leaving only the actual build instructions in there.
The not migrated tests and stand-alone tests suffer only a minor change: they
no longer fork() for each TEST(), otherwise they keep running as before.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
5 years ago
|
|
|
{ 'name': 'plugin-registry', },
|
|
|
|
|
{
|
|
|
|
|
'name': 'pointer',
|
|
|
|
|
'sources': [
|
|
|
|
|
'pointer-test.c',
|
|
|
|
|
'input-timestamps-helper.c',
|
|
|
|
|
input_timestamps_unstable_v1_client_protocol_h,
|
|
|
|
|
input_timestamps_unstable_v1_protocol_c,
|
|
|
|
|
],
|
|
|
|
|
},
|
|
|
|
|
{ 'name': 'pointer-shot', },
|
|
|
|
|
{
|
|
|
|
|
'name': 'presentation',
|
|
|
|
|
'sources': [
|
|
|
|
|
'presentation-test.c',
|
|
|
|
|
presentation_time_client_protocol_h,
|
|
|
|
|
presentation_time_protocol_c,
|
|
|
|
|
],
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
'name': 'roles',
|
|
|
|
|
'sources': [
|
|
|
|
|
'roles-test.c',
|
|
|
|
|
xdg_shell_client_protocol_h,
|
|
|
|
|
xdg_shell_protocol_c,
|
|
|
|
|
],
|
|
|
|
|
},
|
|
|
|
|
{ 'name': 'string', },
|
|
|
|
|
{ 'name': 'subsurface', },
|
tests: thread-based client harness
This replaces the old test harness with a new one.
The old harness relied on fork()'ing each test which makes tests independent,
but makes debugging them harder. The new harness runs client code in a thread
instead of a new process. A side-effect of not fork()'ing anymore is that any
failure will stop running a test series short. Fortunately we do not have any
tests that are expected to crash or fail.
The old harness executed 'weston' from Meson, with lots of setup as both
command line options and environment variables. The new harness executes
wet_main() instead: the test program itself calls the compositor main function
to execute the compositor in-process. Command line arguments are configured in
the test program itself, not in meson.build. Environment variables aside, you
are able to run a test by simply executing the test program, even if it is a
plugin test.
The new harness adds a new type of iteration: fixtures. For now, fixtures are
used to set up the compositor for tests that need a compositor. If necessary, a
fixture setup may include a data array of arbitrary type for executing the test
series for each element in the array. This will be most useful for running
screenshooting tests with both Pixman- and GL-renderers.
The new harness outputs TAP formatted results into stdout. Meson is not
switched to consume TAP yet though, because it would require a Meson version
requirement bump and would not have any benefits at this time. OTOH outputting
TAP is trivial and sets up a clear precedent of random test chatter belonging
to stderr.
This commit migrates only few tests to actually make use of the new features:
roles is a basic client test, subsurface-shot is a client test that
demonstrates the fixture array, and plugin-registry is a plugin test. The rest
of the tests will be migrated later.
Once all tests are migrated, we can remove the test-specific setup from
meson.build, leaving only the actual build instructions in there.
The not migrated tests and stand-alone tests suffer only a minor change: they
no longer fork() for each TEST(), otherwise they keep running as before.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
5 years ago
|
|
|
{ 'name': 'subsurface-shot', },
|
|
|
|
|
{ 'name': 'surface', },
|
|
|
|
|
{ 'name': 'surface-global', },
|
|
|
|
|
{
|
|
|
|
|
'name': 'text',
|
|
|
|
|
'sources': [
|
|
|
|
|
'text-test.c',
|
|
|
|
|
text_input_unstable_v1_client_protocol_h,
|
|
|
|
|
text_input_unstable_v1_protocol_c,
|
|
|
|
|
],
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
'name': 'touch',
|
|
|
|
|
'sources': [
|
|
|
|
|
'touch-test.c',
|
|
|
|
|
'input-timestamps-helper.c',
|
|
|
|
|
input_timestamps_unstable_v1_client_protocol_h,
|
|
|
|
|
input_timestamps_unstable_v1_protocol_c,
|
|
|
|
|
],
|
|
|
|
|
},
|
|
|
|
|
{ 'name': 'viewporter', },
|
|
|
|
|
{ 'name': 'viewporter-shot', },
|
|
|
|
|
{
|
|
|
|
|
'name': 'yuv-buffer',
|
|
|
|
|
'dep_objs': [
|
|
|
|
|
dep_libdrm_headers,
|
|
|
|
|
dep_libm,
|
|
|
|
|
],
|
|
|
|
|
},
|
|
|
|
|
{ 'name': 'safe-signal', },
|
|
|
|
|
{ 'name': 'safe-signal-output-removal',
|
|
|
|
|
'sources': [
|
|
|
|
|
'safe-signal-output-removal-test.c',
|
|
|
|
|
],
|
|
|
|
|
'dep_objs': [ dep_shell_utils ]
|
|
|
|
|
},
|
tests: thread-based client harness
This replaces the old test harness with a new one.
The old harness relied on fork()'ing each test which makes tests independent,
but makes debugging them harder. The new harness runs client code in a thread
instead of a new process. A side-effect of not fork()'ing anymore is that any
failure will stop running a test series short. Fortunately we do not have any
tests that are expected to crash or fail.
The old harness executed 'weston' from Meson, with lots of setup as both
command line options and environment variables. The new harness executes
wet_main() instead: the test program itself calls the compositor main function
to execute the compositor in-process. Command line arguments are configured in
the test program itself, not in meson.build. Environment variables aside, you
are able to run a test by simply executing the test program, even if it is a
plugin test.
The new harness adds a new type of iteration: fixtures. For now, fixtures are
used to set up the compositor for tests that need a compositor. If necessary, a
fixture setup may include a data array of arbitrary type for executing the test
series for each element in the array. This will be most useful for running
screenshooting tests with both Pixman- and GL-renderers.
The new harness outputs TAP formatted results into stdout. Meson is not
switched to consume TAP yet though, because it would require a Meson version
requirement bump and would not have any benefits at this time. OTOH outputting
TAP is trivial and sets up a clear precedent of random test chatter belonging
to stderr.
This commit migrates only few tests to actually make use of the new features:
roles is a basic client test, subsurface-shot is a client test that
demonstrates the fixture array, and plugin-registry is a plugin test. The rest
of the tests will be migrated later.
Once all tests are migrated, we can remove the test-specific setup from
meson.build, leaving only the actual build instructions in there.
The not migrated tests and stand-alone tests suffer only a minor change: they
no longer fork() for each TEST(), otherwise they keep running as before.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
5 years ago
|
|
|
]
|
|
|
|
|
|
|
|
|
|
if get_option('renderer-gl')
|
|
|
|
|
tests += {
|
|
|
|
|
'name': 'vertex-clip',
|
|
|
|
|
'link_with': plugin_gl,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
endif
|
|
|
|
|
|
|
|
|
|
if get_option('color-management-lcms')
|
|
|
|
|
if not dep_lcms2.found()
|
|
|
|
|
error('color-management-lcms tests require lcms2 which was not found. Or, you can use \'-Dcolor-management-lcms=false\'.')
|
|
|
|
|
endif
|
|
|
|
|
tests += [
|
|
|
|
|
{
|
|
|
|
|
'name': 'color-icc-output',
|
|
|
|
|
'dep_objs': [ dep_libm, dep_lcms_util ]
|
|
|
|
|
},
|
|
|
|
|
{ 'name': 'color-metadata-parsing' },
|
|
|
|
|
{
|
|
|
|
|
'name': 'lcms-util',
|
|
|
|
|
'dep_objs': [ dep_lcms_util ]
|
|
|
|
|
},
|
|
|
|
|
]
|
|
|
|
|
endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
tests_standalone = [
|
|
|
|
|
['config-parser', [], [ dep_zucmain ]],
|
|
|
|
|
['timespec', [], [ dep_zucmain ]],
|
|
|
|
|
['zuc',
|
|
|
|
|
[
|
|
|
|
|
'../tools/zunitc/test/fixtures_test.c',
|
|
|
|
|
'../tools/zunitc/test/zunitc_test.c'
|
|
|
|
|
],
|
|
|
|
|
[ dep_zucmain ]
|
|
|
|
|
],
|
|
|
|
|
]
|
|
|
|
|
|
|
|
|
|
if get_option('xwayland')
|
|
|
|
|
d = dependency('x11', required: false)
|
|
|
|
|
if not d.found()
|
|
|
|
|
error('Xwayland tests require libX11 which was not found. Or, you can use \'-Dxwayland=false\'.')
|
|
|
|
|
endif
|
|
|
|
|
tests += {
|
|
|
|
|
'name': 'xwayland',
|
|
|
|
|
'dep_objs': d,
|
|
|
|
|
}
|
|
|
|
|
endif
|
|
|
|
|
|
|
|
|
|
# Manual test plugin, not used in the automatic suite
|
|
|
|
|
surface_screenshot_test = shared_library(
|
|
|
|
|
'test-surface-screenshot',
|
|
|
|
|
'surface-screenshot-test.c',
|
|
|
|
|
include_directories: common_inc,
|
|
|
|
|
dependencies: [ dep_libweston_private, dep_libshared ],
|
|
|
|
|
name_prefix: '',
|
|
|
|
|
install: false,
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
if get_option('shell-ivi')
|
|
|
|
|
ivi_layout_test_plugin = shared_library(
|
|
|
|
|
'test-ivi-layout',
|
|
|
|
|
[
|
|
|
|
|
'ivi-layout-test-plugin.c',
|
|
|
|
|
weston_test_server_protocol_h,
|
|
|
|
|
weston_test_protocol_c,
|
|
|
|
|
],
|
|
|
|
|
include_directories: common_inc,
|
|
|
|
|
dependencies: [ dep_libweston_private, dep_libexec_weston ],
|
|
|
|
|
name_prefix: '',
|
|
|
|
|
install: false,
|
|
|
|
|
)
|
|
|
|
|
env_modmap += 'test-ivi-layout.so=' + ivi_layout_test_plugin.full_path() + ';'
|
|
|
|
|
|
|
|
|
|
tests += [
|
|
|
|
|
{
|
|
|
|
|
'name': 'ivi-layout-client',
|
|
|
|
|
'sources': [
|
|
|
|
|
'ivi-layout-test-client.c',
|
|
|
|
|
ivi_application_client_protocol_h,
|
|
|
|
|
ivi_application_protocol_c,
|
|
|
|
|
],
|
|
|
|
|
'test_deps': [ ivi_layout_test_plugin ],
|
|
|
|
|
},
|
|
|
|
|
{ 'name': 'ivi-layout-internal', },
|
|
|
|
|
{
|
|
|
|
|
'name': 'ivi-shell-app',
|
|
|
|
|
'sources': [
|
|
|
|
|
'ivi-shell-app-test.c',
|
|
|
|
|
ivi_application_client_protocol_h,
|
|
|
|
|
ivi_application_protocol_c,
|
|
|
|
|
],
|
|
|
|
|
},
|
|
|
|
|
]
|
|
|
|
|
endif
|
|
|
|
|
|
|
|
|
|
test_config_h = configuration_data()
|
|
|
|
|
test_config_h.set_quoted('WESTON_TEST_REFERENCE_PATH', meson.current_source_dir() + '/reference')
|
|
|
|
|
test_config_h.set_quoted('WESTON_MODULE_MAP', env_modmap)
|
|
|
|
|
test_config_h.set_quoted('WESTON_DATA_DIR', join_paths(meson.current_source_dir(), '..', 'data'))
|
|
|
|
|
test_config_h.set_quoted('TESTSUITE_PLUGIN_PATH', exe_plugin_test.full_path())
|
|
|
|
|
test_config_h.set10('WESTON_TEST_SKIP_IS_FAILURE', get_option('test-skip-is-failure'))
|
|
|
|
|
configure_file(output: 'test-config.h', configuration: test_config_h)
|
|
|
|
|
|
tests: thread-based client harness
This replaces the old test harness with a new one.
The old harness relied on fork()'ing each test which makes tests independent,
but makes debugging them harder. The new harness runs client code in a thread
instead of a new process. A side-effect of not fork()'ing anymore is that any
failure will stop running a test series short. Fortunately we do not have any
tests that are expected to crash or fail.
The old harness executed 'weston' from Meson, with lots of setup as both
command line options and environment variables. The new harness executes
wet_main() instead: the test program itself calls the compositor main function
to execute the compositor in-process. Command line arguments are configured in
the test program itself, not in meson.build. Environment variables aside, you
are able to run a test by simply executing the test program, even if it is a
plugin test.
The new harness adds a new type of iteration: fixtures. For now, fixtures are
used to set up the compositor for tests that need a compositor. If necessary, a
fixture setup may include a data array of arbitrary type for executing the test
series for each element in the array. This will be most useful for running
screenshooting tests with both Pixman- and GL-renderers.
The new harness outputs TAP formatted results into stdout. Meson is not
switched to consume TAP yet though, because it would require a Meson version
requirement bump and would not have any benefits at this time. OTOH outputting
TAP is trivial and sets up a clear precedent of random test chatter belonging
to stderr.
This commit migrates only few tests to actually make use of the new features:
roles is a basic client test, subsurface-shot is a client test that
demonstrates the fixture array, and plugin-registry is a plugin test. The rest
of the tests will be migrated later.
Once all tests are migrated, we can remove the test-specific setup from
meson.build, leaving only the actual build instructions in there.
The not migrated tests and stand-alone tests suffer only a minor change: they
no longer fork() for each TEST(), otherwise they keep running as before.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
5 years ago
|
|
|
foreach t : tests
|
|
|
|
|
t_name = 'test-' + t.get('name')
|
|
|
|
|
t_sources = t.get('sources', [t.get('name') + '-test.c'])
|
|
|
|
|
t_sources += weston_test_client_protocol_h
|
|
|
|
|
|
|
|
|
|
t_deps = [ dep_test_client, dep_libweston_private_h ]
|
|
|
|
|
t_deps += t.get('dep_objs', [])
|
|
|
|
|
|
|
|
|
|
run_exclusive = t.get('run_exclusive', false)
|
|
|
|
|
|
tests: thread-based client harness
This replaces the old test harness with a new one.
The old harness relied on fork()'ing each test which makes tests independent,
but makes debugging them harder. The new harness runs client code in a thread
instead of a new process. A side-effect of not fork()'ing anymore is that any
failure will stop running a test series short. Fortunately we do not have any
tests that are expected to crash or fail.
The old harness executed 'weston' from Meson, with lots of setup as both
command line options and environment variables. The new harness executes
wet_main() instead: the test program itself calls the compositor main function
to execute the compositor in-process. Command line arguments are configured in
the test program itself, not in meson.build. Environment variables aside, you
are able to run a test by simply executing the test program, even if it is a
plugin test.
The new harness adds a new type of iteration: fixtures. For now, fixtures are
used to set up the compositor for tests that need a compositor. If necessary, a
fixture setup may include a data array of arbitrary type for executing the test
series for each element in the array. This will be most useful for running
screenshooting tests with both Pixman- and GL-renderers.
The new harness outputs TAP formatted results into stdout. Meson is not
switched to consume TAP yet though, because it would require a Meson version
requirement bump and would not have any benefits at this time. OTOH outputting
TAP is trivial and sets up a clear precedent of random test chatter belonging
to stderr.
This commit migrates only few tests to actually make use of the new features:
roles is a basic client test, subsurface-shot is a client test that
demonstrates the fixture array, and plugin-registry is a plugin test. The rest
of the tests will be migrated later.
Once all tests are migrated, we can remove the test-specific setup from
meson.build, leaving only the actual build instructions in there.
The not migrated tests and stand-alone tests suffer only a minor change: they
no longer fork() for each TEST(), otherwise they keep running as before.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
5 years ago
|
|
|
t_exe = executable(
|
|
|
|
|
t_name,
|
|
|
|
|
t_sources,
|
|
|
|
|
c_args: [
|
|
|
|
|
'-DTHIS_TEST_NAME="' + t_name + '"',
|
|
|
|
|
],
|
|
|
|
|
build_by_default: true,
|
|
|
|
|
include_directories: common_inc,
|
|
|
|
|
dependencies: t_deps,
|
|
|
|
|
link_with: t.get('link_with', []),
|
tests: thread-based client harness
This replaces the old test harness with a new one.
The old harness relied on fork()'ing each test which makes tests independent,
but makes debugging them harder. The new harness runs client code in a thread
instead of a new process. A side-effect of not fork()'ing anymore is that any
failure will stop running a test series short. Fortunately we do not have any
tests that are expected to crash or fail.
The old harness executed 'weston' from Meson, with lots of setup as both
command line options and environment variables. The new harness executes
wet_main() instead: the test program itself calls the compositor main function
to execute the compositor in-process. Command line arguments are configured in
the test program itself, not in meson.build. Environment variables aside, you
are able to run a test by simply executing the test program, even if it is a
plugin test.
The new harness adds a new type of iteration: fixtures. For now, fixtures are
used to set up the compositor for tests that need a compositor. If necessary, a
fixture setup may include a data array of arbitrary type for executing the test
series for each element in the array. This will be most useful for running
screenshooting tests with both Pixman- and GL-renderers.
The new harness outputs TAP formatted results into stdout. Meson is not
switched to consume TAP yet though, because it would require a Meson version
requirement bump and would not have any benefits at this time. OTOH outputting
TAP is trivial and sets up a clear precedent of random test chatter belonging
to stderr.
This commit migrates only few tests to actually make use of the new features:
roles is a basic client test, subsurface-shot is a client test that
demonstrates the fixture array, and plugin-registry is a plugin test. The rest
of the tests will be migrated later.
Once all tests are migrated, we can remove the test-specific setup from
meson.build, leaving only the actual build instructions in there.
The not migrated tests and stand-alone tests suffer only a minor change: they
no longer fork() for each TEST(), otherwise they keep running as before.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
5 years ago
|
|
|
install: false,
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
test(
|
|
|
|
|
t.get('name'),
|
|
|
|
|
t_exe,
|
|
|
|
|
depends: t.get('test_deps', []),
|
|
|
|
|
timeout: 120,
|
|
|
|
|
protocol: 'tap',
|
|
|
|
|
is_parallel: not run_exclusive
|
|
|
|
|
)
|
tests: thread-based client harness
This replaces the old test harness with a new one.
The old harness relied on fork()'ing each test which makes tests independent,
but makes debugging them harder. The new harness runs client code in a thread
instead of a new process. A side-effect of not fork()'ing anymore is that any
failure will stop running a test series short. Fortunately we do not have any
tests that are expected to crash or fail.
The old harness executed 'weston' from Meson, with lots of setup as both
command line options and environment variables. The new harness executes
wet_main() instead: the test program itself calls the compositor main function
to execute the compositor in-process. Command line arguments are configured in
the test program itself, not in meson.build. Environment variables aside, you
are able to run a test by simply executing the test program, even if it is a
plugin test.
The new harness adds a new type of iteration: fixtures. For now, fixtures are
used to set up the compositor for tests that need a compositor. If necessary, a
fixture setup may include a data array of arbitrary type for executing the test
series for each element in the array. This will be most useful for running
screenshooting tests with both Pixman- and GL-renderers.
The new harness outputs TAP formatted results into stdout. Meson is not
switched to consume TAP yet though, because it would require a Meson version
requirement bump and would not have any benefits at this time. OTOH outputting
TAP is trivial and sets up a clear precedent of random test chatter belonging
to stderr.
This commit migrates only few tests to actually make use of the new features:
roles is a basic client test, subsurface-shot is a client test that
demonstrates the fixture array, and plugin-registry is a plugin test. The rest
of the tests will be migrated later.
Once all tests are migrated, we can remove the test-specific setup from
meson.build, leaving only the actual build instructions in there.
The not migrated tests and stand-alone tests suffer only a minor change: they
no longer fork() for each TEST(), otherwise they keep running as before.
Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
5 years ago
|
|
|
endforeach
|
|
|
|
|
|
|
|
|
|
# FIXME: the multiple loops is lame. rethink this.
|
|
|
|
|
foreach t : tests_standalone
|
|
|
|
|
if t[0] != 'zuc'
|
|
|
|
|
srcs_t = [
|
|
|
|
|
'@0@-test.c'.format(t.get(0)),
|
|
|
|
|
weston_test_client_protocol_h,
|
|
|
|
|
]
|
|
|
|
|
else
|
|
|
|
|
srcs_t = []
|
|
|
|
|
endif
|
|
|
|
|
|
|
|
|
|
if t.length() > 1
|
|
|
|
|
srcs_t += t.get(1)
|
|
|
|
|
endif
|
|
|
|
|
|
|
|
|
|
if t.length() > 2
|
|
|
|
|
deps_t = t[2]
|
|
|
|
|
else
|
|
|
|
|
deps_t = [ dep_test_client ]
|
|
|
|
|
endif
|
|
|
|
|
|
|
|
|
|
exe_t = executable(
|
|
|
|
|
'test-@0@'.format(t.get(0)),
|
|
|
|
|
srcs_t,
|
|
|
|
|
build_by_default: true,
|
|
|
|
|
include_directories: common_inc,
|
|
|
|
|
dependencies: deps_t,
|
|
|
|
|
install: false,
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
# matrix-test is a manual test
|
|
|
|
|
if t[0] != 'matrix'
|
|
|
|
|
test(t.get(0), exe_t)
|
|
|
|
|
endif
|
|
|
|
|
endforeach
|
|
|
|
|
|
|
|
|
|
if get_option('backend-drm')
|
|
|
|
|
executable(
|
|
|
|
|
'setbacklight',
|
|
|
|
|
'setbacklight.c',
|
|
|
|
|
dependencies: [
|
|
|
|
|
dep_backlight,
|
|
|
|
|
dep_libdrm,
|
|
|
|
|
dependency('libudev')
|
|
|
|
|
],
|
|
|
|
|
include_directories: common_inc,
|
|
|
|
|
install: false
|
|
|
|
|
)
|
|
|
|
|
endif
|
