ACATS 4.1 User's Guide
Title Page
Contents   Index   References   Previous   Next 

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:
The ACATS user is not the implementer, so modifying the compiler is not possible;
An important part of the compiler or binder is a third party tool, so adding an option is not feasible;
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.

Contents   Index   References   Previous   Next