Most GNU C++ library classes possess a method named
that is useful in helping to verify correct performance of class
OK() operations checks the "representation invariant" of a
class object. This is a test to check whether the object is in a valid
state. In effect, it is a (sometimes partial) verification of the
library's promise that (1) class operations always leave objects in
valid states, and (2) the class protects itself so that client functions
cannot corrupt this state.
While no simple validation technique can assure that all operations
perform correctly, calls to
OK() can at least verify that
operations do not corrupt representations. For example for
a, b, c; ... a = b + c;, a call to
a.OK(); will guarantee that
a is a valid
String, but does not guarantee that it
contains the concatenation of
b + c. However, given that
is known to be valid, it is possible to further verify its properties,
for example via
a.after(b) == c && a.before(c) == b. In other
OK() generally checks only those internal representation
properties that are otherwise inaccessible to users of the class. Other
class operations are often useful for further validation.
Failed calls to
OK() call a class's
error method if
one exists, else directly call
abort. Failure indicates
an implementation error that should be reported.
With only rare exceptions, the internal support functions for a class
never themselves call
OK() (although many of the test files
in the distribution call
Verification of representational invariants can sometimes be very time consuming for complicated data structures.
Go to the first, previous, next, last section, table of contents.