DataMuseum.dk

top - download

    Length: 4567 (0x11d7)
    Types: TextFile
    Names: »V«

└─⟦db1c56801⟧ Bits:30000748 8mm tape, Rational 1000, TESTMATE 2_2_0
    └─ ⟦866d14df1⟧ »DATA« 
        └─⟦97c804b2f⟧ 
            └─⟦this⟧ 

TextFile

with System;
with Po_Handle;
with Po_Conditions;
with Po_Access_Modes;
with World_Coverage_Map;
with Unit_Set_Map;

package Coverage_Data is

  -- This package provides access to the coverage data associated with a test
  -- run. The coverage data can be accessed for reading, display and additional
  -- computation.

  type Object is private;
  -- The Coverage_Data object has two components: the Unit_Set_Map and
  -- the World_Coverage_Map.

  subtype Test_Case_Handle is Po_Handle.Object;

  type Coverage_Kind is (Segment, Decision);

  function Constructor (The_Segment : System.Segment) return Object;

  procedure Destructor (Of_The_Obj : in out Object);


  function Get_Coverage_Kind (For_Obj : Object) return Coverage_Kind;
  -- Returns the kind of coverage represented by the Coverage_Data.Object


  procedure Get_Unit_Set_Map (For_Obj :        Object;
                              Into    : in out Unit_Set_Map.Object);

  -- The Unit_Set_Map contains a map of test cases to Ada units. Each Ada unit
  -- covered by a test case is found in the map element for that test case.
  -- If a test run has three test cases, then the Unit_Set_Map will have an
  -- element for each test case, where the domain of the element is the test case
  -- name, and the range is a set of Ada units covered by that test case.
  -- Subprograms for iterating through the Unit_Set_Map are found in the
  -- Unit_Set_Map package. Subprograms for iterating through the Ada unit sets
  -- are found in the Unit_Name_Set package.




  procedure Get_World_Coverage_Map (For_Obj :        Object;
                                    Into    : in out World_Coverage_Map.Object);

  -- The World_Coverage_Map is just that: a map of worlds to the coverage for
  -- that world. In a World_Coverage_Map.Object, each world in the closure of the
  -- covered units for the test run has an entry whose range is a
  -- Unit_Cover_Map.Object. The World_Coverage_Map package provides the iterator
  -- and evaluation operations used to traverse this object.

  -- The Unit_Cover_Map.Object implements a map from an Ada unit to the coverage
  -- for each subprogram in the Ada unit. The Unit_Cover_Map package provides
  -- the iterator and operations for accessing the domain and range of this map,
  -- similar to the World_Coverage_Map package. The range of the
  -- Unit_Cover_Map.Object is the Subprog_Coverage_Map.Object.

  -- The Subprog_Coverage_Map.Object maps each subprogram to its coverage data.
  -- The coverage data for a subprogram is represented by a
  -- Subprogram_Coverage_Summary.Object. Subprogram map traversal is performed
  -- using the iterator and operations declared the Subprog_Coverage_Map package.

  -- The Subprogram_Coverage_Summary.Object maintains a summary of coverage for
  -- the segments and decisions hit and missed by a test run, and a total count
  -- of the segment and decision elements in the subprogram. The summary counts
  -- are accessed with the operations found in the Subprogram_Coverage_Summary
  -- package. In addition to the summary counts, a list of each coverage element
  -- in the subprogram is maintained. These elements are of type
  -- Coverage_Element_With_Test_Case_Set.Object. The iterator and associated
  -- operations for traversing the coverage element list of a
  -- Subprogram_Coverage_Summary.Object are also provided in the
  -- Subprogram_Coverage_Summary package.

  -- Each coverage element represented by a
  -- Coverage_Element_With_Test_Case_Set.Object contains an external
  -- representation of the Diana for the represented part of the subprogram, an
  -- indication whether it is a decision, a segment or both, and a set of test
  -- cases that hit this element. A test case is inserted into an element's test
  -- case set when the execution of the test case results in the element being
  -- hit during coverage analysis. Appropriate operations for accessing the
  -- coverage element information and an iterator for the test case set are
  -- declared in the Coverage_Element_With_Test_Case package.

  package Persistent_Operations is


    procedure Get_Condition (Obj  : in     Object;
                             Into : in out Po_Conditions.Condition);


    procedure Open (The_Obj : in out Object;
                    Mode    : in     Po_Access_Modes.Modes;
                    Handle  : in     Po_Handle.Object);


    function Name (For_Obj : Object) return String;

    procedure Close (The_Obj : in out Object; Abandon : Boolean := False);

  end Persistent_Operations;


end Coverage_Data;