The cover Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The cover Reference Manual

This is the cover Reference Manual, generated automatically by Declt version 2.4 patchlevel 1 "Will Decker" on Mon Apr 08 13:52:14 2019 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

;This is the September 15, 1991 version of
;the on-line documentation for Richard Waters' test case coverage checker.

The COVER system: Determining the Coverage of a Test Suite

Richard C. Waters

MIT AI Laboratory
545 Technology Sq.
Cambridge MA 02139 
Dick@AI.MIT.EDU

Mitsubishi Electric Research Laboratories
201 Broadway
Cambridge MA 02139
Dick@MERL.COM

The value of a suite of test cases depends critically on its
coverage.  Ideally a suite should test every facet of the
specification for a program and every facet of the algorithms used to
implement the specification.  Unfortunately, there is no practical way
to be sure that complete coverage has been achieved.  However,
something should be done to assess the coverage of a test suite,
because a test suite with poor coverage has little value.

A traditional approximate method of assessing the coverage of a test
suite is to check that every condition tested by the program is
exercised.  For every predicate in the program, there should be at
least one test case that causes the predicate to be true and one that
causes it to be false.  Consider the function MY* below which uses a
convoluted algorithm to compute the product of two numbers.

(DEFUN MY* (X Y)
  (LET ((SIGN 1))
    (WHEN (MINUSP X)
      (SETQ SIGN (- SIGN))
      (SETQ X (- X)))
    (WHEN (MINUSP Y)
      (SETQ SIGN (- SIGN))
      (SETQ Y (- X)))
    (* SIGN X Y)))

The function my* contains two predicates, (MINUSP X) and
(MINUSP Y), which lead to four conditions: X is negative,
X is not negative, Y is negative, and Y is not
negative.  To be at all thorough, a test suite must contain tests
exercising all four of these conditions.  For instance, any test suite
that fails to exercise the condition where Y is negative will
fail to detect the bug in the next to last line of the function.

(As an example of the fact that covering all the conditions in a
program does not guarantee that every facet of either the algorithm or
the specification will be covered, consider the fact that the two test
cases (MY* 2.1 3) and (MY* -1/2 -1/2) cover all four
conditions.  However, they do not detect the bug on the next to last
line and they do not detect the fact that MY* fails to work on
complex numbers.)

The COVER system determines which conditions tested by a program
are exercised by a given test suite.  This is no substitute for
thinking hard about the coverage of the test suite.  However, it
provides a useful starting point and can indicate some areas where
additional test cases should be devised.

		       USER'S MANUAL FOR COVER

The functions, macros, and variables that make up the COVER
system are in a package called "COVER".  The six exported
symbols are documented below.

COVER:ANNOTATE t-or-nil

Evaluating (COVER:ANNOTATE T) triggers the processing of
function and macro definitions by the COVER system.  Each
subsequent instance of DEFUN or DEFMACRO is altered by
adding annotation that maintains information about the various
conditions tested in the body.

Evaluating (COVER:ANNOTATE NIL) stops the special processing of
function and macro definitions.  Subsequent definitions are not
annotated.  However, if a function or macro that is currently
annotated is redefined, the new definition is annotated as well.

The macro COVER:ANNOTATE should only be used as a top-level
form.  When annotation is triggered, a warning message is printed, and
T is returned.  Otherwise, NIL is returned.

(COVER:ANNOTATE T) => t ; after printing:
;;; Warning: Coverage annotation applied.


COVER:FORGET-ALL

This function, which always returns t, has the effect of removing all
coverage annotation from every function and macro.  It is appropriate
to do this before completely recompiling the system being tested or
before switching to a different system to be tested.

COVER:RESET

Each condition tested by an annotated function and macro is associated
with a flag that trips when the condition is exercised.  The function
COVER:RESET resets all these flags, and returns T.  It is
appropriate to do this before rerunning a test suite to reevaluate
its coverage.

COVER:REPORT &KEY FN OUT ALL

This function displays the information maintained by COVER,
returning no values.  FN must be the name of an annotated
function or macro.  If FN is specified, a report is printed
showing information about that function or macro only.  Otherwise,
reports are printed about every annotated function and macro.

OUT, which defaults to *STANDARD-OUTPUT*,
must either be an output stream or the name of a file.  It specifies
where the reports should be printed.

If ALL, which defaults to NIL, is non-null then the
reports printed contain information about every condition.  Otherwise,
the reports are abbreviated to highlight key conditions that have not
been exercised.

COVER:*LINE-LIMIT* default value 75

The output produced by COVER:REPORT is truncated to ensure that
it is no wider than COVER:*LINE-LIMIT*.

			      AN EXAMPLE

Suppose that the function MY* has been annotated and that no other
functions or macros have been annotated.  The following example
illustrates the operation of COVER and the reports printed by
COVER:REPORT.

(setq cover:*line-limit* 43) => 43

(cover:reset) => T

(cover:report) => ; after printing:
;- :REACH (DEFUN MY* (X Y))  <1>

(my* 2 2) => 4

(cover:report) => ; after printing:
;+ :REACH (DEFUN MY* (X Y))  <1>
; + :REACH (WHEN (MINUSP X) (SETQ S  <2>
;  - :NON-NULL (MINUSP X)  <4>
; + :REACH (WHEN (MINUSP Y) (SETQ S  <6>
;  - :NON-NULL (MINUSP Y)  <8>

(my* -2 2) => -4

(cover:report) => ; after printing:
;+ :REACH (DEFUN MY* (X Y))  <1>
; + :REACH (WHEN (MINUSP Y) (SETQ S  <6>
;  - :NON-NULL (MINUSP Y)  <8>

(cover:report :all t) => ; after printing:
;+ :REACH (DEFUN MY* (X Y))  <1>
; + :REACH (WHEN (MINUSP X) (SETQ S  <2>
;  + :NON-NULL (MINUSP X)  <4>
;  + :NULL (MINUSP X)  <5>
; + :REACH (WHEN (MINUSP Y) (SETQ S  <6>
;  - :NON-NULL (MINUSP Y)  <8>
;  + :NULL (MINUSP Y)  <9>

Each line in a report contains three pieces of information about a
point in a definition: +/- specifying that the point
either has (+) or has not (-) been exercised, a message
indicating the physical and logical placement of the point in the
definition, and in angle brackets < >, an integer that is a
unique identifier for the point.  Indentation is used to indicate that
some points are subordinate to others in the sense that the
subordinate points cannot be exercised without also exercising their
superiors.  The order of the lines of the report is the same as the
order of the points in the definition.

Each message contains a label (e.g., :REACH, :NULL) and a
piece of code.  There is a point labeled :REACH corresponding to
each definition as a whole and each conditional form within each
definition.  Subordinate points corresponding to the conditions a
conditional form tests are grouped under the point corresponding to
the form.  As discussed in detail in the next subsection, the messages
for the subordinate points describe the situations in which the
conditions are exercised.  Lines that would otherwise be too long to
fit on one line have their messages truncated (e.g., points <2>
and <6>).

The first three reports are abbreviated based on two principles.
First, if a point P and all of its subordinates have been exercised,
then P and all of its subordinates are omitted from the report.
This is done to focus the user's attention on the points that have not
been exercised.

Second, if a point P has not been exercised, then all of the points
subordinate to it are omitted from the report.  This reflects the fact
that it is not possible for any of these subordinate points to have
been exercised and one cannot devise a test case that exercises any of
the subordinate points without first figuring out how to exercise P.

An additional complicating factor is that COVER operates in an
incremental fashion and does not, in general, have full information
about the subordinates of points that have not been exercised.  As a
result, it is not always possible to present a complete report.
However, one can have total confidence that if the report says that
every point has been exercised, this statement is based on complete
information.

The first report in shows that none of the points
within MY* has been exercised.  The second report displays most
of the points in MY*, to set the context for the two points that
have not been exercised.  The third report omits <2> and its
subordinates, since they have all been exercised.  The fourth report
shows a complete report corresponding to the third abbreviated report.

COVER:FORGET &rest ids

This function gives the user greater control over the reports produced
by COVER:REPORT.  Each ID must be an integer identifying a point.  All
information about the specified points (and their subordinates) is
forgotten.  From the point of view of COVER:REPORT, the effect is as
if the points never existed.  (A forgotten point can be retrieved by
reevaluating or recompiling the function or macro definition
containing it.)  The example below, which follows on after the end of
the example above, shows the action of COVER:FORGET.

(cover:forget 6) => T

(cover:report :all t) => ; after printing:
;+ :REACH (DEFUN MY* (X Y))  <1>
; + :REACH (WHEN (MINUSP X) (SETQ S  <2>
;  + :NON-NULL (MINUSP X)  <4>
;  + :NULL (MINUSP X)  <5>

(cover:report) =>  after printing
;All points exercised.

The abbreviated report above does not describe any points, because
every point in MY* that has not been forgotten has been
exercised.  It is appropriate to forget a point if there is some
reason that no test case can possibly exercise the point.  However, it
is much better to write your code so that every condition can be
tested.

(Point numbers are assigned based on the order in which points are
entered into COVER's database.  In general, whenever a
definition is reevaluated or recompiled, the numbers of the points
within it change.)

		 THE WAY CONDITIONALS ARE ANNOTATED



(in-package "USER")

(require "COVER" ...)

(defmacro maybe+ (x y)
  `(if (numberp ,x) (+ ,x ,y)))

(cover:annotate t)

(defmacro maybe- (x y)
  `(if (numberp ,x) (- ,x ,y)))

(defun g (x y)
   (cond ((and (null x) y) y)
         (y (case y
              (1 (maybe- x y))
              (2 (maybe+ x y))))))

(cover:annotate nil)

(defun h (x y) ...)

(cover:reset)

(run-tests)

(cover:report :out "report" :all t)



;+ :REACH (DEFMACRO MAYBE- (X Y))  <1>
;+ :REACH (DEFUN G (X Y))  <2>
; + :REACH (COND ((AND # Y) Y) (Y (  <3>
;  + :REACH (AND (NULL X) Y)  <9>
;   + :FIRST-NULL (NULL X)  <11>
;   + :EVAL-ALL Y  <12>
;  + :FIRST-NON-NULL (AND (NULL X)   <5>
;  + :FIRST-NON-NULL Y  <7>
;   + :REACH (CASE Y (1 (MAYBE- X Y  <13>
;    + :SELECT 1  <15>
;     + :REACH (IF (NUMBERP X) (- X  <18>
;      + :NON-NULL (NUMBERP X)  <20>
;      + :NULL (NUMBERP X)  <21>
;    + :SELECT 2  <16>
;    - :SELECT-NONE  <17>
;  + :ALL-NULL  <8>

The above shows a file that makes use of COVER and the kind of
report that might be produced by loading the file.  Because,
MAYBE- and G are the only definitions that have been annotated,
these are the only definitions that are reported on.  The order of the
reports is the same as the order in which the definitions were
compiled.  The report on G indicates that the tests performed by
RUN-TESTS exercise most of the conditions tested by G.
However, they do not exercise the situation in which the CASE
statement is reached, but neither of its clauses is selected.

There are no points within MAYBE-, because the code for
MAYBE- does not contain any conditional forms.  It is interesting to
consider the precise points that COVER includes for G.

When COVER processes a definition, a cluster of points is generated
corresponding to each conditional form (i.e., IF, WHEN, UNTIL, COND,
CASE, TYPECASE, AND, and OR) that is literally present in the program.
In addition, points are generated corresponding to conditional forms
that are produced by macros that are annotated (e.g., the IF produced
by the MAYBE- in the first CASE clause in G). However, annotation is
not applied to conditionals that come from other sources (e.g., from
macros that are defined outside of the system being tested).  These
conditionals are omitted, because there is no reasonable way for the
user to know how they relate to the code, and therefore there is no
reasonable way for the user to devise a test case that will exercise
them.


The messages associated with a point's subordinates describe the
situations under which the subordinates are exercised.  The pattern of
messages associated with CASE and TYPECASE is illustrated by the
portion (reproduced below) of the report above that describes the CASE
in G.

;   + :REACH (CASE Y (1 (MAYBE- X Y  <13>
;    + :SELECT 1  <15>
;    + :SELECT 2  <16>
;    - :SELECT-NONE  <17>

There are two subpoints corresponding to the two clauses of the
CASE.  In addition, since the last clause does not begin with
T or OTHERWISE, there is an additional point corresponding to
the situation where none of the clauses of the CASE are
executed.

The pattern of messages associated with a COND is illustrated by the
portion of the report that describes the COND in G.

; + :REACH (COND ((AND # Y) Y) (Y (  <3>
;  + :REACH (AND (NULL X) Y)  <9>
;  + :FIRST-NON-NULL (AND (NULL X)   <5>
;  + :FIRST-NON-NULL Y  <7>
;  + :ALL-NULL  <8>

There are subordinate points corresponding to the two clauses and the
situation where neither clause is executed.  There is also a point <9>
corresponding to the AND that is the predicate of the first COND
clause.  This point is placed directly under <3>, because it is not
subordinate to any of the individual COND clauses.

The treatment of AND (and OR) is particularly interesting.
Sometimes AND is used as a control construct on a par with
COND.  In that situation, it is clear that AND should be
treated analogously to COND.  However, at other times, AND
is used to compute a value that is tested by another conditional form.
In that situation, COVER could choose to treat AND as a
simple function.  However, it is nevertheless still reasonable to
think of an AND as having conditional points that correspond to
different reasons why the AND returns a true or false value.  It
is wise to include tests corresponding to each of these different
reasons.

The pattern of messages associated with an AND is illustrated by the
portion of the report that describes the AND in G.

(cover:report :all t)
;  + :REACH (AND (NULL X) Y)  <9>
;   + :FIRST-NULL (NULL X)  <11>
;   + :EVAL-ALL Y  <12>

The final subpoint corresponds to the situation where all of the
arguments of the AND have been evaluated.  The AND then
returns whatever the final argument returned.

The example in this section illustrates a batch-oriented use of COVER.
However, COVER is most effectively used in an interactive way.  It is
recommended that you first create as comprehensive a test suite as you
can and capture it using a tool such as RT.  The tests should then be
run in conjunction with COVER and repeated reports from COVER
generated as additional tests are created until complete coverage of
conditions has been achieved.  To robustly support this mode of
operation, COVER has been carefully designed so that it will work with
batch-compiled definitions, incrementally-compiled definitions, and
interpreted definitions.

			   OBTAINING COVER

COVER is written in portable Common Lisp and has been tested in
several different Common Lisp implementations.  The source for cover
can be obtained over the INTERNET by using FTP.  Connection should be
made to FTP.AI.MIT.EDU (INTERNET number 128.52.32.6).  Login as
``anonymous'' and copy the files shown below.

    In the directory /pub/lptrs/

    cover.lisp        ; source code
    cover-test.lisp   ; test suite
    cover-doc.txt     ; brief documentation


The code for COVER and the files above are copyright 1991 by the
Massachusetts Institute of Technology, Cambridge MA.  Permission to
use, copy, modify, and distribute this software for any purpose and
without fee is hereby granted, provided that this copyright and
permission notice appear in all copies and supporting documentation,
and that the names of MIT and/or the author are not used in
advertising or publicity pertaining to distribution of the software
without specific, written prior permission.  MIT and the author make
no representations about the suitability of this software for any
purpose.  It is provided ``as is'' without express or implied
warranty.

MIT and the author disclaim all warranties with regard to this software,
including all implied warranties of merchantability and fitness.  In no
event shall MIT or the author be liable for any special, indirect or
consequential damages or any damages whatsoever resulting from loss of use,
data or profits, whether in an action of contract, negligence or other
tortious action, arising out of or in connection with the use or
performance of this software.



Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 cover

Author

Richard C. Waters

License

MIT

Description

Code coverage utility for Common Lisp

Long Description

The COVER Common Lisp test case coverage determination tool can help assess the coverage of a suite of test cases. When a suite of test cases for a program is run in conjunction with COVER, statistics are kept on which conditions in the code for the program are exercised and which are not. Based on this information, COVER can print a report of what has been missed. By devising tests that exercise these conditions, a programmer can extend the test suite so that it has more complete coverage.

Source

cover.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 cover.asd

Location

cover.asd

Systems

cover (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.2 cover/cover-package.lisp

Parent

cover (system)

Location

cover-package.lisp

Packages

cover


Previous: , Up: Lisp files   [Contents][Index]

3.1.3 cover/cover.lisp

Dependency

cover-package.lisp (file)

Parent

cover (system)

Location

cover.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Previous: , Up: Packages   [Contents][Index]

4.1 cover

Source

cover-package.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Special variables

Special Variable: *line-limit*
Package

cover

Source

cover.lisp (file)

Special Variable: *report-readable-branches*

When true, causes COVER:REPORT to print the branch information readably. This can be annoying when the symbols are not in the current package.

Package

cover

Source

cover.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Macros

Macro: annotate T-OR-NIL
Package

cover

Source

cover.lisp (file)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 Functions

Function: cover-compile-hook THUNK

Used in ASDF to enable coverage in a package being compiled

Package

cover

Source

cover.lisp (file)

Function: forget &rest IDS
Package

cover

Source

cover.lisp (file)

Function: forget-all ()
Package

cover

Source

cover.lisp (file)

Function: report &key FN OUT ALL
Package

cover

Source

cover.lisp (file)

Function: reset ()
Package

cover

Source

cover.lisp (file)


Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Special variables

Special Variable: *all*
Package

cover

Special Variable: *cgs*
Package

cover

Source

cover.lisp (file)

Special Variable: *check*
Package

cover

Source

cover.lisp (file)

Special Variable: *depth*
Package

cover

Special Variable: *done*
Package

cover

Special Variable: *fix*
Package

cover

Source

cover.lisp (file)

Special Variable: *out*
Package

cover

Special Variable: *subs*
Package

cover

Special Variable: *sup*
Package

cover


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Symbol macros

Symbol Macro: *annotating*
Package

cover

Source

cover.lisp (file)

Expansion

(cover::cgs-annotating cover::*cgs*)

Symbol Macro: *count*
Package

cover

Source

cover.lisp (file)

Expansion

(cover::cgs-count cover::*cgs*)

Symbol Macro: *hit*
Package

cover

Source

cover.lisp (file)

Expansion

(cover::cgs-hit cover::*cgs*)

Symbol Macro: *points*
Package

cover

Source

cover.lisp (file)

Expansion

(identity (cdr (cover::cgs-points-head cover::*cgs*)))

Symbol Macro: *testing*
Package

cover

Source

cover.lisp (file)

Expansion

(cover::cgs-testing cover::*cgs*)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Macros

Macro: c BODY &rest MSG
Package

cover

Source

cover.lisp (file)

Macro: c-and &rest PS
Package

cover

Source

cover.lisp (file)

Macro: c-case KEY &rest CS
Package

cover

Source

cover.lisp (file)

Macro: c-cond &rest CS
Package

cover

Source

cover.lisp (file)

Macro: c-hide B
Package

cover

Source

cover.lisp (file)

Macro: c-if PRED THEN &optional ELSE
Package

cover

Source

cover.lisp (file)

Macro: c-or &rest PS
Package

cover

Source

cover.lisp (file)

Macro: c-typecase KEY &rest CS
Package

cover

Source

cover.lisp (file)

Macro: c-unless PRED &rest ACTIONS
Package

cover

Source

cover.lisp (file)

Macro: c-when PRED &rest ACTIONS
Package

cover

Source

cover.lisp (file)

Macro: def NAME ARGS FORM
Package

cover

Source

cover.lisp (file)

Macro: defgeneric N &rest DEFGENERIC-BODY
Package

cover

Source

cover.lisp (file)

Macro: defmacro N A &body B
Package

cover

Source

cover.lisp (file)

Macro: defmethod N &rest METHOD-BODY
Package

cover

Source

cover.lisp (file)

Macro: defun N ARGL &body B
Package

cover

Source

cover.lisp (file)

Macro: in-package NAME
Package

cover

Source

cover.lisp (file)

Macro: sup-mac ()
Package

cover

Source

cover.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.4 Functions

Function: add-point P
Package

cover

Source

cover.lisp (file)

Function: add-top-point P
Package

cover

Source

cover.lisp (file)

Function: annotate1 FLAG
Package

cover

Source

cover.lisp (file)

Function: c-and0 PS
Package

cover

Source

cover.lisp (file)

Function: c-case0 CS
Package

cover

Source

cover.lisp (file)

Function: c-case1 CLAUSE
Package

cover

Source

cover.lisp (file)

Function: c-cond0 VAR CS
Package

cover

Source

cover.lisp (file)

Function: c-or0 PS
Package

cover

Source

cover.lisp (file)

Function: c0 P SUP B
Package

cover

Source

cover.lisp (file)

Function: c1 B M S
Package

cover

Source

cover.lisp (file)

Function: cgs-annotating INSTANCE
Function: (setf cgs-annotating) VALUE INSTANCE
Package

cover

Source

cover.lisp (file)

Function: cgs-count INSTANCE
Function: (setf cgs-count) VALUE INSTANCE
Package

cover

Source

cover.lisp (file)

Function: cgs-hit INSTANCE
Function: (setf cgs-hit) VALUE INSTANCE
Package

cover

Source

cover.lisp (file)

Function: cgs-p OBJECT
Package

cover

Source

cover.lisp (file)

Function: cgs-points-head INSTANCE
Function: (setf cgs-points-head) VALUE INSTANCE
Package

cover

Source

cover.lisp (file)

Function: cgs-points-map INSTANCE
Function: (setf cgs-points-map) VALUE INSTANCE
Package

cover

Source

cover.lisp (file)

Function: cgs-points-tail INSTANCE
Function: (setf cgs-points-tail) VALUE INSTANCE
Package

cover

Source

cover.lisp (file)

Function: cgs-testing INSTANCE
Function: (setf cgs-testing) VALUE INSTANCE
Package

cover

Source

cover.lisp (file)

Function: copy-cgs INSTANCE
Package

cover

Source

cover.lisp (file)

Function: copy-point SEQUENCE

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package

cover

Source

SYS:SRC;CODE;SEQ.LISP (not found)

Function: copy-points-set INSTANCE
Package

cover

Source

cover.lisp (file)

Function: do-shadowing-import PACKAGE

Add the shadowed symbols provided by COVER to the indicated package.

Package

cover

Source

cover.lisp (file)

Function: find-point FN
Package

cover

Source

cover.lisp (file)

Function: fn-name P
Package

cover

Source

cover.lisp (file)

Function: forget1 NAMES PS
Package

cover

Source

cover.lisp (file)

Function: hit STRUCTURE
Function: (setf hit) VALUE STRUCTURE
Package

cover

Source

cover.lisp (file)

Function: id STRUCTURE
Function: (setf id) VALUE STRUCTURE
Package

cover

Source

cover.lisp (file)

Function: instrument-forms FORMS

Function that replaces various symbols with their instrumented versions. This will be expanded later because some macros need to customize it. For example, ITERATE depends on certain symbols being present and breaks if they are blindly replaced.

Package

cover

Source

cover.lisp (file)

Function: locate NAME
Package

cover

Source

cover.lisp (file)

Function: make-cgs &key (COUNT COUNT) (HIT HIT) (POINTS-HEAD POINTS-HEAD) (POINTS-TAIL POINTS-TAIL) (POINTS-MAP POINTS-MAP) (ANNOTATING ANNOTATING) (TESTING TESTING)
Package

cover

Source

cover.lisp (file)

Function: make-point &key (HIT HIT) (ID ID) (STATUS STATUS) (NAME NAME) (SUBS SUBS)
Package

cover

Source

cover.lisp (file)

Function: make-points-set &key (HEAD HEAD) (TAIL TAIL) (MAP MAP)
Package

cover

Source

cover.lisp (file)

Function: name STRUCTURE
Function: (setf name) VALUE STRUCTURE
Package

cover

Source

cover.lisp (file)

Function: name-part-from-specialized-lambda-list SPECL

List of the specializer parts from a specialized lambda list

Package

cover

Source

cover.lisp (file)

Function: parse-body BODY
Package

cover

Source

cover.lisp (file)

Function: points-set-head INSTANCE
Function: (setf points-set-head) VALUE INSTANCE
Package

cover

Source

cover.lisp (file)

Function: points-set-map INSTANCE
Function: (setf points-set-map) VALUE INSTANCE
Package

cover

Source

cover.lisp (file)

Function: points-set-p OBJECT
Package

cover

Source

cover.lisp (file)

Function: points-set-tail INSTANCE
Function: (setf points-set-tail) VALUE INSTANCE
Package

cover

Source

cover.lisp (file)

Function: process CDEF DEF FN ARGL B
Package

cover

Source

cover.lisp (file)

Function: process-defgeneric-method N OM

Process a :method option from a defgeneric form for function named N. Returns the form for defining the point and the revised method description

Package

cover

Source

cover.lisp (file)

Function: process1 CDEF DEF FNL FN-EXTRA ARGLL B
Package

cover

Source

cover.lisp (file)

Function: process2 CDEF DEF FNL FN-EXTRA ARGLL B
Package

cover

Source

cover.lisp (file)

Function: record-hit P
Package

cover

Source

cover.lisp (file)

Function: report1 PS *ALL* *OUT*
Package

cover

Source

cover.lisp (file)

Function: report2 P
Package

cover

Source

cover.lisp (file)

Function: report3 P
Package

cover

Source

cover.lisp (file)

Function: reportable P
Package

cover

Source

cover.lisp (file)

Function: reportable-subs P
Package

cover

Source

cover.lisp (file)

Function: status STRUCTURE
Function: (setf status) VALUE STRUCTURE
Package

cover

Source

cover.lisp (file)

Function: subs STRUCTURE
Function: (setf subs) VALUE STRUCTURE
Package

cover

Source

cover.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.5 Structures

Structure: cgs ()
Package

cover

Source

cover.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: count
Type

integer

Initform

0

Readers

cgs-count (function)

Writers

(setf cgs-count) (function)

Slot: hit
Type

integer

Initform

1

Readers

cgs-hit (function)

Writers

(setf cgs-hit) (function)

Slot: points-head
Type

list

Readers

cgs-points-head (function)

Writers

(setf cgs-points-head) (function)

Slot: points-tail
Type

list

Readers

cgs-points-tail (function)

Writers

(setf cgs-points-tail) (function)

Slot: points-map
Type

hash-table

Initform

(make-hash-table :test (function equal))

Readers

cgs-points-map (function)

Writers

(setf cgs-points-map) (function)

Slot: annotating
Readers

cgs-annotating (function)

Writers

(setf cgs-annotating) (function)

Slot: testing
Readers

cgs-testing (function)

Writers

(setf cgs-testing) (function)

Structure: points-set ()
Package

cover

Source

cover.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: head
Readers

points-set-head (function)

Writers

(setf points-set-head) (function)

Slot: tail
Readers

points-set-tail (function)

Writers

(setf points-set-tail) (function)

Slot: map
Readers

points-set-map (function)

Writers

(setf points-set-map) (function)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.6 Types

Type: c-and &rest B
Package

cover

Source

cover.lisp (file)

Type: c-or &rest B
Package

cover

Source

cover.lisp (file)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   C   F   L  
Index Entry  Section

C
cover.asd: The cover<dot>asd file
cover/cover-package.lisp: The cover/cover-package<dot>lisp file
cover/cover.lisp: The cover/cover<dot>lisp file

F
File, Lisp, cover.asd: The cover<dot>asd file
File, Lisp, cover/cover-package.lisp: The cover/cover-package<dot>lisp file
File, Lisp, cover/cover.lisp: The cover/cover<dot>lisp file

L
Lisp File, cover.asd: The cover<dot>asd file
Lisp File, cover/cover-package.lisp: The cover/cover-package<dot>lisp file
Lisp File, cover/cover.lisp: The cover/cover<dot>lisp file

Jump to:   C   F   L  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (  
A   C   D   F   H   I   L   M   N   P   R   S  
Index Entry  Section

(
(setf cgs-annotating): Internal functions
(setf cgs-count): Internal functions
(setf cgs-hit): Internal functions
(setf cgs-points-head): Internal functions
(setf cgs-points-map): Internal functions
(setf cgs-points-tail): Internal functions
(setf cgs-testing): Internal functions
(setf hit): Internal functions
(setf id): Internal functions
(setf name): Internal functions
(setf points-set-head): Internal functions
(setf points-set-map): Internal functions
(setf points-set-tail): Internal functions
(setf status): Internal functions
(setf subs): Internal functions

A
add-point: Internal functions
add-top-point: Internal functions
annotate: Exported macros
annotate1: Internal functions

C
c: Internal macros
c-and: Internal macros
c-and0: Internal functions
c-case: Internal macros
c-case0: Internal functions
c-case1: Internal functions
c-cond: Internal macros
c-cond0: Internal functions
c-hide: Internal macros
c-if: Internal macros
c-or: Internal macros
c-or0: Internal functions
c-typecase: Internal macros
c-unless: Internal macros
c-when: Internal macros
c0: Internal functions
c1: Internal functions
cgs-annotating: Internal functions
cgs-count: Internal functions
cgs-hit: Internal functions
cgs-p: Internal functions
cgs-points-head: Internal functions
cgs-points-map: Internal functions
cgs-points-tail: Internal functions
cgs-testing: Internal functions
copy-cgs: Internal functions
copy-point: Internal functions
copy-points-set: Internal functions
cover-compile-hook: Exported functions

D
def: Internal macros
defgeneric: Internal macros
defmacro: Internal macros
defmethod: Internal macros
defun: Internal macros
do-shadowing-import: Internal functions

F
find-point: Internal functions
fn-name: Internal functions
forget: Exported functions
forget-all: Exported functions
forget1: Internal functions
Function, (setf cgs-annotating): Internal functions
Function, (setf cgs-count): Internal functions
Function, (setf cgs-hit): Internal functions
Function, (setf cgs-points-head): Internal functions
Function, (setf cgs-points-map): Internal functions
Function, (setf cgs-points-tail): Internal functions
Function, (setf cgs-testing): Internal functions
Function, (setf hit): Internal functions
Function, (setf id): Internal functions
Function, (setf name): Internal functions
Function, (setf points-set-head): Internal functions
Function, (setf points-set-map): Internal functions
Function, (setf points-set-tail): Internal functions
Function, (setf status): Internal functions
Function, (setf subs): Internal functions
Function, add-point: Internal functions
Function, add-top-point: Internal functions
Function, annotate1: Internal functions
Function, c-and0: Internal functions
Function, c-case0: Internal functions
Function, c-case1: Internal functions
Function, c-cond0: Internal functions
Function, c-or0: Internal functions
Function, c0: Internal functions
Function, c1: Internal functions
Function, cgs-annotating: Internal functions
Function, cgs-count: Internal functions
Function, cgs-hit: Internal functions
Function, cgs-p: Internal functions
Function, cgs-points-head: Internal functions
Function, cgs-points-map: Internal functions
Function, cgs-points-tail: Internal functions
Function, cgs-testing: Internal functions
Function, copy-cgs: Internal functions
Function, copy-point: Internal functions
Function, copy-points-set: Internal functions
Function, cover-compile-hook: Exported functions
Function, do-shadowing-import: Internal functions
Function, find-point: Internal functions
Function, fn-name: Internal functions
Function, forget: Exported functions
Function, forget-all: Exported functions
Function, forget1: Internal functions
Function, hit: Internal functions
Function, id: Internal functions
Function, instrument-forms: Internal functions
Function, locate: Internal functions
Function, make-cgs: Internal functions
Function, make-point: Internal functions
Function, make-points-set: Internal functions
Function, name: Internal functions
Function, name-part-from-specialized-lambda-list: Internal functions
Function, parse-body: Internal functions
Function, points-set-head: Internal functions
Function, points-set-map: Internal functions
Function, points-set-p: Internal functions
Function, points-set-tail: Internal functions
Function, process: Internal functions
Function, process-defgeneric-method: Internal functions
Function, process1: Internal functions
Function, process2: Internal functions
Function, record-hit: Internal functions
Function, report: Exported functions
Function, report1: Internal functions
Function, report2: Internal functions
Function, report3: Internal functions
Function, reportable: Internal functions
Function, reportable-subs: Internal functions
Function, reset: Exported functions
Function, status: Internal functions
Function, subs: Internal functions

H
hit: Internal functions

I
id: Internal functions
in-package: Internal macros
instrument-forms: Internal functions

L
locate: Internal functions

M
Macro, annotate: Exported macros
Macro, c: Internal macros
Macro, c-and: Internal macros
Macro, c-case: Internal macros
Macro, c-cond: Internal macros
Macro, c-hide: Internal macros
Macro, c-if: Internal macros
Macro, c-or: Internal macros
Macro, c-typecase: Internal macros
Macro, c-unless: Internal macros
Macro, c-when: Internal macros
Macro, def: Internal macros
Macro, defgeneric: Internal macros
Macro, defmacro: Internal macros
Macro, defmethod: Internal macros
Macro, defun: Internal macros
Macro, in-package: Internal macros
Macro, sup-mac: Internal macros
make-cgs: Internal functions
make-point: Internal functions
make-points-set: Internal functions

N
name: Internal functions
name-part-from-specialized-lambda-list: Internal functions

P
parse-body: Internal functions
points-set-head: Internal functions
points-set-map: Internal functions
points-set-p: Internal functions
points-set-tail: Internal functions
process: Internal functions
process-defgeneric-method: Internal functions
process1: Internal functions
process2: Internal functions

R
record-hit: Internal functions
report: Exported functions
report1: Internal functions
report2: Internal functions
report3: Internal functions
reportable: Internal functions
reportable-subs: Internal functions
reset: Exported functions

S
status: Internal functions
subs: Internal functions
sup-mac: Internal macros

Jump to:   (  
A   C   D   F   H   I   L   M   N   P   R   S  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *  
A   C   H   M   P   S   T  
Index Entry  Section

*
*all*: Internal special variables
*annotating*: Internal symbol macros
*cgs*: Internal special variables
*check*: Internal special variables
*count*: Internal symbol macros
*depth*: Internal special variables
*done*: Internal special variables
*fix*: Internal special variables
*hit*: Internal symbol macros
*line-limit*: Exported special variables
*out*: Internal special variables
*points*: Internal symbol macros
*report-readable-branches*: Exported special variables
*subs*: Internal special variables
*sup*: Internal special variables
*testing*: Internal symbol macros

A
annotating: Internal structures

C
count: Internal structures

H
head: Internal structures
hit: Internal structures

M
map: Internal structures

P
points-head: Internal structures
points-map: Internal structures
points-tail: Internal structures

S
Slot, annotating: Internal structures
Slot, count: Internal structures
Slot, head: Internal structures
Slot, hit: Internal structures
Slot, map: Internal structures
Slot, points-head: Internal structures
Slot, points-map: Internal structures
Slot, points-tail: Internal structures
Slot, tail: Internal structures
Slot, testing: Internal structures
Special Variable, *all*: Internal special variables
Special Variable, *cgs*: Internal special variables
Special Variable, *check*: Internal special variables
Special Variable, *depth*: Internal special variables
Special Variable, *done*: Internal special variables
Special Variable, *fix*: Internal special variables
Special Variable, *line-limit*: Exported special variables
Special Variable, *out*: Internal special variables
Special Variable, *report-readable-branches*: Exported special variables
Special Variable, *subs*: Internal special variables
Special Variable, *sup*: Internal special variables
Symbol Macro, *annotating*: Internal symbol macros
Symbol Macro, *count*: Internal symbol macros
Symbol Macro, *hit*: Internal symbol macros
Symbol Macro, *points*: Internal symbol macros
Symbol Macro, *testing*: Internal symbol macros

T
tail: Internal structures
testing: Internal structures

Jump to:   *  
A   C   H   M   P   S   T  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   C   P   S   T  
Index Entry  Section

C
c-and: Internal types
c-or: Internal types
cgs: Internal structures
cover: The cover system
cover: The cover package

P
Package, cover: The cover package
points-set: Internal structures

S
Structure, cgs: Internal structures
Structure, points-set: Internal structures
System, cover: The cover system

T
Type, c-and: Internal types
Type, c-or: Internal types

Jump to:   C   P   S   T