Add --exact, --no-deps, or --no-prune to trim tests as needed

By explicitly specifying --exact, --no-deps, or --no-prune these tests
are now immune from any change in the default behavior of "apitrace
trim". Whether --exact or --auto is the default, these tests will get
exactly the behavior they want.

Rework testing of trimming of operations with no side effects

The previous test was bogus. The only call it trimmed was glxSwapBuffers
which is actually invalid, (this call definitely does have side effects,
but can easily be trimmed if desired with --trim-spec=drawing).

The new testing here uses a trace from a new program, (source
included), called few-side-effects which simply makes various calls
that do not have side effects, (such as glGetIntegerv and
glIsEnabled).

Then, the testing exercises the two independent mechanisms available
for trimming calls without side effects:

    trim --prune

Trims calls within the user-specified range without side
effects.

    trim --deps --trim-spec=no-side-effects

Trims calls outside the user-specific range without side
effects.

Three new tests are added here, one for each of the above cases and
one for both combined, (prune, trim, and prune-and-trim).

cli: Add test for "apitrace trim" with both --calls and --frames

This case was triggering a bug in "apitrace trim" where it would
incorrectly bail out after going past the last specified call (or
frame) without noticing that there were still further frames (or
calls) to be processed.

Fix test to correctly use cmake feature to find python executable

On my system, at least, there was no ${python} variable set, so the
tests for PIL were incorrectly failing, (such that many tests were not
being run at all).

trim-range: Stress the call-set parser just a tiny bit more.

We specify an equivalent range, but in a slightly more complex way for
better testing.

Add a tri glsl sample.

Track rename of "retrace" to "replay" within apitrace.

Verifying that everything still passes after the rename.

Signed-off-by: José Fonseca <jose.r.fonseca@gmail.com>

Be more lenient with shader matching.

d3d*: Don't set the BufferDesc dimmension.

cli: Add testing for recently-added "apitrace trim --trim-spec"

Each test here is quite simple. Without doing any image-based
verification, simply ensure that the expected calls are trimmed with
each different invocation of --trim-spec.

trim_stress: Only look at files matching [0-9]*.png when counting references

If there are any differences from a previous run, there will be
several additional image files left around, (.thumb.png, etc.). And we
don't want to count those.

trim_stress: Also test any traces in the directory trim_stress/local

This is useful for performing testing on traces that are too large to
be considered for include in git, or for traces that cannot be shared
due to proprietary contents.

trim_stress: Fail test at first frame which doesn't match reference

When stress-testing large traces, it's inefficient to work through the
entire trace before reporting an error that occurred in one of the
first frames.

Instead, check each frame one at a time immediately as each rendered
frame becomes available. Then fail the test at the first mismatched
frame.

Fix test to correctly use cmake feature to find python executable

On my system, at least, there was no ${python} variable set, so the
tests for PIL were incorrectly failing, (such that many tests were not
being run at all).

Signed-off-by: José Fonseca <jfonseca@vmware.com>

Merge branch 'trim-auto'

Add d3d8 scnapshot. Be consistent with swapeffect.

Don't run tests that depend on PIL.

Unfortunately it is non-standard and binaries hard to get by on MacOSX.

apps: Check d3dretrace snapshots.

apps/d3d8: Be precise with window size and format.

cli: Use python differ. Fix failures.

Tests were failure due to off by one difference in line nos.

Update examples to use DXGI.

That's more common and challenging for apitrace.

apps: Be verbose when tracing.

cli: Use difflib to compare expected vs output.

cli: Don't rely on image generation for diff-image tests.

Use static images instead.

trim: Update for --exact -> --auto

Track updates to "apitrace trim" which no longer drops glBindTexture calls

We still aren't sure *why* apitrace trim should have to leave these
calls around, but we have a trace which only passes the
trim-stress-test if these calls are untrimmed. While that mystery
waits to be solved, make the test here compatible with the current
behavior.

glxsimple: Introduce an inter-frame texture dependency to exercise trim code

The previous glxsimple program was too simple as each frame was
entirely self-contained, (textures were created, initialized, and
referenced only within single frames).

For more realistic trimming, we create and initialize a texture in one
frame, then reference that texture in a later frame. This is a better
test to ensure that when trimming the first frame the texture creation
and initialization is not discarded.

Add stress tests from "apitrace trim".

The trim_stress directory makes it simple to stress test "apitrace
trim" by simply dropping new trace files into this directory. The
stress testing ensures that creating a new trace by trimming to a
single frame still generates the same image as that frame from the
original trace. It performs this test exhaustively for each frame of
each trace.

This testing ensures that trimming doesn't break the rendered results
of any frame. It does not do anything to test that trimming actually
discards anything. So the existing cli tests are still
independendently useful for verifying that expected content is
discarded.

Add a couple of tests for the --frames option of "apitrace trim"

Recent versions of apitrace added this new command-line option, so
it's useful to test that it actually works here.

Add test to ensure that unused shaders are dropped from a trace.

This tests functionality which was added even more recently to
"apitrace trim".

cli_driver: Rework driver script to preserve json-embedded whitespace

Previously, the line read from the script was being passed through
python's string.split() and string.join() functions. This was causing
sequences of successive whitespace characters to be collapsed down to
a single space, (in turn causing spurious failures when comparing
against expected output with successive whitespace).

Rework the driver to avoid munging the line past the separation of the
first command word.

Add test to ensure that unused textures are dropped from a trace.

This tests functionality recently added to "apitrace trim".

trim-head: New test to ensure "apitrace trim" drops all calls after range

This test ensures that all calls beyond the user-specified range are
correctly dropped. It also ensures that uninteresting calls are
trimmed, (since the glxsimple trace includes many of those).

Make glxsimple loop over all drawing methods multiple times

We now have 3 different drawing methods, each performed two times, and
in a total of 6 different colors. Looping over theese things twice
means that we can trim out a single frame of any one method and ensure
that "apitrace trim" has some non-trivial trimming to do both before
and after the frame of interest.

Add a third frame, this time drawing with a texture.

This will allow us to test that "apitrace trim" can trim out unused
textures.

glxsimple: Add a second frame drawing a solid color with GLSL.

This will allow us to test that we can trim out unused shaders.

Add the source of a very simple program using OpenGL through GLX.

We'll use this program to generate traces for use in the test suite,
(to exercise using "apitrace trim" to trim away unused textures,
shader programs, etc.).

There is a Makefile here, for convenience to any test writers wanting
to expand this program. Note that this Makefile us intentionally not
integrated with the cmake setup of the apitrace-tests project. That's
because it is not expected that this test program should be built or
run as a standard part of the test suite. Instead, useful trace files
generated from glxsimple will be directly committed to the
apitrace-tests repository.

cli: Use new --call-nos=no call to "apitrace dump-images" for consistent results

Recent "apitrace trim" is now dropping uninteresting calls by
default. This means that the call numbers of rendering operations are
changing. Consequently, image comparisons were failing not due to
image-content differences, but simply because the filenames (with
embedded call numbers in them) no longer matched.

We can avoid this problem by using the --call-nos=no option which was
added to "apitrace dump-images" in very recent versions.

Print commands to be executed by cli_driver.py

These aren't made visible unless CTEST_OUTPUT_ON_FAILURE in set, and
in that case it's quite convenient to see what the test was doing when
it failed.

Add a test to ensure "apitrace trim" performs proper dependency checking

Here we trim a trace by specifying (with --calls) only the final
glXSwapBuffers and then test that we can still produce a matching
image from the trace. This will only succeed if "apitrace trim"
performs dependency checking and includes many previous calls.

Of course, historically "apitrace trim" performed no such dependency
checks, so older versions of apitrace are expected to fail this test.

Add some comments to the recently-added cli tests.

It's easy enough to ignore lines starting with a '#' and that lets us
make these tests more self-documenting.

Add a test that "apitrace diff-images" flags mismatching images.

With this test we add a new EXPECT_FAILURE: attribute to the script
syntax to indicate that a particular apitrace command in the script is
expected to fail. This requires manually invoking the Popen
constructor rather than using subprocess.check_output, (which is
*close* to what we need but fails to assign the output when raising an
exception).

We also remove the globbing from the CMakeLists.txt file to get a
manual ordering of the tests (rather than executing in alphabetic
order).

Add a new 'cli' subdirectory for higher-level testing of apitrace CLI.

As described in the README, this new directory is for tests that
perform higher-level testing of the apitrace command-line interface
than either of the existing traces or apps directories.

Compared to traces, these new tests can do higher-level things like
dumping images from traces, comparing images, etc.

Compared to apps, these tests are intended to be portable across
multiple targets. (This isn't actually the case yet because commands
like "apitrace dump-images" currently work only on OpenGL. Also, even
when that is fixed, we will also need to then extend these tests to
have traces for each supported target for testing.)

In this commit, the only new test exercises "apitrace dump-images" and
"apitrace diff-images" on a simple trace file with one frame,
(tri.trace grabbed from apps/gl).

Add more README documentation on how existing test drivers are structured.

More than once, I've reverse-engineered how the test suite uses test
drivers (app_driver.py and tool_driver.py) to invoke scripts within
the apps/ and traces/ directory. In order to save my future-self some
work in doing this yet again, I've written some documentation in
README.markdown in each directory.

Hopefully this documentation will be useful for anyone wanting to
write additional tests.

apps/d3d11: Comprehensive test.

tracematch: Fix array parsing.

Update readme.

Remove left over debug statement.

Add a shader d3d9 tri test.

Precise d3d8-10.1 reference traces.

Fix parsing of floats without '.'

For example "1e+10"

Accept comments in reference traces.

Handle DOS line endings.

Retrace d3d8.

gl/map_buffer: Exit 1 when GL_ARB_map_buffer_range is not found.

Only invoke pkg_check_modules when PKG_CONFIG_FOUND is true.

Use clang on MacOSX.

Drop pragmas.

Rename checker.py -> tracematch.py

Improve gl map buffer test.

Use the new trace checker.

Further improvements to checker.

Improve checker.

Use 'apitrace retrace'

Specify rendertarget view descriptions.

To exercise unions.

Add new retrace apis.

Add a d3d10 level 9 test case.

Update state workarounds.

Test trimming.

Make tri_glsl test robust against attribute location changes.

Update for floating point precision changes.

Propagate apitrace trace error codes.

Ensure feature level 10.0 at minimum.

Allow to build samples without apitrace source tree.

Allow to build d3d samples independently of apitrace source.

Rename hlsl d3dcommon.

Attempt of a d3d11.1 test.

d3d10.1 sample.

Put HLSL shaders into their own directory.

Make OpenGL/GLUT/GLEW optional.

d3d11 test.

Cleanup d3d10 test.

Precompile d3d10 shader.

Fixup d3d10 test.

Prototype of d3d10 sample app.

Compiles but untested.

D3D7 sample.

D3D8 sample app.

Simple D3D9 app.

Handle CRLF lines in tool_driver.py

Update reference for GLboolean update.

Pragmas.

Bit more work on the checker.

Add .gitignore.

Test callsets.

Dump verbosely.

Make it easier to add more tests.

Better code organization.

Split the driver code.

Better checking (WIP).

Make PIL optional.