ACATS 4.1 User's Guide
6.2.2 Creating an Event Trace directly by the implementation
Creating an event trace for a particular implementation
is a problem for the ACATS user and their implementer (the ACATS user
need not be an implementer, of course). We can only give general guidance
on approaching this problem.
One approach is the for implementer to directly add
event trace creation to their tools. In this approach, options would
be added to the compiler and binder that would write events to an event
trace file. The ACATS user would set the Generate_Event_Trace_File constant
in Report.A to True. The user would use this new compiler and binder
option to write events to ETrace.csv, as will the Report package. At
strategic times, the ETrace.csv file could be copied to a new name in
order to keep its size manageable.
This approach is likely to be the easiest, as all
of the information needed to create an event is likely to be available
in a compiler error handler. Moreover, writing an event is an easy operation
in Ada (see Report.Put_Event_Trace) and likely most other languages.
And by directly including this capability in the compiler, it is available
to all users and likely needs little modification even if the compiler
error handling is changed significantly. The effort needed is small and
one-time.
However, this approach
may not work in some cases:
1.
The ACATS user is not the implementer, so modifying the compiler is not
possible;
2.
An important part of the compiler or binder is a third party tool, so
adding an option is not feasible;
3.
The ACATS testing target does not have a file system, so having report
write an event trace is not possible.
In each of these cases, the technique outlined in
the next section is preferable.
Note that in case 2, not all parts of an Ada compilation
system need to be able to generate an event trace. Any part that can
fail only in the case of a bug elsewhere in the system (that is, does
not diagnose errors in the Ada code) can be ignored for the purposes
of an event trace. For instance, the use of a system-provided linker
after the completion of the bind step need not be reflected in an event
trace, as it has no role in the enforcement of Ada Post-Compilation Rules.
For more on this topic, see
6.2.1.
