The cover Reference Manual

This is the cover Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed May 15 04:56:33 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 cover

Code coverage utility for Common Lisp

Author

Richard C. Waters

License

MIT

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.

Child Components

3 Files

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


3.1 Lisp


3.1.1 cover/cover.asd

Source

cover.asd.

Parent Component

cover (system).

ASDF Systems

cover.


3.1.2 cover/cover-package.lisp

Source

cover.asd.

Parent Component

cover (system).

Packages

cover.


3.1.3 cover/cover.lisp

Dependency

cover-package.lisp (file).

Source

cover.asd.

Parent Component

cover (system).

Public Interface
Internals

4 Packages

Packages are listed by definition order.


4.1 cover

Source

cover-package.lisp.

Use List

common-lisp.

Public Interface
Internals

5 Definitions

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


5.1 Public Interface


5.1.1 Special variables

Special Variable: *line-limit*
Package

cover.

Source

cover.lisp.

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.


5.1.2 Macros

Macro: annotate (t-or-nil)
Package

cover.

Source

cover.lisp.

Macro: with-coverage (&body body)

Set up an environment where cl:in-package forms are treated as cover:in-package forms

Package

cover.

Source

cover.lisp.


5.1.3 Ordinary functions

Function: checkpoint-coverage (&optional fns)
Package

cover.

Source

cover.lisp.

Function: count-covered-points (&optional fns)
Package

cover.

Source

cover.lisp.

Function: cover-compile-hook (thunk)

Used in ASDF to enable coverage in a package being compiled

Package

cover.

Source

cover.lisp.

Function: forget (&rest ids)
Package

cover.

Source

cover.lisp.

Function: forget-all ()
Package

cover.

Source

cover.lisp.

Function: report (&key fn out all)
Package

cover.

Source

cover.lisp.

Function: reset ()
Package

cover.

Source

cover.lisp.

Function: restore-checkpointed-coverage (&optional fns)
Package

cover.

Source

cover.lisp.


5.2 Internals


5.2.1 Special variables

Special Variable: *all*
Package

cover.

Special Variable: *cgs*
Package

cover.

Source

cover.lisp.

Special Variable: *check*
Package

cover.

Source

cover.lisp.

Special Variable: *depth*
Package

cover.

Special Variable: *done*
Package

cover.

Special Variable: *fix*
Package

cover.

Source

cover.lisp.

Special Variable: *out*
Package

cover.

Special Variable: *subs*
Package

cover.

Special Variable: *sup*
Package

cover.


5.2.2 Symbol macros

Symbol Macro: *annotating*
Package

cover.

Source

cover.lisp.

Symbol Macro: *count*
Package

cover.

Source

cover.lisp.

Symbol Macro: *hit*
Package

cover.

Source

cover.lisp.

Symbol Macro: *points*
Package

cover.

Source

cover.lisp.

Symbol Macro: *testing*
Package

cover.

Source

cover.lisp.


5.2.3 Macros

Macro: c (body &rest msg)
Package

cover.

Source

cover.lisp.

Macro: c-and (&rest ps)
Package

cover.

Source

cover.lisp.

Macro: c-case (key &rest cs)
Package

cover.

Source

cover.lisp.

Macro: c-cond (&rest cs)
Package

cover.

Source

cover.lisp.

Macro: c-hide (b)
Package

cover.

Source

cover.lisp.

Macro: c-if (pred then &optional else)
Package

cover.

Source

cover.lisp.

Macro: c-or (&rest ps)
Package

cover.

Source

cover.lisp.

Macro: c-typecase (key &rest cs)
Package

cover.

Source

cover.lisp.

Macro: c-unless (pred &rest actions)
Package

cover.

Source

cover.lisp.

Macro: c-when (pred &rest actions)
Package

cover.

Source

cover.lisp.

Macro: def (name args form)
Package

cover.

Source

cover.lisp.

Macro: defgeneric (n &rest defgeneric-body)
Package

cover.

Source

cover.lisp.

Macro: defmacro (n a &body b)
Package

cover.

Source

cover.lisp.

Macro: defmethod (n &rest method-body)
Package

cover.

Source

cover.lisp.

Macro: defun (n argl &body b)
Package

cover.

Source

cover.lisp.

Macro: in-package (name)
Package

cover.

Source

cover.lisp.

Macro: sup-mac ()
Package

cover.

Source

cover.lisp.


5.2.4 Ordinary functions

Function: add-point (p)
Package

cover.

Source

cover.lisp.

Function: add-top-point (p)
Package

cover.

Source

cover.lisp.

Function: annotate1 (flag)
Package

cover.

Source

cover.lisp.

Function: c-and0 (ps)
Package

cover.

Source

cover.lisp.

Function: c-case0 (cs)
Package

cover.

Source

cover.lisp.

Function: c-case1 (clause)
Package

cover.

Source

cover.lisp.

Function: c-cond0 (var cs)
Package

cover.

Source

cover.lisp.

Function: c-or0 (ps)
Package

cover.

Source

cover.lisp.

Function: c0 (p sup b)
Package

cover.

Source

cover.lisp.

Function: c1 (b m s)
Package

cover.

Source

cover.lisp.

Reader: cgs-annotating (instance)
Writer: (setf cgs-annotating) (instance)
Package

cover.

Source

cover.lisp.

Target Slot

annotating.

Reader: cgs-count (instance)
Writer: (setf cgs-count) (instance)
Package

cover.

Source

cover.lisp.

Target Slot

count.

Reader: cgs-hit (instance)
Writer: (setf cgs-hit) (instance)
Package

cover.

Source

cover.lisp.

Target Slot

hit.

Function: cgs-p (object)
Package

cover.

Source

cover.lisp.

Reader: cgs-points-head (instance)
Writer: (setf cgs-points-head) (instance)
Package

cover.

Source

cover.lisp.

Target Slot

points-head.

Reader: cgs-points-map (instance)
Writer: (setf cgs-points-map) (instance)
Package

cover.

Source

cover.lisp.

Target Slot

points-map.

Reader: cgs-points-tail (instance)
Writer: (setf cgs-points-tail) (instance)
Package

cover.

Source

cover.lisp.

Target Slot

points-tail.

Reader: cgs-testing (instance)
Writer: (setf cgs-testing) (instance)
Package

cover.

Source

cover.lisp.

Target Slot

testing.

Function: copy-cgs (instance)
Package

cover.

Source

cover.lisp.

Function: copy-point (sequence)

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

Package

cover.

Alias for

copy-seq.

Function: copy-points-set (instance)
Package

cover.

Source

cover.lisp.

Function: do-shadowing-import (package)

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

Package

cover.

Source

cover.lisp.

Function: find-point (fn)
Package

cover.

Source

cover.lisp.

Function: fn-name (p)
Package

cover.

Source

cover.lisp.

Function: forget1 (names ps)
Package

cover.

Source

cover.lisp.

Function: hit (structure)
Package

cover.

Source

cover.lisp.

Function: (setf hit) (structure)
Package

cover.

Source

cover.lisp.

Function: id (structure)
Package

cover.

Source

cover.lisp.

Function: (setf id) (structure)
Package

cover.

Source

cover.lisp.

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.

Function: locate (name)
Package

cover.

Source

cover.lisp.

Function: make-cgs (&key count hit points-head points-tail points-map annotating testing)
Package

cover.

Source

cover.lisp.

Function: make-point (&key hit saved-hit id status name subs)
Package

cover.

Source

cover.lisp.

Function: make-points-set (&key head tail map)
Package

cover.

Source

cover.lisp.

Function: map-points (fn &optional fns)

Apply FN to every point

Package

cover.

Source

cover.lisp.

Function: name (structure)
Package

cover.

Source

cover.lisp.

Function: (setf name) (structure)
Package

cover.

Source

cover.lisp.

Function: name-part-from-specialized-lambda-list (specl)

List of the specializer parts from a specialized lambda list

Package

cover.

Source

cover.lisp.

Function: parse-body (body)
Package

cover.

Source

cover.lisp.

Reader: points-set-head (instance)
Writer: (setf points-set-head) (instance)
Package

cover.

Source

cover.lisp.

Target Slot

head.

Reader: points-set-map (instance)
Writer: (setf points-set-map) (instance)
Package

cover.

Source

cover.lisp.

Target Slot

map.

Function: points-set-p (object)
Package

cover.

Source

cover.lisp.

Reader: points-set-tail (instance)
Writer: (setf points-set-tail) (instance)
Package

cover.

Source

cover.lisp.

Target Slot

tail.

Function: process (cdef def fn argl b)
Package

cover.

Source

cover.lisp.

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.

Function: process1 (cdef def fnl fn-extra argll b)
Package

cover.

Source

cover.lisp.

Function: process2 (cdef def fnl fn-extra argll b)
Package

cover.

Source

cover.lisp.

Function: record-hit (p)
Package

cover.

Source

cover.lisp.

Function: report1 (ps *all* *out*)
Package

cover.

Source

cover.lisp.

Function: report2 (p)
Package

cover.

Source

cover.lisp.

Function: report3 (p)
Package

cover.

Source

cover.lisp.

Function: reportable (p)
Package

cover.

Source

cover.lisp.

Function: reportable-subs (p)
Package

cover.

Source

cover.lisp.

Function: saved-hit (structure)
Package

cover.

Source

cover.lisp.

Function: (setf saved-hit) (structure)
Package

cover.

Source

cover.lisp.

Function: status (structure)
Package

cover.

Source

cover.lisp.

Function: (setf status) (structure)
Package

cover.

Source

cover.lisp.

Function: subs (structure)
Package

cover.

Source

cover.lisp.

Function: (setf subs) (structure)
Package

cover.

Source

cover.lisp.


5.2.5 Structures

Structure: cgs
Package

cover.

Source

cover.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: count
Package

common-lisp.

Type

integer

Initform

0

Readers

cgs-count.

Writers

(setf cgs-count).

Slot: hit
Type

integer

Initform

1

Readers

cgs-hit.

Writers

(setf cgs-hit).

Slot: points-head
Type

list

Readers

cgs-points-head.

Writers

(setf cgs-points-head).

Slot: points-tail
Type

list

Readers

cgs-points-tail.

Writers

(setf cgs-points-tail).

Slot: points-map
Type

hash-table

Initform

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

Readers

cgs-points-map.

Writers

(setf cgs-points-map).

Slot: annotating
Readers

cgs-annotating.

Writers

(setf cgs-annotating).

Slot: testing
Readers

cgs-testing.

Writers

(setf cgs-testing).

Structure: points-set
Package

cover.

Source

cover.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: head
Readers

points-set-head.

Writers

(setf points-set-head).

Slot: tail
Readers

points-set-tail.

Writers

(setf points-set-tail).

Slot: map
Package

common-lisp.

Readers

points-set-map.

Writers

(setf points-set-map).


5.2.6 Types

Type: c-and (&rest b)
Package

cover.

Source

cover.lisp.

Type: c-or (&rest b)
Package

cover.

Source

cover.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

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

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

A
add-point: Private ordinary functions
add-top-point: Private ordinary functions
annotate: Public macros
annotate1: Private ordinary functions

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

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

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

H
hit: Private ordinary functions

I
id: Private ordinary functions
in-package: Private macros
instrument-forms: Private ordinary functions

L
locate: Private ordinary functions

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

N
name: Private ordinary functions
name-part-from-specialized-lambda-list: Private ordinary functions

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

R
record-hit: Private ordinary functions
report: Public ordinary functions
report1: Private ordinary functions
report2: Private ordinary functions
report3: Private ordinary functions
reportable: Private ordinary functions
reportable-subs: Private ordinary functions
reset: Public ordinary functions
restore-checkpointed-coverage: Public ordinary functions

S
saved-hit: Private ordinary functions
status: Private ordinary functions
subs: Private ordinary functions
sup-mac: Private macros

W
with-coverage: Public macros


A.3 Variables

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

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

A
annotating: Private structures

C
count: Private structures

H
head: Private structures
hit: Private structures

M
map: Private structures

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

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

T
tail: Private structures
testing: Private structures