The assert-p Reference Manual

Table of Contents

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

The assert-p Reference Manual

This is the assert-p Reference Manual, version 1.0.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Mon Dec 02 09:03:29 2019 GMT+0.


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

1 Introduction

assert-p

A library of assertions written in Common Lisp.

Getting Started in assert-p

Dependencies

:assertion-error

Download and load

1 - Load assert-p system by quicklisp

(ql:quickload :assert-p)

2 - Download and load assert-p system by github and asdf

Download directly from github:

git clone https://github.com/noloop/assert-p.git

and load by ASDF:

(asdf:load-system :assert-p)

Note: Remember to configure asdf to find your directory where you downloaded the libraries (asdf call them "systems") above, if you do not know how to make a read at: https://common-lisp.net/project/asdf/asdf/Configuring-ASDF-to-find-your-systems.html or https://lisp-lang.org/learn/writing-libraries.

But what is a library of assertions?

An assertion library assembles is an set of assertions that throw an assertion-error when the assertion fails. An assertion library usually follows a pattern so that the Test Runners can capture the assertion-error that it throws. The default I follow is using the library :assertion-error of which assert-p is dependent. All assert-p assertions return t when the assertion passes and throw assertion-error when the assertion fails.

(t-p actual)

Check actual eq t. Return t when actual is t, and throw assertion-error when actual is not t.

(t-p t) => t
(t-p nil) => throw assertion-error
(t-p '()) => throw assertion-error
(t-p 5) => throw assertion-error

(not-t-p actual)

Check actual not eq t. Return t when actual is not t, and throw assertion-error when actual is t.

(not-t-p t) => throw assertion-error
(not-t-p nil) => t
(not-t-p '()) => t
(not-t-p 5) => t

(zero-p actual)

Check actual eq 0. Return t when actual is 0, and throw assertion-error when actual is not 0.

(zero-p 0) => t
(zero-p 1) => throw assertion-error
(zero-p '()) => throw assertion-error
(zerot-p nil) => throw assertion-error

(not-zero-p actual)

Check actual not eq 0. Return t when actual is not 0, and throw assertion-error when actual is 0.

(not-zero-p 0) => throw assertion-error
(not-zero-p 1) => t
(not-zero-p '()) => t
(not-zerot-p nil) => t

(nil-p actual)

Check actual eq nil. Return t when actual is nil, and throw assertion-error when actual is not nil.

(nil-p nil) => t
(nil-p 1) => throw assertion-error
(nil-p '()) => t
(nil-p 0) => throw assertion-error

(not-nil-p actual)

Check actual not eq nil. Return t when actual is not nil, and throw assertion-error when actual is nil.

(not-nil-p nil) => throw assertion-error
(not-nil-p 1) => t
(not-nil-p '()) => throw assertion-error
(not-nil-p 0) => t

(null-p actual)

Check null actual. Equivalent to (null actual). Return t when actual is null, and throw assertion-error when actual is not null.

(null-p nil) => t
(null-p 1) => throw assertion-error
(null-p '()) => t
(null-p 0) => throw assertion-error

(not-null-p actual)

Check not null actual. Equivalent to (not (null actual)). Return t when actual is not null, and throw assertion-error when actual is null.

(not-null-p nil) => throw assertion-error
(not-null-p 1) => t
(not-null-p '()) => throw assertion-error
(not-null-p 0) => t

(eq-p actual expected)

Check actual eq expected. Return t when actual is eq expected, and throw assertion-error when actual is not eq expected.

(eq-p nil nil) => t
(eq-p 1 3) => throw assertion-error
(eq-p 1 1) => t ; Depending on the implementation it may return T or NIL.
(eq-p nil '())) => t
(eq-p :a :a) => t
(eq-p t nil) => throw assertion-error

(not-eq-p actual expected)

Check actual not eq expected. Return t when actual is not eq expected, and throw assertion-error when actual is eq expected.

(not-eq-p nil nil) => throw assertion-error
(not-eq-p nil '())) => throw assertion-error
(not-eq-p :a :a) => throw assertion-errort
(not-eq-p t nil) => t

(eql-p actual expected)

Check actual eql expected. Return t when actual is eql expected, and throw assertion-error when actual is not eql expected.

(eql-p nil nil) => t
(eql-p 1 3) => throw assertion-error
(eql-p 1 1) => t
(eql-p nil '())) => t
(eql-p :a :a) => t
(eql-p t nil) => throw assertion-error

(not-eql-p actual expected)

Check actual not eql expected. Return t when actual is not eql expected, and throw assertion-error when actual is not expected.

(not-eql-p nil nil) => throw assertion-error
(not-eql-p 1 3) => t
(not-eql-p 1 1) => throw assertion-error
(not-eql-p nil '())) => throw assertion-error
(not-eql-p :a :a) => throw assertion-error
(not-eql-p t nil) => t

(equal-p actual expected)

Check actual equal expected. Return t when actual is equal expected, and throw assertion-error when actual is not equal expected.

(equal-p nil nil) => t
(equal-p 1 3) => throw assertion-error
(equal-p 1 1) => t
(equal-p nil '())) => t
(equal-p :a :a) => t
(equal-p t nil) => throw assertion-error
(equal-p '(1 2 3) '(1 2 3)) => t
(not-equal-p "a" "A") => throw assertion-error

(not-equal-p actual expected)

Check actual not equal expected. Return t when actual is not equal expected, and throw assertion-error when actual is equal expected.

(not-equal-p nil nil) => throw assertion-error
(not-equal-p 1 3) => t
(not-equal-p 1 1) => throw assertion-error
(not-equal-p nil '())) => throw assertion-error
(not-equal-p :a :a) => throw assertion-error
(not-equal-p t nil) => t
(not-equal-p '(1 2 3) '(1 2 3)) => throw assertion-error
(not-equal-p "a" "A") => t

(equalp-p actual expected)

Check actual equalp expected. Return t when actual is equalp expected, and throw assertion-error when actual is not equalp expected.

(equalp-p nil nil) => t
(equalp-p 1 3) => throw assertion-error
(equalp-p 1 1) => t
(equalp-p nil '())) => t
(equalp-p :a :a) => t
(equalp-p t nil) => throw assertion-error
(equalp-p '(1 2 3) '(1 2 3)) => t
(equalp-p "a" "A") => t

(not-equalp-p actual expected)

Check actual not equalp expected. Return t when actual is not equalp expected, and throw assertion-error when actual is equalp expected.

(not-equalp-p nil nil) => throw assertion-error
(not-equalp-p 1 3) => t
(not-equalp-p 1 1) => throw assertion-error
(not-equalp-p nil '())) => throw assertion-error
(not-equalp-p :a :a) => throw assertion-error
(not-equalp-p t nil) => t
(not-equalp-p '(1 2 3) '(1 2 3)) => throw assertion-error
(not-equalp-p "a" "A") => throw assertion-error

(typep-p actual expected)

Check actual typep expected. Return t when actual is typep expected, and throw assertion-error when actual is not typep expected.

(typep-p 1 'integer) => t
(typep-p "a" 'string) => t
(typep-p :a 'symbol) => t
(typep-p nil 'integer)) => throw assertion-error
(typep-p nil 'symbol) => t

(not-typep-p actual expected)

Check actual not typep expected. Return t when actual is not typep expected, and throw assertion-error when actual is typep expected.

(not-typep-p 1 'integer) => throw assertion-error
(not-typep-p "a" 'string) => throw assertion-error
(not-typep-p :a 'symbol) => throw assertion-error
(not-typep-p nil 'integer)) => t
(not-typep-p nil 'symbol) => throw assertion-error

(values-p predicate actual expected)

Check actual every predicate expected. Predicate is a symbol of function, actual is a list, and expected an atom. Example: (values-p '= '(t t t) t) It's similar to (every #'(lambda (i) (= t i)) '(t t t)). Return t when actual values is expected, and throw assertion-error when actual values is not expected.

(values-p '= '(1 1 1) 1) => t
(values-p 'string= '("a" "a" "a") "a") => t
(values-p 'eq '(t t t) t)) => t
(values-p 'eq '(t nil t) t)) => throw assertion-error
(values-p 'eq '(nil nil nil) t)) => throw assertion-error

(not-values-p predicate actual expected)

Check actual every not predicate expected. Predicate is a symbol of function, actual is a list, and expected an atom. Example: (values-p '= '(t t t) t) It's similar to (every #'(lambda (i) (not (= t i))) '(t t t)). Return t when actual values is not expected, and throw assertion-error when actual values is expected.

(not-values-p '= '(1 1 1) 1) => throw assertion-error
(not-values-p 'string= '("a" "a" "a") "a") => throw assertion-error
(not-values-p 'eq '(t t t) t)) => throw assertion-error
(not-values-p 'eq '(t nil t) t)) => throw assertion-error
(not-values-p 'eq '(nil nil nil) t)) => t

(error-p fn)

Check if fn throw an error. Return t when fn throw error, and throw assertion-error when fn not throw error.

(error-p #'(lambda () (error "Something"))) => t
(error-p #'(lambda () ())) => throw assertion-error

(not-error-p fn)

Check if fn not throw an error. Return t when fn not throw error, and throw assertion-error when fn throw error.

(not-error-p #'(lambda () (error "Something"))) => throw assertion-error
(not-error-p #'(lambda () ())) => t

(condition-error-p fn condition)

Check if fn throw an specified condition error. Return t when fn throw specified condition error, and throw assertion-error when fn not throw specified condition error.

(condition-error-p #'(lambda () (error 'division-by-zero))
                   division-by-zero) => t
(condition-error-p #'(lambda () ())
                   division-by-zero) => throw assertion-error
(condition-error-p #'(lambda () (error "Something"))
                   division-by-zero) => throw assertion-error

(not-condition-error-p fn condition)

Check if fn not throw an specified condition error. Return t when fn not throw specified condition error, and throw assertion-error when fn throw specified condition error.

(not-condition-error-p #'(lambda () (error 'division-by-zero))
                   division-by-zero) => throw assertion-error
(not-condition-error-p #'(lambda () ())
                   division-by-zero) => t
(not-condition-error-p #'(lambda () (error "Something"))
                   division-by-zero) => t

(custom-p test-result actual expected operator)

Custom check for special cases. Where test-result is a form that returns t or nil, actual is value actual used in test-result, expected is value expected used in test-result, operator is operator used in test-result. Return t when test-result is t, and throw assertion-error when test-result is nil.

(custom-p (every #'eq '(:a :b :c) '(:a :b))
          '(:a :b :c)
          '(:a :b)
          "every =") => t
(custom-p (every #'eq '(:a :b :c) '(:a :b :z))
          '(:a :b :c)
          '(:a :b)
          "string=") => throw assertion-error
(custom-p (string= "I exist?" "I exist?")
          "I exist?"
          "I exist?"
          "string=") => t
(custom-p (string= "I exist?" "I'm not sure.")
          "I exist?"
          "I'm not sure."
          "string=") => throw assertion-error

API

function (t-p actual) => t or throw assertion-error

function (not-t-p actual) => t or throw assertion-error

function (zero-p actual) => t or throw assertion-error

function (not-zero-p actual) => t or throw assertion-error

function (nil-p actual) => t or throw assertion-error

function (not-nil-p actual) => t or throw assertion-error

function (null-p actual) => t or throw assertion-error

function (not-null-p actual) => t or throw assertion-error

function (eq-p actual expected) => t or throw assertion-error

function (not-eq-p actual expected) => t or throw assertion-error

function (eql-p actual expected) => t or throw assertion-error

function (not-eql-p actual expected) => t or throw assertion-error

function (equal-p actual expected) => t or throw assertion-error

function (not-equal-p actual expected) => t or throw assertion-error

function (equalp-p actual expected) => t or throw assertion-error

function (not-equalp-p actual expected) => t or throw assertion-error

function (typep-p actual expected) => t or throw assertion-error

function (not-typep-p actual expected) => t or throw assertion-error

function (values-p predicate actual expected) => t or throw assertion-error

function (not-values-p predicate actual expected) => t or throw assertion-error

function (error-p fn) => t or throw assertion-error

function (not-error-p fn) => t or throw assertion-error

macro (condition-error-p fn condition) => t or throw assertion-error

macro (not-condition-error-p fn condition) => t or throw assertion-error

function (custom-p test-result actual expected operator) => t or throw assertion-error

LICENSE

Copyright (C) 2019 noloop

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see https://www.gnu.org/licenses/.

Contact author:

noloop@zoho.com


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 assert-p

Maintainer

noloop <noloop@zoho.com>

Author

noloop <noloop@zoho.com>

Home Page

https://github.com/noloop/assert-p

Source Control

(:git "git@github.com:noloop/assert-p.git")

Bug Tracker

https://github.com/noloop/assert-p/issues

License

GPLv3

Description

A library of assertions written in Common Lisp.

Version

1.0.0

Dependency

assertion-error

Source

assert-p.asd (file)

Component

src (module)


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

3 Modules

Modules are listed depth-first from the system components tree.


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

3.1 assert-p/src

Parent

assert-p (system)

Location

src/

Components

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

4 Files

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


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

4.1 Lisp


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

4.1.1 assert-p.asd

Location

assert-p.asd

Systems

assert-p (system)


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

4.1.2 assert-p/src/package.lisp

Parent

src (module)

Location

src/package.lisp

Packages

noloop.assert-p


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

4.1.3 assert-p/src/macros.lisp

Dependency

package.lisp (file)

Parent

src (module)

Location

src/macros.lisp

Internal Definitions

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

4.1.4 assert-p/src/assert-p.lisp

Dependency

macros.lisp (file)

Parent

src (module)

Location

src/assert-p.lisp

Exported Definitions
Internal Definitions

assertion (function)


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

5 Packages

Packages are listed by definition order.


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

5.1 noloop.assert-p

Source

package.lisp (file)

Nickname

assert-p

Use List

common-lisp

Exported Definitions
Internal Definitions

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

6 Definitions

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


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

6.1 Exported definitions


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

6.1.1 Macros

Macro: condition-error-p FN CONDITION

Check if fn throw an specified condition error.

Package

noloop.assert-p

Source

assert-p.lisp (file)

Macro: not-condition-error-p FN CONDITION

Check if fn not throw an specified condition error.

Package

noloop.assert-p

Source

assert-p.lisp (file)


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

6.1.2 Functions

Function: custom-p TEST-RESULT ACTUAL EXPECTED OPERATOR

Custom check for special cases. Where test-result is a form that returns t or nil, actual is value actual used in test-result, expected is value expected used in test-result, operator is operator used in test-result. Return t when test-result is t, and throw assertion-error when test-result is nil.

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: eq-p ACTUAL EXPECTED

Check actual eq expected

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: eql-p ACTUAL EXPECTED

Check actual eql expected

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: equal-p ACTUAL EXPECTED

Check actual equal expected

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: equalp-p ACTUAL EXPECTED

Check actual equalp expected

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: error-p FN

Check if fn throw an error.

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: nil-p ACTUAL

Check actual eq nil

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: not-eq-p ACTUAL EXPECTED

Check actual not eq expected

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: not-eql-p ACTUAL EXPECTED

Check actual not eql expected

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: not-equal-p ACTUAL EXPECTED

Check actual not equal expected

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: not-equalp-p ACTUAL EXPECTED

Check actual not equalp expected

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: not-error-p FN

Check if fn not throw an error.

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: not-nil-p ACTUAL

Check actual not eq nil

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: not-null-p ACTUAL

Check not null actual. Equivalent to (not (null actual))

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: not-t-p ACTUAL

Check actual not eq t

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: not-typep-p ACTUAL EXPECTED

Check actual not typep expected

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: not-values-p PREDICATE ACTUAL EXPECTED

Check actual every not predicate expected. Predicate is a symbol of function, actual is a list, and expected an atom. Example: (values-p ’= ’(t t t) t) It’s similar to (every #’(lambda (i) (not (= t i))) ’(t t t))

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: not-zero-p ACTUAL

Check actual not eq 0

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: null-p ACTUAL

Check null actual. Equivalent to (null actual)

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: t-p ACTUAL

Check actual eq t

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: typep-p ACTUAL EXPECTED

Check actual typep expected

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: values-p PREDICATE ACTUAL EXPECTED

Check actual every predicate expected. Predicate is a symbol of function, actual is a list, and expected an atom. Example: (values-p ’= ’(t t t) t) It’s similar to (every #’(lambda (i) (= t i)) ’(t t t))

Package

noloop.assert-p

Source

assert-p.lisp (file)

Function: zero-p ACTUAL

Check actual eq 0

Package

noloop.assert-p

Source

assert-p.lisp (file)


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

6.2 Internal definitions


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

6.2.1 Macros

Macro: assertion-error-check TEST-FORM
Package

noloop.assert-p

Source

macros.lisp (file)

Macro: assertion-values TEST-FN PREDICATE ACTUAL EXPECTED OPERATOR
Package

noloop.assert-p

Source

macros.lisp (file)

Macro: condition-error-check TEST-FN CONDITION
Package

noloop.assert-p

Source

macros.lisp (file)

Macro: error-check TEST-FN
Package

noloop.assert-p

Source

macros.lisp (file)

Macro: once-only (&rest NAMES) &body BODY
Package

noloop.assert-p

Source

macros.lisp (file)

Macro: with-gensyms VARS &body BODY
Package

noloop.assert-p

Source

macros.lisp (file)


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

6.2.2 Functions

Function: assertion RESULT ACTUAL EXPECTED OPERATOR

When result is t return t. When result is nil throw assertion-error. One assertion need result(t or nil), one object actual, one object expected, and one operator(string or symbol). Assertion-error also loading one message of error(built with actual, expected and operator) and the stack trace of error throw moment.

Package

noloop.assert-p

Source

assert-p.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   A   F   L   M  
Index Entry  Section

A
assert-p.asd: The assert-p․asd file
assert-p/src: The assert-p/src module
assert-p/src/assert-p.lisp: The assert-p/src/assert-p․lisp file
assert-p/src/macros.lisp: The assert-p/src/macros․lisp file
assert-p/src/package.lisp: The assert-p/src/package․lisp file

F
File, Lisp, assert-p.asd: The assert-p․asd file
File, Lisp, assert-p/src/assert-p.lisp: The assert-p/src/assert-p․lisp file
File, Lisp, assert-p/src/macros.lisp: The assert-p/src/macros․lisp file
File, Lisp, assert-p/src/package.lisp: The assert-p/src/package․lisp file

L
Lisp File, assert-p.asd: The assert-p․asd file
Lisp File, assert-p/src/assert-p.lisp: The assert-p/src/assert-p․lisp file
Lisp File, assert-p/src/macros.lisp: The assert-p/src/macros․lisp file
Lisp File, assert-p/src/package.lisp: The assert-p/src/package․lisp file

M
Module, assert-p/src: The assert-p/src module

Jump to:   A   F   L   M  

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

A.2 Functions

Jump to:   A   C   E   F   M   N   O   T   V   W   Z  
Index Entry  Section

A
assertion: Internal functions
assertion-error-check: Internal macros
assertion-values: Internal macros

C
condition-error-check: Internal macros
condition-error-p: Exported macros
custom-p: Exported functions

E
eq-p: Exported functions
eql-p: Exported functions
equal-p: Exported functions
equalp-p: Exported functions
error-check: Internal macros
error-p: Exported functions

F
Function, assertion: Internal functions
Function, custom-p: Exported functions
Function, eq-p: Exported functions
Function, eql-p: Exported functions
Function, equal-p: Exported functions
Function, equalp-p: Exported functions
Function, error-p: Exported functions
Function, nil-p: Exported functions
Function, not-eq-p: Exported functions
Function, not-eql-p: Exported functions
Function, not-equal-p: Exported functions
Function, not-equalp-p: Exported functions
Function, not-error-p: Exported functions
Function, not-nil-p: Exported functions
Function, not-null-p: Exported functions
Function, not-t-p: Exported functions
Function, not-typep-p: Exported functions
Function, not-values-p: Exported functions
Function, not-zero-p: Exported functions
Function, null-p: Exported functions
Function, t-p: Exported functions
Function, typep-p: Exported functions
Function, values-p: Exported functions
Function, zero-p: Exported functions

M
Macro, assertion-error-check: Internal macros
Macro, assertion-values: Internal macros
Macro, condition-error-check: Internal macros
Macro, condition-error-p: Exported macros
Macro, error-check: Internal macros
Macro, not-condition-error-p: Exported macros
Macro, once-only: Internal macros
Macro, with-gensyms: Internal macros

N
nil-p: Exported functions
not-condition-error-p: Exported macros
not-eq-p: Exported functions
not-eql-p: Exported functions
not-equal-p: Exported functions
not-equalp-p: Exported functions
not-error-p: Exported functions
not-nil-p: Exported functions
not-null-p: Exported functions
not-t-p: Exported functions
not-typep-p: Exported functions
not-values-p: Exported functions
not-zero-p: Exported functions
null-p: Exported functions

O
once-only: Internal macros

T
t-p: Exported functions
typep-p: Exported functions

V
values-p: Exported functions

W
with-gensyms: Internal macros

Z
zero-p: Exported functions

Jump to:   A   C   E   F   M   N   O   T   V   W   Z  

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

A.3 Variables


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

A.4 Data types

Jump to:   A   N   P   S  
Index Entry  Section

A
assert-p: The assert-p system

N
noloop.assert-p: The noloop․assert-p package

P
Package, noloop.assert-p: The noloop․assert-p package

S
System, assert-p: The assert-p system

Jump to:   A   N   P   S