The jingoh Reference Manual

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

The jingoh Reference Manual

This is the jingoh Reference Manual, version 3.0.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 04:54:36 2022 GMT+0.

Table of Contents


1 Introduction

JINGOH 3.0.1

NOTE! Jingoh is very personal products, so use your own risk. Other products (if any) are strongly recommended.

What is this?

DSL to notate specification, rather than test framework.

Notable differences from other test suites.

Specification notation rather than test framework.

When specification is modified, test should be fixed. Vice vaca, when a hole found in specification via test, specification should be fixed. Idealy, both specification and test should be managed in one place.

Readability oriented syntax rather than writablility.

In concept above, test is specification, so readability prior than writability. Author may need writability. Unfortunately, author is few, but the third persons. For syntax details, see SYNTAX.md.

Including specification template (i.e. as test template).

TDD begginer may not understand what should be written as test. Thanks to CLHS, we know what should be written as specification. For details, see generator/README.md.

Including dribble for REPL driven development.

Most CLer will do REPL driven development. Writting tiny codes, loading it to lisp environment, then checking it inside REPL. If find something unexpected behavior, fixing codes, reloading it and so on. For such users, jingoh provides special dribble repl. Your interactions with REPL are automatically send spec file. For details, see generator/README.md.

Including from-spec(i.e. test)-file-to-HTML converter.

Managing both test and specification at one place allows you to never write documentation, since it is already written. You can say "See spec/test file.", but we provide little bit prittier to html comverter. For details, see documentizer/README.md.

Including from-spec(i.e. test)-file-to-github-wiki converter.

Additionaly, we provide to github-wiki converter. For details, see documentizer/README.md.

Including from-spec(i.e. test)-file-to-lisp-documentation importer.

Additionaly, we provide lisp documentation importer. You can refer spec documentation via CL:DOCUMENTATION. For details, see documentizer/README.md.

Customizable issue printer.

What is the best issue report? It is issue of flavor. We print issue as raw data object. Thanks to CLOS, you can easily customize printer with PRINT-OBJECT.

Support coloring printing.

For readability, we provide coloring printing. In many cases, you will not feel like to customize issue printer.

Support S-Expression-equal. (alpha quality.)

It is hard to test macro generate correct S-Expression. Because, there is symbol which generate via GENSYM. We will provide SEXP=. (This is alpha quality, so it is internal.)

Support parallel testing.

Optionaly you can choose parallel testing.

Including project skelton generator.

Battery included. You can ignore some annoying knowledge about backward.

How to use.

Initialization

If your system is already made, evaluate below.

NOTE! You must specify your system with keyword.

(asdf:load-system :jingoh.generator)
(jingoh.generator:generate :your-system)

In this case, jingoh will make spec subdirectory in your system source directory like below.

your-system/
  |--- your-system.asd
  |--- your-system.lisp
  |--- spec/
        |--- your-system.test.asd
        |--- your-system.lisp

Else if your system is not made yet, specify :init keyword with T.

(jingoh.generator:generate :your-system :init t)

In this case, jingoh works like project skeleton generator (e.g. quick-project.).

your-system/
  |--- README.md
  |--- spec/
        |--- your-system.lisp
        |--- your-system.test.asd
  |--- src/
        |--- your-system.lisp
  |--- your-system.asd

In both cases, test is already setup. To run test, evaluate like below.

(asdf:test-system :your-system)

Writing specifications.

Let's say your-system has function like below.

(defun adder (num)
  "Make adder function."
  (lambda (x)
    (+ x num)))

To add specification of ADDER to your spec file, evaluate like below.

(jingoh.generator:dribble :your-system)

DRIBBLE>

Now, you are in the dribble repl. To append spec file with template, input :g.

DRIBBLE> :g

>>

Input function name.

>> adder

DRIBBLE>

Jingoh appends spec file with template like below.

(requirements-about ADDER)

;;;; Description:
; Make adder function.

#+syntax
(ADDER num) ; => result

;;;; Arguments and Values:

; num := 

; result := 

;;;; Affected By:

;;;; Side-Effects:

;;;; Notes:

;;;; Exceptional-Situations:

This template is designed to be same with hyper-spec.

Different from ordinary repl, dribble repl ask you each result are expected.

DRRIBLE> (adder 1)

FUNCTION
Is it expected return type? (y or n)

If yes, spec file are appended.

Is it expected return type? (y or n) y

#<CLOSURE (LAMBDA (X) :IN ADDER) {12345}>
DRIBBLE>

Ok, try to next test.

DRIBBLE> (adder :not-number)

FUNCTION
Is it expected return type? (y or n)

Let's say you want to specify signaling an error in this case. FUNCTION is not expected return type.

When you choice NO, it invokes ordinary deubgger.

Is it expected return type? (y or n) n

debugger invoked on a UNEXPECTED-BEHAVIOR in thread
#<THREAD ....>:

restarts (invokable by number or by possibly-abbreviated name):
  0: [USE-VALUE] Specify expected type.
  1: [DRIBBLE  ] Return to dribble.
  2: [ABORT    ] Exit debugger, returning to top level.

This is ordinary debugger, so you can do anything in debugger, editting, reloading, etc.

Let's modify source like below.

(defun adder (num)
  "Make adder function."
  (check-type num number)
  (lambda (x)
    (+ x num)))

After modifying and reloading your system in the debugger, select restart DRIBBLE to return dribble repl.

DRIBBLE> (adder :not-number)

debugger invoded on a SIMPLE-TYPE-ERROR in thread
#<THREAD ...>:

restarts (invokable by number or by possibly-abbreviated name):
  0: [STORE-VALUE] Supply a new value for NUM.
  1: [APPEND-SPEC] Append spec, returning to dribble.
  2: [DRIBBLE    ] Return to dribble.
  3: [ABORT      ] Exit debugger, returning to top level.

Ok, signaling an error is expected behavior. Let's choice restart APPEND-SPEC.

To exit dribble repl, input :q.

DRIBBLE> :q

*

After dribble session, edit the spec file to move test code in the right place.

After editting, spec file may like below. To write comment, use markdown syntax with semicolon escape. To know completed syntax, see SYNTAX.md. One-sentence-some-examples style is recommended.

(requirements-about ADDER)

;;;; Description:
; Make adder function.
#?(ADDER 1) :be-the FUNCTION

; Apply number to returned function, such function return added value.
#?(FUNCALL (ADDER 1) 2) => 3

#+syntax
(ADDER num) ; => result

;;;; Arguments and Values:

; num := number which is acceptable for `CL:+`, otherwise error
#?(ADDER :NOT-NUMBER) :signals SIMPLE-TYPE-ERROR

; result := function as `(FUNCTION (NUMBER) NUMBER)`

;;;; Affected By:
; none

;;;; Side-Effects:
; none

;;;; Notes:

;;;; Exceptional-Situations:

Running test.

NOTE! Before running test, do not forget export (if it will be exported.) symbol from your system package, or import (if it will be internals.) symbol from your system package to spec package.

(asdf:test-system :your-system)

passed example

Documentization

After writing your-system's spec file, if you want to get your system's html documentations, evaluate like below.

(asdf:load-system :jingoh.documentizer)
(jingoh.documentizer:documentize :your-system)

Jingoh will make doc subdirectory in your system source directory.

If you want provide such documentations as github wiki, after clone github wiki repository, evaluate like below.

(jingoh.documentaizer:github :your-system "path/to/your-system.wiki/")

Then push it.

Parallel testing.

Normally, jingoh run tests sequentially. If you want to run tests in parallel, modify spec/your-system.test.asd like below.

(defsystem :your-system.test
  :depends-on (:jingoh.parallel ; <--- instead of :jingoh
               "your-system")
  :components ((:file "your-system"))
  :perform
  (test-op(o c)(symbol-call :jingoh.parallel ; <--- instead of :jingoh
                            :pexamine ; <--- instead of :examine
                            :your-system)))

NOTE! Parallelizing has its own overhead, so parallel testing may slower than sequential testing.

From developer

Product's goal

?

License

MIT

Tested with

Known issue.

Installation

TODO


2 Systems

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


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

2.1 jingoh

DSL to notate specification, rather than test framework.

Author

Shinichi Sato

License

MIT

Long Description

## Abstract concepts
Jingoh provides the features to notate specification, rather than test framework.
Once you writes your library’s specifications with jingoh, such file works as test. Additionaly, it will be enough to be used as tutolials for end users.

## Packages
Package JINGOH responds to be as interface.
JINGOH’s external symbols are main features for light users.
JINGOH’s internal symbols are inherited from other modules.

System (same as package) JINGOH.ORG, JINGOH.TESTER, JINGOH.EXAMINER, JINGOH.READER are modules.

## Extensions
Jingoh provides some extensions.

### Jingoh.generator
Provides the features to generate test template.

### Jingoh.documentizer
Provides the features to convert test file to html, or markdown for github wiki.

### Jingoh.parallel
Provides the feature to run test in parallel.

## NOTE
Jingoh compiles test form at run time.
Its advantage is recallability.
When test code is not modified but system source code,
you does not reload test file (i.e. does not need to evaluate ASDF:TEST-SYSTEM).
Just reload system then evaluate JINGOH:EXAMINE.
JINGOH:EXAMINE can control which test should be evaluated. (the default is all)

Disadvantage is higher running cost.

Version

3.0.1

Dependencies
Source

jingoh.asd.

Child Component

package.lisp (file).


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

2.2 jingoh.org

Jingoh’s background database system

Author

SATO Shinichi

License

MIT

Long Description

# jingoh.org - Jingoh’s background database system

## Abstract concepts
Jingoh.org provides jingoh’s background database system. Provides abstract container type named ORG and its operators.

## Terms
### ORG
Stands in ORGanization.
It manages all REQUIREMENTs of SUBJECTs about your system. You can refer it as test-suite which usual test framework has.

### REQUIREMENT
What the operator must/should/may behaves.
You can refer it as test which usual test framework has.

### SUBJECT
Target of REQUIREMENT.

## Management hierarchy
“‘
+—–+
| ORG | ; e.g. system or package
+—–+
|
+—————————————-+
|+———-+ | ; called "specifications"
|| SUBJECTs | ; e.g. functions or macros |
|+———-+ |
| | |
|+————–+ |
|| REQUIREMENTS | ; i.e. behaviors | |+————–+ | +—————————————-+
“‘

Version

2.1.6

Dependencies
  • alexandria (system).
  • check-bnf (system).
Source

jingoh.org.asd.

Child Components

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

2.3 jingoh.tester

Jingoh module for issue objects and interface for jingoh.org.

Author

SATO Shinichi

License

MIT

Long Description

# jingoh.tester - Dsl for requirement.

## Abstract concepts
Jingoh.tester is a dsl for requirement.
It provides -
* Notations of requirement.
* Testing feature which tests implementation satisfies requirement or not.
* Abstract data types which represents issues.

For extensibility, requirement’s internal representation is not specified.
Although Jingoh.tester provides operators which handle requirements.
So users does not need to know about what happen behind the black box.

For modulability, jingoh.tester does not provide report functions, and restoring database system.
It is jingoh.examiner or jingoh.org who responds it respectively.

## Terms

### REQUIREMENT
REQUIREMENT is internal datatype which represents specifications of requirement for operator’s behavior.

### ISSUE
ISSUE is abstract datatype which contains information about issue of implementation of requiements.

Version

1.3.17

Dependencies
  • alexandria (system).
  • uiop (system).
  • closer-mop (system).
  • bordeaux-threads (system).
  • structure-ext (system).
  • check-bnf (system).
  • cl-ansi-text (system).
  • vivid-diff (system).
  • vivid-colors (system).
  • cl-colors2 (system).
  • jingoh.org (system).
  • fuzzy-match (system).
Source

jingoh.tester.asd.

Child Components

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

2.4 jingoh.examiner

Jingoh module for test running and control/config output.

Author

SATO Shinichi

License

MIT

Long Description

# jingoh.examiner - Jingoh’s printing issues feature.

## Abstract concepts
Jingoh.examiner provides features to examine implementation of requirements, and to print result.

For modulability, jingoh.examiner does not respond to register requirements or how to handle requirements. It is jingoh.org or jingoh.tester responds, respectively.

Version

0.0.17

Dependencies
Source

jingoh.examiner.asd.

Child Component

examine.lisp (file).


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

2.5 jingoh.reader

Jingoh module to provide reader macro.

Author

SATO Shinichi

License

MIT

Long Description

## Abstract concepts

Jingoh.reader provides dispatch macro function for jingoh.tester and named-readtables.

Dispatch macro ‘#?‘ allows you to write test form as if it is written in REPL.
It may be a worse way to write a test, but the written form will be better looking especially for a third person.

If you do not like using the dispatch macro, you can ignore this.

Version

2.5.2

Dependencies
  • uiop (system).
  • named-readtables (system).
  • eclector (system).
  • jingoh.tester (system).
Source

jingoh.reader.asd.

Child Component

reader.lisp (file).


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   [Contents][Index]

3.1.1 jingoh/jingoh.asd

Source

jingoh.asd.

Parent Component

jingoh (system).

ASDF Systems

jingoh.


3.1.2 jingoh.org/jingoh.org.asd

Source

jingoh.org.asd.

Parent Component

jingoh.org (system).

ASDF Systems

jingoh.org.


3.1.3 jingoh.tester/jingoh.tester.asd

Source

jingoh.tester.asd.

Parent Component

jingoh.tester (system).

ASDF Systems

jingoh.tester.


3.1.4 jingoh.examiner/jingoh.examiner.asd

Source

jingoh.examiner.asd.

Parent Component

jingoh.examiner (system).

ASDF Systems

jingoh.examiner.


3.1.5 jingoh.reader/jingoh.reader.asd

Source

jingoh.reader.asd.

Parent Component

jingoh.reader (system).

ASDF Systems

jingoh.reader.


3.1.6 jingoh/package.lisp

Source

jingoh.asd.

Parent Component

jingoh (system).

Packages

jingoh.

Public Interface

setup (macro).


3.1.7 jingoh.org/package.lisp

Source

jingoh.org.asd.

Parent Component

jingoh.org (system).

Packages

jingoh.org.


3.1.8 jingoh.org/conditions.lisp

Dependency

package.lisp (file).

Source

jingoh.org.asd.

Parent Component

jingoh.org (system).

Public Interface

3.1.9 jingoh.org/org.lisp

Dependency

conditions.lisp (file).

Source

jingoh.org.asd.

Parent Component

jingoh.org (system).

Public Interface
Internals

3.1.10 jingoh.org/deforg.lisp

Dependency

org.lisp (file).

Source

jingoh.org.asd.

Parent Component

jingoh.org (system).

Public Interface
Internals

*orgs* (special variable).


3.1.11 jingoh.org/miscellaneous.lisp

Dependencies
Source

jingoh.org.asd.

Parent Component

jingoh.org (system).

Public Interface
Internals

3.1.12 jingoh.tester/package.lisp

Source

jingoh.tester.asd.

Parent Component

jingoh.tester (system).

Packages

jingoh.tester.


3.1.13 jingoh.tester/report.lisp

Dependency

package.lisp (file).

Source

jingoh.tester.asd.

Parent Component

jingoh.tester (system).

Public Interface
Internals

3.1.14 jingoh.tester/miscellaneous.lisp

Dependency

package.lisp (file).

Source

jingoh.tester.asd.

Parent Component

jingoh.tester (system).

Public Interface
Internals

3.1.15 jingoh.tester/tester.lisp

Dependencies
Source

jingoh.tester.asd.

Parent Component

jingoh.tester (system).

Public Interface
Internals

3.1.16 jingoh.examiner/examine.lisp

Source

jingoh.examiner.asd.

Parent Component

jingoh.examiner (system).

Packages

jingoh.examiner.

Public Interface
Internals

3.1.17 jingoh.reader/reader.lisp

Source

jingoh.reader.asd.

Parent Component

jingoh.reader (system).

Packages

jingoh.reader.

Public Interface
Internals

4 Packages

Packages are listed by definition order.


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

4.1 jingoh.tester

Source

package.lisp.

Use List
Used By List
Public Interface
Internals

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

4.2 jingoh.examiner

Source

examine.lisp.

Use List
Used By List

jingoh.

Public Interface
Internals

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

4.3 jingoh.reader

Source

reader.lisp.

Use List

common-lisp.

Used By List

jingoh.

Public Interface
Internals

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

4.4 jingoh

Source

package.lisp.

Use List
Public Interface

setup (macro).


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

4.5 jingoh.org

Source

package.lisp.

Nickname

org

Use List

common-lisp.

Used By List
Public Interface
Internals

5 Definitions

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


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

5.1 Public Interface


Next: , Previous: , Up: Public Interface   [Contents][Index]

5.1.1 Special variables

Special Variable: *break-on-finish*

Breaks when finish examine.

Package

jingoh.examiner.

Source

examine.lisp.

Special Variable: *issues*

# \*ISSUES\*

## Description:
Previous issues.

“‘lisp
#?(let ((*org* (make-org)) *on-fails* *issues*)
(eval ’(defspec (+) => 1)) (examine *org*) *issues*)
:satisfies (lambda ($result) (& (listp $result) (= 1 (length $result)) (every #’issue-p $result))) , :stream
“‘
Value type is LIST

“‘lisp
#?
*ISSUES* :be-the
“‘
Initial value is NIL

## Affected By:
EXAMINE

## Notes:
Debug use.

Package

jingoh.examiner.

Source

examine.lisp.

Special Variable: *on-fails*

# \*ON-FAILS\*

## Description:
Specify EXAMINE’s behavior.

## Value type is (member :error :stop nil)

“‘lisp
#?
*ON-FAILS* :be-the
“‘
If :ERROR, debugger is immediately invoked when one test is failed.

“‘lisp
#?(let (*break-on-finish*
(*org* (make-org))
(*on-fails* :error))
(eval ’(defspec (+) => 1))
(eval ’(defspec (+) => 0))
(examine *org*))
:invokes-debugger jingoh.examiner::break-on-fails
“‘
If :STOP, EXAMINE is immediately stop successfully when one test is failed.

“‘lisp
#?(let (*break-on-finish*
(*org* (make-org))
(*on-fails* :stop))
(eval ’(defspec (+) => 1))
(eval ’(defspec (+) => 0))
(examine *org*))
:outputs #.(format NIL "~2%; Stop to examine cause *ON-FAILS* at NIL~2%~A ~%" (make-instance ’test-issue :form ’(+)
:expected 1
:actual 0
:test ’eql)
(cl-ansi-text:red "1 fail"))
“‘
Initial value is NIL

## Affected By:
none

## Notes:

Package

jingoh.examiner.

Source

examine.lisp.

Special Variable: *org*

# \*ORG\*
Current org.
Value type is ORG

“‘lisp
#?
*ORG* :be-the
“‘
Initial value is #<ORG NIL>

## Affected By:
IN-ORG

## Notes:
# conditions

Package

jingoh.org.

Source

deforg.lisp.

Special Variable: *read-print*

# \*READ-PRINT\*

## Control verbosity of |\#reader|.

“‘lisp
#?(let ((*readtable* (copy-readtable nil)) (*read-print* T))
(enable)
(with-input-from-string (in "#?(+) => 0") (read in)))
:output-satisfies (lambda ($string) (with-input-from-string (in $string)
(& (string= "" (read-line in))
(string= "#:TEST-FORM: (+)" (read-line in)) (string= "#:KEYWORD: =>" (read-line in)) (string= "#:EXPECTED: 0" (read-line in)) (char= #\R (read-char in))
(char= #\E (read-char in))
(char= #\A (read-char in))
(char= #\D (read-char in))
(char= #\: (read-char in))
(equal ‘(defspec(+) => 0 :LINE NIL) (read in))
(null (read in nil nil)))))
, :stream
“‘
Value type is NULL

“‘lisp
#?
*READ-PRINT* :be-the
“‘
Initial value is NIL

## Affected By:
none

## Notes:

Package

jingoh.reader.

Source

reader.lisp.

Special Variable: *read-verbose*

# \*READ-VERBOSE\*

## Description:
Controls verbosity of |\#?reader|

“‘lisp
#?(let ((*readtable* (copy-readtable nil)) (*read-verbose* T))
(enable)
(with-input-from-string (in "#?(+) => 0")
(read in)))
:output-satisfies (lambda ($string)
(& (string= (format nil "~%READ: ")
(subseq $string 0 7))
(equal (with-input-from-string (in $string :start 7) (read in))
‘(defspec (+) => 0 :LINE NIL))))
, :stream
“‘
Value type is NULL

“‘lisp
#?
*READ-VERBOSE* :be-the
“‘
Initial value is NIL

## Affected By:
none

## Notes:

Package

jingoh.reader.

Source

reader.lisp.

Special Variable: *verbose*

# \*VERBOSE\*

## Description:
Controls examine’s verbosity. For detail, see EXAMINE. Value type is (INTEGER 0 3)

“‘lisp
#?
*VERBOSE* :be-the
“‘
Initial value is 2

## Affected By:
EXAMINE

## Notes:

Package

jingoh.examiner.

Source

examine.lisp.


5.1.2 Macros

Macro: & (&body body)

# &

## Description:
When (cl:and ...) is failed, we are not able to get information about which clause is failed.
& provides such information.

“‘lisp
#?(& T T T)
=> T
“‘

“‘lisp
#?(& T NIL T)
:signals jingoh.tester::UNSATISFIED
“‘

### syntax
(& &body body)
=> result

## Arguments and Values:
body := some forms which generates non NIL value.
result := When all form return non NIL value, returns T. Otherwise error.

## Affected By:
none

## Side-Effects:
none

## Notes:
When one form is evaluated to NIL, short cut is occur.

“‘lisp
#?(& T NIL (princ :hoge))
:signals jingoh.tester::UNSATISFIED
“‘
*TIPS* - When clause is function, :args slot contains arguments.

“‘lisp
#?(handler-case (& (eq :hoge :fuga)) (jingoh.tester::unsatisfied (c)
(jingoh.tester::args c)))
=> (:hoge :fuga)
, :test
“‘
But when cluase is variable, macro form, or special form, :args slot is stored with NIL.

“‘lisp
#?(handler-case (& (and (eq :hoge :fuga))) (jingoh.tester::unsatisfied (c)
(jingoh.tester::args c)))
=> NIL
“‘

## Exceptional-Situations:

Package

jingoh.tester.

Source

tester.lisp.

Macro: ? (&body body)

# ?

## Description:
One shot tester.

“‘lisp
#?(? (+) => 0)
=> NIL
“‘

“‘lisp
#?(? (+) => 1)
:satisfies (lambda ($result)
(& (listp $result)
(= 1 (length $result))
(every #’issue-p $result)))
“‘

### syntax
(? &body body)
=> result

## Arguments and Values:
body := (test-form dispatch-key expected option*)
test-form := form which is tested.
dispatch-key := (member => :be-the :satisfies :outputs :values :multiple-value-satisfies :output-satisfies :expanded-to :equivalents :signals :invokes-debugger) expected := lisp value which is expected value of test-form.
option := key value pair.
key := (member :test :lazy :ignore-signals :with-restarts :stream :before :after :around :line :as :timeout)

### dispatch-keys.

standard usage.

“‘lisp
#?(? (+) => 0)
=> NIL
“‘
When expected value is unreadable object, use :be-the.

“‘lisp
#?(? #’car :be-the function)
=> NIL
“‘
Above code can write like below.

“‘lisp
#?(? #’car :satisfies functionp)
=> NIL
“‘
To test multiple values, use :values

“‘lisp
#?(? (floor 2 3) :values (0 2))
=> NIL
“‘
To test output strings, use :outputs

“‘lisp
#?(? (princ :foo) :outputs "FOO")
=> NIL
“‘
To test complex multiple values, use :multiple-value-satisfies.

“‘lisp
#?(? (values 0 *standard-output*)
:multiple-value-satisfies (lambda (n s)
(& (numberp n)
(streamp s))))
=> NIL
“‘
To test complex string, use :output-satisfies
TODO
To test condition, use :signals.

“‘lisp
#?(? (error "error") :signals ERROR)
=> NIL
“‘

“‘lisp
#?(? (signal ’warning) :signals warning)
=> NIL
“‘
Corner case: Handling unknown condition.

“‘lisp
#?(? (error "error") :signals unknown-condition)
:satisfies (lambda (result)
(and (listp result)
(every #’issue-p result)))
, :ignore-signals
“‘
ccl need.
To test debugger is invoked or not, use :invokes-debugger

“‘lisp
#?(? (invoke-debugger (make-condition ’error)) :invokes-debugger ERROR)
=> NIL
“‘
Corner case: Handling unknown condition.

“‘lisp
#?(? (invoke-debugger (make-condition ’error)) :invokes-debugger unknown-condition)
:satisfies (lambda (result)
(and (listp result)
(every #’issue-p result)))
, :ignore-signals
“‘
ccl need.
To test macro expansion, use :expanded-to

“‘lisp
#?(& T)
:expanded-to (progn (assert t () ’jingoh.tester::unsatisfied
:test-form ’T)
T)
“‘
To test two codes are semantically equal, use :equivalents

“‘lisp
#?(loop :for i :in ’(1 2 3) :sum i)
:equivalents (reduce #’+ ’(1 2 3))
“‘

### option keys

When expected value is not symbol, character or integer, use :test option.

“‘lisp
#?(? (list 1 2 3) => (1 2 3) :test equal)
=> NIL
“‘
To ignore condition especially warning, use :ignore-signals.

“‘lisp
#?(? (progn (warn "warning")
t)
=> T :ignore-signals warning :stream nil)
=> NIL
, :ignore-signals
“‘

“‘lisp
#?(? (signal ’warning) => NIL :ignore-signals warning)
=> NIL
, :ignore-signals
“‘
To test compile time error is occur, use :lazy.

“‘lisp
#?(? (defun "invalid" () (princ :hoge))
:signals ERROR :lazy T)
=> NIL
“‘
To test restart is available, use :with-restarts with :signals.

“‘lisp
#?(? (warn "warning") :signals warning :with-restarts muffle-warning)
=> NIL
“‘
When dispatch key is :outputs, you can specify stream by :stream.

“‘lisp
#?(? (princ :foo *error-output*) :outputs "FOO" :stream *error-output*)
=> NIL
“‘
When test needs setup, you can use :before.

“‘lisp
#?(? (princ :foo) :outputs "HOGEFOO" :before (princ :hoge))
=> NIL
“‘
When test needs teardown, you can use :after.

“‘lisp
#?(? (princ :foo) :outputs "FOOBAR" :after (princ :bar))
=> NIL
“‘
*NOTE!* - Internally, :after is placed as clean up form of CL:UNWIND-PROTECT, so :after’s return value is discarded.

“‘lisp
#?(? (+) => 0 :after 1)
=> NIL
“‘
In many cases, :around is useful instead of :before or :after.
Inside of :aroud, you must call CALL-BODY like CL:CALL-NEXT-METHOD.

“‘lisp
#?(? a => 0 :around (let ((a 0))
(call-body)))
=> NIL
“‘
:line is used to store file line internally.

“‘lisp
#?(? t => NIL :line 123)
:satisfies (lambda ($result)
(& (listp $result)
(= 1 (length $result))
(every #’issue-p $result)
(= 123 (issue-line (car $result)))))
“‘
:as is used internally to substitute.
And it is specifyed via COMMON-REQUIREMENTS-ABOUT only.

“‘lisp
#?(let ((*org* (make-org)))
(common-requirements-about (car first) :as command)
;; In order to delay macro expansion, EVAL is needed.
;; Because defspec refers *ORG* at macro expansion time.
(eval ’(defspec (command ’(1 2 3)) => 1))
(uiop:while-collecting (collect)
(do-requirements (req) (collect (check req)))))
=> (NIL NIL)
, :test
“‘
:timeout is used to set timeout.
The default is 1 sec.

“‘lisp
#?(? (sleep 0.1) => NIL :timeout 0.2)
=> NIL
“‘
result := list which includes issues.

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

## Tests.
Edge case.
Using literal circular list.

“‘lisp
#?(? ’#0=(:a . #0#) :be-the list)
=> NIL
“‘
Edge case.
Can test signal.

“‘lisp
#?(signal ’error)
=> NIL
, :ignore-signals
“‘

Package

jingoh.tester.

Source

tester.lisp.

Macro: common-requirements-about ((&rest subject*) &rest option* &key as &allow-other-keys)

# COMMON-REQUIREMENTS-ABOUT

## Description:
Declare current subjects of current org.

“‘lisp
#?(common-requirements-about (first car) :as op)
=> (FIRST CAR)
, :test
“‘

### syntax
(COMMON-REQUIREMENTS-ABOUT (&rest subject\*) &rest option\* &key (as (error "keyword parameter :as is required."))) => result

## Arguments and Values:
subject := subject-designator. Described later.
Otherwise error.

“‘lisp
#?(common-requirements-about (0 "hoO") :as op)
:signals ERROR
, :lazy
“‘
option := key value pair.
Supported key value pair is unspecified,
but :AS is required. See below.
as := symbol. Otherwise error.

“‘lisp
#?(common-requirements-about (first car) :as 0)
:signals error
, :lazy
“‘
specify alias for common subjects.
result := List which includes specified subjects.

## Affected By:
*ORG*

## Side-Effects:
Modify *ORG* current-subject slot and options slot.

“‘lisp
#?(let (acc)
(deforg :demo)
(in-org :demo)
(push (org-current-subjects *org*) acc)
(push (org-options *org*) acc)
(common-requirements-about (car first) :as op)
(push (org-current-subjects *org*) acc)
(push (org-options *org*) acc)
(nreverse acc))
=> ((NIL) NIL (CAR FIRST) (:AS OP))
, :test
“‘

## Notes:

## Exceptional-Situations:
# internal apis for hackers.

Package

jingoh.org.

Source

deforg.lisp.

Macro: deforg (name)

# DEFORG

## Description:
Define new ORGanization object for your system.

“‘lisp
#?(deforg :demo)
:be-the ORG
“‘

### syntax
(DEFORG name)
=> result

## Arguments and Values:
name := symbol, otherwise ERROR.

“‘lisp
#?(deforg "ERROR")
:signals error
, :lazy
“‘
result := org

## Affected By:
none

## Side-Effects:
Underlying org database is modified.

## Notes:
DEFORG does not affect current org.
It is same like CL:DEFPACKAGE.

“‘lisp
#?(progn (deforg :demo)
(org-name *org*))
:satisfies (lambda ($name) (not (eq :demo $name))) “‘

## Exceptional-Situations:

Package

jingoh.org.

Source

deforg.lisp.

Macro: defspec (&body body)

# DEFSPEC

## Description:
Define specification.

### syntax
(DEFSPEC &body body)
=> result

## Arguments and Values:
body := see ?
result := list which represents current subjects.

“‘lisp
#?(defspec (+) => 0)
=> (NIL)
, :test
“‘

## Affected By:
*org*

## Side-Effects:
Modify *ORG*’s specification slot.

“‘lisp
#?(progn (princ (org-requirements-count *org*)) (defspec (+) => 0)
(princ (org-requirements-count *org*))) :outputs "01"
“‘

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

tester.lisp.

Macro: do-requirements ((var &optional <subject-designator> <org> <return>) &body body)

# DO-REQUIREMENTS

## Description:
Iterate forms for each requirements.

“‘lisp
#?(do-requirements (req)
(princ req))
:outputs "01"
“‘

### syntax
(DO-REQUIREMENTS (var &optional (subject-designator t) (org ’\*org\*) return) &body body)
=> result

## Arguments and Values:
var := When symbol, it is bound by each requirement.
When list, its first element is symbol which is bound by each requirment,
and, second element is symbol which is bound by such requirement’s sbuject.

“‘lisp
#?(do-requirements ((req sub))
(format t "~&~S ~S"req sub))
:outputs "0 SUBJECT
1 SUBJECT"
“‘
subject-designator := subject designator, described later.
org := org generate form. when such form does not generate org, an implementation dependent condition is signaled.

“‘lisp
#?(do-requirements (req t :not-org)
(princ req))
:signals condition
“‘
return := return value generate form.

“‘lisp
#?(do-requirements (req t *org* (princ :end))
(princ req))
:outputs "01END"
“‘
inside return form, VAR is able to seen but it is bound by NIL.

“‘lisp
#?(do-requirements (req t *org* (princ req))
(princ req))
:outputs "01NIL"
“‘
any values are able to be returned.

“‘lisp
#?(let ((sum 0))
(do-requirements (req t *org* (values sum 1 2 3))
(incf sum req)))
:values (1 1 2 3)
“‘
body := implicit progn.
Body wrapped implicit block named nil, so you can return.

“‘lisp
#?(do-requirements (req t *org* (princ :never))
(if (zerop req)
(return :hoge)
(princ req)))
=> :hoge
“‘
CL:DECLARE can appear in top of BODY.

“‘lisp
#?(do-requirements (req)
(declare (type integer req))
(princ req))
:outputs "01"
“‘
result := value which return form generates.
The default is nil.

“‘lisp
#?(do-requirements (req)
(+ req))
=> NIL
“‘

## Affected By:
*org* when org is not specified.
org-current-subjects when subject is not specified, or specified as T.
org-specifications when subject is specified by nil.

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

miscellaneous.lisp.

Macro: enable (&optional char)

# ENABLE

## Description:
Set dispatch macro wich specified character to ‘*readtable*‘.

“‘lisp
#?(let ((*readtable* (copy-readtable nil)))
(values (named-readtables::%get-dispatch-macro-character #\# #\? *readtable*) (enable)
(named-readtables::%get-dispatch-macro-character #\# #\? *readtable*))) :multiple-value-satisfies (lambda ($1 $2 $3)
(& (null $1)
$2
$3))
“‘

### syntax
(ENABLE &optional (char #\?))
=> result

## Arguments and Values:
char := form generates character.
When CHAR does not generate character, an error is signaled.

“‘lisp
#?(enable 0)
:signals error
, :ignore-signals
“‘
result := implementation dependent.

## Affected By:
‘*readtable*‘

## Side-Effects:
May modify ‘*readtable*‘ state.

## Notes:

## Exceptional-Situations:
When specified dispatch macro character is already used,
an error of type MACRO-CHAR-CONFLICTION is signaled with
restart named REPLACE.

“‘lisp
#?(let ((*readtable* (copy-readtable nil)))
(enable #\*))
:signals MACRO-CHAR-CONFLICTION
, :with-restarts
“‘

Package

jingoh.reader.

Source

reader.lisp.

Macro: in-org (name)

# IN-ORG

## Description:
Modify current org.

“‘lisp
#?(progn (deforg :demo)
(princ (org-name (in-org :demo)))
(princ (org-name *org*)))
:outputs "DEMODEMO"
“‘

### syntax
(IN-ORG name)
=> result

## Arguments and Values:
name := org-designator, otherwise error.

“‘lisp
#?(in-org 0)
:signals error
, :lazy
“‘
result := org

“‘lisp
#?(progn (deforg :demo)
(in-org :demo))
:be-the ORG
“‘

## Affected By:
Underlying org database.

## Side-Effects:
Modify *ORG*.

## Notes:

## Exceptional-Situations:
When specified org does not exist, an error is signaled.

“‘lisp
#?(in-org :no-such-org)
:signals MISSING-ORG
“‘

Package

jingoh.org.

Source

deforg.lisp.

Macro: requirements-about (subject &rest option*)

# REQUIREMENTS-ABOUT

## Description:
Declare current subject of current org.

### syntax
(REQUIREMENTS-ABOUT subject &rest option\*)
=> result

“‘lisp
#?(requirements-about +)
=> (+)
, :test
“‘

## Arguments and Values:
subject := subject-designator. ; see subject-designator below. Otherwise error.

“‘lisp
#?(requirements-about 0)
:signals error
, :lazy
“‘
option := keyword value pair.
Supportted keys are unspecified.
It is not jingoh.org’s respond.
result := List which includes current subjects.

## Affected By:
*ORG*

## Side-Effects:
Modify *ORG* current-subject slot and options slot.

“‘lisp
#?(let (acc)
(deforg :demo)
(in-org :demo)
(push (org-current-subjects *org*) acc)
(push (org-options *org*) acc)
(requirements-about + :key :value)
(push (org-current-subjects *org*) acc)
(push (org-options *org*) acc)
(nreverse acc))
=> ((NIL) NIL (+) (:KEY :VALUE))
, :test
“‘

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

deforg.lisp.

Macro: setup (name)
Package

jingoh.

Source

package.lisp.

Macro: with-examiner-context (form)
Package

jingoh.examiner.

Source

examine.lisp.

Macro: with-integrated-output-stream ((var) &body body)
Package

jingoh.tester.

Source

miscellaneous.lisp.


5.1.3 Ordinary functions

Function: #?reader (stream character number)

# |#?reader|

## Description:
Dismatch macro function for making DEFSPEC form.

“‘lisp
#?(let ((*readtable* (copy-readtable nil)))
(enable)
(with-input-from-string (in "#?(+) => 0")
(read in)))
=> (DEFSPEC (+) => 0 :LINE NIL)
, :test
“‘

### syntax
(|#?reader| stream character number)
=> result

## Arguments and Values:
stream := input stream
character := dispatch macro character.
number := (or null integer)
result := DEFSPEC form.

## Affected By:
‘*read-base*‘ ‘*read-default-float-format*‘ ‘*read-eval*‘ ‘*read-suppress*‘ ‘*readtable*‘ ‘*read-verbose*‘ ‘*read-print*‘

## Side-Effects:
consume stream contents.

## Notes:

## Exceptional-Situations:

## Tests.
Can handle read time labeling.

“‘lisp
#?(let ((*readtable* (copy-readtable nil)))
(enable)
(with-input-from-string (s "#?(list #0=1 #0#) => (#1=1 #1#) ,:test equal")
(read s)))
=> (defspec (list #0=1 #0#) => (1 1) :line nil :test equal)
, :test
“‘

Package

jingoh.reader.

Source

reader.lisp.

Function: add-new-option-key (key)

# ADD-NEW-OPTION-KEY

## Description:

### syntax
(ADD-NEW-OPTION-KEY key)
=> result

## Arguments and Values:
key := keyword, otherwise TYPE-ERROR is signaled.

“‘lisp
#?(add-new-option-key "not-keyword-symbol") :signals condition
“‘
result := key

“‘lisp
#?(add-new-option-key :this-is-returned)
=> :THIS-IS-RETURNED
, :after
“‘

## Affected By:

## Side-Effects:
JINGOH.ORG::*OPTION-KEYS* is modified.

## Notes:
Do nothing when key is conflicted.

“‘lisp
#?(values (find-option-key :as) (add-new-option-key :as))
:values (:AS :AS)
“‘

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Function: add-requirement (subject requirement &optional org)

# ADD-REQUIREMENT

## Description:
add requirement into org.

“‘lisp
#?(add-requirement ’subject 0)
=> 0
“‘

### syntax
(ADD-REQUIREMENT subject requirement &optional (org \*org\*)) => result

## Arguments and Values:
subject := symbol, otherwise implementation dependent condition.

“‘lisp
#?(add-requirement "not symbol" 0)
:signals condition
“‘
requirement := any lisp object. unspecified.
org := org, otherwise implementation dependent condition.

“‘lisp
#?(add-requirement ’subject :value :not-org)
:signals condition
“‘
result := requirement

## Affected By:
*org* when org is not specified.

## Side-Effects:
specified org object is destructively modified.

“‘lisp
#?(progn (princ (org-requirements-count *org*)) (add-requirement ’subject 0)
(princ (org-requirements-count *org*)))
:outputs "01"
“‘

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

miscellaneous.lisp.

Function: canonicalize (test-form parameters)

# CANONICALIZE

## Description:
Helper for MAKE-REQUIREMENT

“‘lisp
#?(canonicalize ’(+) ())
:satisfies (lambda (form)
(equal form
(if bt:*supports-threads-p*
’(bt:with-timeout (1)
(+))
’(+))))
“‘

### syntax
(CANONICALIZE test-form parameters)
=> result

## Arguments and Values:
test-form := form which is tested.
parameters := key value pair.
key := (member :before :after :around :lazy :timeout)

“‘lisp
#?(canonicalize ’(+) ’(:before (print :before))) :satisfies (lambda (form)
(equal form
‘(progn (print :before)
,(if bt:*supports-threads-p*
’(bt:with-timeout (1)
(+))
’(+)))))
“‘

“‘lisp
#?(canonicalize ’(+) ’(:after (print :after))) :satisfies (lambda (form)
(equal form
‘(unwind-protect ,(if bt:*supports-threads-p* ’(bt:with-timeout (1)
(+))
’(+))
(print :after))))
“‘

“‘lisp
#?(canonicalize ’(+) ’(:around (let ((a 0)) (call-body)))) :satisfies (lambda (form)
(equal form
‘(let ((a 0))
,(if bt:*supports-threads-p* ’(bt:with-timeout (1)
(+))
’(+)))))
“‘

“‘lisp
#?(canonicalize ’(+) ’(:lazy t))
:satisfies (lambda (form)
(equal form
(if bt:*supports-threads-p*
’(bt:with-timeout (1)
(eval (macroexpand ’(+))))
’(eval (macroexpand ’(+))))))
“‘

“‘lisp
#?(canonicalize ’(+) ’(:timeout 2))
:satisfies (lambda (form)
(equal form
(if bt:*supports-threads-p*
’(bt:with-timeout (2)
(+))
’(+))))
“‘
result := form.

## Affected By:
none

## Side-Effects:
none

## Notes:
form is copied.

“‘lisp
#?(let*((form (list ’+))
(result(canonicalize form ())))
(rplaca form ’-)
result)
:satisfies (lambda (form)
(equal form
(if bt:*supports-threads-p*
’(bt:with-timeout (1) (+))
’(+))))
“‘

## Exceptional-Situations:
when unsupported key comes (See ?), an error is signaled.

“‘lisp
#?(canonicalize ’(+) ’(:no-such-key :comes))
:signals error
“‘

Package

jingoh.tester.

Source

miscellaneous.lisp.

Function: check (requirement)

# CHECK

## Description:
accept requirement, then check it.

“‘lisp
#?(check ’((+) => 0))
=> NIL
“‘

### syntax
(CHECK requirement)
=> result

## Arguments and Values:
requirement := unspecified.
result := list which may includes issues.

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

tester.lisp.

Function: clear-option-keys ()

# CLEAR-OPTION-KEYS

## Description:

### syntax
(CLEAR-OPTION-KEYS)
=> result

“‘lisp
#?(let ((jingoh.org::*option-keys* (make-hash-table))) (values (add-new-option-key :one) (add-new-option-key :two) (find-option-key :one) (find-option-key :two)
(type-of (clear-option-keys)) (find-option-key :one nil) (find-option-key :two nil)))
:values (:ONE :TWO :ONE :TWO HASH-TABLE NIL NIL) “‘

## Arguments and Values:
result := hash-table

## Affected By:
JINGOH.ORG::*OPTION-KEYS*

## Side-Effects:
JINGOH.ORG::*OPTION-KEYS*

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Reader: condition-issue-message (instance)

# CONDITION-ISSUE-MESSAGE

## Description:
return condition message string.

“‘lisp
#?(loop :for name :in *condition-issues*
:always (string= "message" (condition-issue-message (make-instance name :message "message")))) => T
“‘

### syntax
(CONDITION-ISSUE-MESSAGE sb-kernel:instance)
=> result
### setf
(SETF (CONDITION-ISSUE-MESSAGE SB-KERNEL:INSTANCE) SB-KERNEL::VALUE)
=> new-value

## Arguments and Values:
instance := condition-issue, otherwise error.

“‘lisp
#?(loop :for name :in (set-difference *issues* *condition-issues*)
:never (ignore-errors (condition-issue-message (make-instance name))))
=> T
“‘

“‘lisp
#?(condition-issue-message 0)
:signals error
, :lazy
“‘
result := (or string null)

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Target Slot

message.

Writer: (setf condition-issue-message) (instance)
Package

jingoh.tester.

Source

report.lisp.

Target Slot

message.

Function: condition-issue-p (object)

# CONDITION-ISSUE-P

## Description:
Tests arg is condition-issue.

“‘lisp
#?(let ((issues (mapcar #’make-instance *condition-issues*)))
(every #’condition-issue-p issues))
=> T
“‘

“‘lisp
#?(let ((issues (mapcar #’make-instance (set-difference *issues* *condition-issues*)))) (notany #’condition-issue-p issues))
=> T
“‘

### syntax
(CONDITION-ISSUE-P sb-kernel::object)
=> result

## Arguments and Values:
object := T

“‘lisp
#?(condition-issue-p 0)
:invokes-debugger not
“‘
result := boolean

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Function: debugger-was-invoked-p (object)

# ERROR-WAS-SIGNALED-P, WARNING-WAS-SIGNALED-P, DEBUGGER-WAS-INVOKED-P, UNMATCH-CONDITION-P, UNEXPECTED-SUCCESS-P, UNEXPECTED-OUTPUT-P, ISSUE-OF-MULTIPLE-VALUES-P, MISSING-RESTARTS-P, UNSATISFIED-CLAUSE-P, WRONG-FORMAT-P

## [Predicates]

## Description:
Tests.

“‘lisp
#?(let* ((pred-name (symbol-name ’pred))
(issue-name (find-symbol (subseq pred-name 0 (- (length pred-name) 2)))))
(pred (make-instance issue-name)))
=> T
“‘

### syntax
(ERROR-WAS-SIGNALED-P sb-kernel::object)
=> result

## Arguments and Values:
object := T

“‘lisp
#?(pred 0)
:invokes-debugger NOT
“‘
result := boolean

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Function: delete-option-key (key)

# DELETE-OPTION-KEY

## Description:

### syntax
(DELETE-OPTION-KEY key)
=> result

## Arguments and Values:
key := T

“‘lisp
#?(delete-option-key :no-such)
=> NIL
“‘
result := BOOLEAN, T when KEY exists.

“‘lisp
#?(values (delete-option-key :no-such-key) (add-new-option-key :no-such-key) (delete-option-key :no-such-key)) :values (NIL :NO-SUCH-KEY T)
“‘

## Affected By:
JINGOH.ORG::*OPTION-KEYS*

## Side-Effects:
Destructively modify JINGOH.ORG::*OPTION-KEYS*.

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Function: delete-org (org-designator)

# DELETE-ORG

## Description:
delete specified org from underlying org database.

“‘lisp
#?(let (acc)
(push (find-org :hoge nil) acc)
(register-org :hoge (make-org :name :hoge))
(push (find-org :hoge) acc)
(delete-org :hoge)
(push (find-org :hoge nil) acc)
(nreverse acc))
:satisfies (lambda ($result)
(destructuring-bind (existp1 hoge existp2) $result (& (null existp1)
(org-p hoge)
(null existp2))))
“‘

### syntax
(DELETE-ORG org-designator)
=> result

## Arguments and Values:
org-designator := org-designator, described later.
result := T

## Affected By:
Underlying org database.

## Side-Effects:
Modify underlying org database.

## Notes:
Return value is always T, even if any org is deleted.

## Exceptional-Situations:

Package

jingoh.org.

Source

deforg.lisp.

Function: delete-subject (subject-designator &optional org)

# DELETE-SUBJECT

## Description:
delete subject from org.

“‘lisp
#?(progn (do-requirements ((req sub) nil)
(declare (ignore req))
(princ sub))
(delete-subject ’subject)
(do-requirements ((req sub) nil)
(declare (ignore req))
(princ sub)))
:outputs "SUBJECTANOTHERANOTHER"
“‘

### syntax
(DELETE-SUBJECT subject-designator &optional (org \*org\*)) => result

## Arguments and Values:
subject-designator := subject-designator, describe later org := org, otherwise implementation dependent condition

“‘lisp
#?(delete-subject ’subject :not-org)
:signals condition
“‘
result := T

“‘lisp
#?(delete-subject ’subject)
=> T
“‘

## Affected By:
*org* when org is not specified.
Org-current-subject when subject is not specified,
or specified by T.

## Side-Effects:
org specifications is modified destructively.

## Notes:
return value is always T even no subject is deleted.

“‘lisp
#?(delete-subject :no-such-subject)
=> T
“‘

## Exceptional-Situations:

#### The guard for allegro.

Package

jingoh.org.

Source

deforg.lisp.

Function: encallable (form &optional not-first-p)

# ENCALLABLE

## Description:
tiny helper for writing macro.

“‘lisp
#?(encallable ”car)
=> CAR
“‘

“‘lisp
#?(encallable ”car t)
=> #’CAR
, :test
“‘

“‘lisp
#?(encallable #’car)
:signals error
“‘

“‘lisp
#?(encallable #’car t)
:signals error
“‘

“‘lisp
#?(encallable ’#’car)
=> CAR
“‘

“‘lisp
#?(encallable ’(lambda (x) (print x)))
=> (LAMBDA (X) (PRINT X))
, :test
“‘

“‘lisp
#?(encallable (lambda (x) (print x)))
:signals error
“‘

### syntax
(ENCALLABLE form &optional not-first-p)
=> result

## Arguments and Values:
form := function or function-name
not-first-p := boolean
result := function (when not-first-p is true)
or function-name (when not-first-p is false (the default)).

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

miscellaneous.lisp.

Function: error-was-signaled-p (object)

# ERROR-WAS-SIGNALED-P, WARNING-WAS-SIGNALED-P, DEBUGGER-WAS-INVOKED-P, UNMATCH-CONDITION-P, UNEXPECTED-SUCCESS-P, UNEXPECTED-OUTPUT-P, ISSUE-OF-MULTIPLE-VALUES-P, MISSING-RESTARTS-P, UNSATISFIED-CLAUSE-P, WRONG-FORMAT-P

## [Predicates]

## Description:
Tests.

“‘lisp
#?(let* ((pred-name (symbol-name ’pred))
(issue-name (find-symbol (subseq pred-name 0 (- (length pred-name) 2)))))
(pred (make-instance issue-name)))
=> T
“‘

### syntax
(ERROR-WAS-SIGNALED-P sb-kernel::object)
=> result

## Arguments and Values:
object := T

“‘lisp
#?(pred 0)
:invokes-debugger NOT
“‘
result := boolean

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Function: examine (org &key subject on-fails verbose vivid)

# EXAMINE

## Description:
Examine requirements then print result.

### syntax
(EXAMINE org &key subject ((:verbose \*verbose\*) \*verbose\*) ((:vivid \*print-vivid\*)\*print-vivid\*))
=> result

## Arguments and Values:
org := org-designator, otherwise error

“‘lisp
#?(examine 0)
:signals condition
“‘
subject := subject-designator, otherwise error

“‘lisp
#?(let ((*org* (make-org))
*issues*)
(examine *org* :subject 0))
:signals missing-subject
“‘
*verbose* := (mod 4) specify verbosity of print.
when specified 0, only summary printed.

“‘lisp
#?(let ((*org* (make-org))
*issues*)
(eval ’(defspec (+) => 0))
(examine *org* :verbose 0))
:outputs #.(format nil "~A NIL~%"(cl-ansi-text:green "Pass"))
“‘
when specified 1, issues are printed when fails.

“‘lisp
#?(let ((*org* (make-org))
*issues*)
(eval ’(defspec (+) => 0))
(examine *org* :verbose 1))
:outputs #.(format nil "~A NIL~%"(cl-ansi-text:green "Pass"))
“‘

“‘lisp
#?(let ((*org* (make-org))
*issues*
*on-fails*)
(eval ’(defspec (+) => 1))
(examine *org* :verbose 1))
:outputs #.(format nil "~A in NIL~%~S ~%"
(cl-ansi-text:red "1 fail")
(make-instance ’test-issue :form ’(+)
:expected 1
:actual 0
:test ’eql))
“‘
when specified 2 (the default.), progress is also printed.

“‘lisp
#?(let ((*org* (make-org))
*issues*)
(eval ’(defspec (+) => 0))
(examine *org*))
:outputs #.(format nil "~%NIL~A~%~A NIL~%"
(cl-ansi-text:green ".")
(cl-ansi-text:green "Pass"))
“‘
When specified 3, each test is printed.

“‘lisp
#?(let ((*org* (make-org))
*issues*)
(eval ’(defspec (+) => 0))
(examine *org* :verbose 3))
:outputs #.(format nil "~2%NIL~%~A ~S~%~A NIL~%"
(cl-ansi-text:green "Pass")
’((+) => 0)
(cl-ansi-text:green "Pass"))
“‘
vivid := boolean, control print colorization.
result := nil

“‘lisp
#?(let ((*org* (make-org))
*issues*)
(eval ’(defspec (+) => 0))
(examine *org*))
=> NIL
, :stream
“‘

## Affected By:
*verbose* *on-fails*

## Side-Effects:
print to *standard-output*

## Notes:
If you want to modify format of ISSUE,
you can write CL:PRINT-OBJECT which specialized by ISSUE.

## Exceptional-Situations:
When org is not found, an error of type missing-org is signaled.

“‘lisp
#?(let ((*org* (make-org))
*issues*)
(examine :no-such-org))
:signals missing-org
“‘
When subject is not found, an error of type missing-subject is signaled.

“‘lisp
#?(let ((*org* (make-org))
*issues*)
(examine *org* :subject ’no-such-subject))
:signals missing-subject
“‘

Package

jingoh.examiner.

Source

examine.lisp.

Function: find-option-key (key &optional errorp)

# FIND-OPTION-KEY

## Description:

### syntax
(FIND-OPTION-KEY key &optional (errorp t))
=> result

## Arguments and Values:
key := T

“‘lisp
#?(find-option-key ’#:not-keyword nil)
:signals condition
“‘

“‘lisp
#?(find-option-key :no-such nil)
=> NIL
“‘
errorp := generalized-boolean, to specify signal an error unless found.

“‘lisp
#?(find-option-key :no-such-key)
:signals error
“‘

“‘lisp
#?(find-option-key :no-such-key nil)
=> NIL
“‘
result := (or KEY null)

“‘lisp
#?(find-option-key :as)
=> :AS
“‘

## Affected By:
State of JINGOH.ORG::*OPTION-KEYS*

“‘lisp
#?(let ((jingoh.org::*option-keys* (make-hash-table))) (find-option-key :as nil))
=> NIL
“‘

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Function: find-org (org-designator &optional errorp)

# FIND-ORG

## Description:
Find org from underlying org database.

### syntax
(FIND-ORG org-designator &optional (errorp t))
=> result

## Arguments and Values:
org-designator := org-designator, describe later. Otherwise nil.

“‘lisp
#?(find-org :dummy nil)
=> NIL
“‘
errorp := boolean, when specified T (the default) if specified org is not found, an error is signaled.

“‘lisp
#?(find-org :no-such-org)
:signals MISSING-ORG
“‘

“‘lisp
#?(find-org :no-such-org nil)
=> NIL
“‘
result := org when found, if org is not found and errorp specified NIL, NIL is returned, otherwise error was signaled.

## Affected By:
underlying org database.

## Side-Effects:
none

## Notes:
if ORG-DESIGNATOR is NIL, org which name is NIL is returned.

“‘lisp
#?(find-org nil)
:satisfies (lambda ($result)
(& (org-p $result)
(null (org-name $result))))
“‘

## Exceptional-Situations:

Package

jingoh.org.

Source

deforg.lisp.

Reader: issue-actual (instance)

# ISSUE-ACTUAL

## Description:
return actual value

“‘lisp
#?(loop :for name :in *issues*
:always (zerop (issue-actual (make-instance name :actual 0)))) => T
“‘

### syntax
(ISSUE-ACTUAL sb-kernel:instance)
=> result
### setf
(SETF (ISSUE-ACTUAL SB-KERNEL:INSTANCE) SB-KERNEL::VALUE)
=> new-value

## Arguments and Values:
instance := issue, otherwise error.

“‘lisp
#?(issue-actual 0)
:signals error
, :lazy
“‘
result := actual value

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Target Slot

actual.

Writer: (setf issue-actual) (instance)
Package

jingoh.tester.

Source

report.lisp.

Target Slot

actual.

Reader: issue-expected (instance)

# ISSUE-EXPECTED

## Description: return expected value.

“‘lisp
#?(loop :for name :in *issues*
:always (zerop (issue-expected (make-instance name :expected 0)))) => T
“‘

### syntax
(ISSUE-EXPECTED sb-kernel:instance)
=> result
### setf
(SETF (ISSUE-EXPECTED SB-KERNEL:INSTANCE) SB-KERNEL::VALUE)
=> new-value

## Arguments and Values:
instance := issue, otherwise error.

“‘lisp
#?(issue-expected 0)
:signals error
, :lazy
“‘
result := expected value

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Target Slot

expected.

Writer: (setf issue-expected) (instance)
Package

jingoh.tester.

Source

report.lisp.

Target Slot

expected.

Reader: issue-form (instance)

# ISSUE-FORM

## [Accessor] ISSUE-FORM

## Description:
return issue form.

“‘lisp
#?(let ((issues (loop :for name :in *issues*
:collect (make-instance name :form 0)))) (loop :for i :in issues
:always (zerop (issue-form i))))
=> T
“‘

### syntax
(ISSUE-FORM sb-kernel:instance)
=> result
### setf
(SETF (ISSUE-FORM SB-KERNEL:INSTANCE) SB-KERNEL::VALUE)
=> new-value

## Arguments and Values:
instance := issue, otherwise error.

“‘lisp
#?(issue-form 0)
:signals ERROR
, :lazy
“‘
result := form

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Target Slot

form.

Writer: (setf issue-form) (instance)
Package

jingoh.tester.

Source

report.lisp.

Target Slot

form.

Reader: issue-line (instance)

# ISSUE-LINE

## Description:
return file position of test-form.

“‘lisp
#?(loop :for name :in *issues*
:always (zerop (issue-line (make-instance name :line 0)))) => T
“‘

### syntax
(ISSUE-LINE sb-kernel:instance)
=> result
### setf
(SETF (ISSUE-LINE SB-KERNEL:INSTANCE) SB-KERNEL::VALUE)
=> new-value

## Arguments and Values:
instance := issue, otherwise error.

“‘lisp
#?(issue-line 0)
:signals error
, :lazy
“‘
result := (or null non-negative-integer)

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Target Slot

line.

Writer: (setf issue-line) (instance)
Package

jingoh.tester.

Source

report.lisp.

Target Slot

line.

Function: issue-of-multiple-values-p (object)

# ERROR-WAS-SIGNALED-P, WARNING-WAS-SIGNALED-P, DEBUGGER-WAS-INVOKED-P, UNMATCH-CONDITION-P, UNEXPECTED-SUCCESS-P, UNEXPECTED-OUTPUT-P, ISSUE-OF-MULTIPLE-VALUES-P, MISSING-RESTARTS-P, UNSATISFIED-CLAUSE-P, WRONG-FORMAT-P

## [Predicates]

## Description:
Tests.

“‘lisp
#?(let* ((pred-name (symbol-name ’pred))
(issue-name (find-symbol (subseq pred-name 0 (- (length pred-name) 2)))))
(pred (make-instance issue-name)))
=> T
“‘

### syntax
(ERROR-WAS-SIGNALED-P sb-kernel::object)
=> result

## Arguments and Values:
object := T

“‘lisp
#?(pred 0)
:invokes-debugger NOT
“‘
result := boolean

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Function: issue-p (object)

# ISSUE-P

## Description:
when arg is issue object, returns t, otherwise nil.

“‘lisp
#?(let ((issues (mapcar #’make-instance *issues*))) (every #’issue-p issues))
=> T
“‘

### syntax
(ISSUE-P sb-kernel::object)
=> result

## Arguments and Values:
object := T

“‘lisp
#?(issue-p 0)
:invokes-debugger NOT
“‘
result := boolean

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Function: list-all-option-keys ()

# LIST-ALL-OPTION-KEYS

## Description:

### syntax
(LIST-ALL-OPTION-KEYS)
=> result

## Arguments and Values:
result := list

## Affected By:
JINGOH.ORG::*OPTION-KEYS*

“‘lisp
#?(let ((jingoh.org::*option-keys* (make-hash-table))) (list-all-option-keys))
=> NIL
“‘

## Side-Effects:

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Function: make-org (&key name package current-subjects options specifications)

# MAKE-ORG

## Description:
Make new org object.

“‘lisp
#?(make-org)
:be-the org
“‘

### syntax
(MAKE-ORG &key (#:name nil) (#:package \*package\*) (#:current-subjects ‘(nil)) (#:options nil) (#:specifications
(make-array 0 :fill-pointer 0 :adjustable t :element-type ’spec)))
=> result

## Arguments and Values:
name := symbol represents organization name. Otherwise MAY error.

“‘lisp
#?(make-org :name 0)
=> unspecified
“‘
package := package which organization in. Otherwise MAY error.

“‘lisp
#?(make-org :package 0)
=> unspecified
“‘
current-subjects := cons which includes current subjects. Otherwise MAY error.

“‘lisp
#?(make-org :current-subjects 0)
=> unspecified
“‘
options := list which includes options for current subjects. Otherwise MAY error.

“‘lisp
#?(make-org :options 0)
=> unspecified
“‘
specifications := vector which includes specifications. Otherwise MAY error.

“‘lisp
#?(make-org :specifications 0)
=> unspecified
“‘
result := ORG

## Affected By:
*package* when :PACKAGE is not specified.

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Function: missing-restarts-p (object)

# ERROR-WAS-SIGNALED-P, WARNING-WAS-SIGNALED-P, DEBUGGER-WAS-INVOKED-P, UNMATCH-CONDITION-P, UNEXPECTED-SUCCESS-P, UNEXPECTED-OUTPUT-P, ISSUE-OF-MULTIPLE-VALUES-P, MISSING-RESTARTS-P, UNSATISFIED-CLAUSE-P, WRONG-FORMAT-P

## [Predicates]

## Description:
Tests.

“‘lisp
#?(let* ((pred-name (symbol-name ’pred))
(issue-name (find-symbol (subseq pred-name 0 (- (length pred-name) 2)))))
(pred (make-instance issue-name)))
=> T
“‘

### syntax
(ERROR-WAS-SIGNALED-P sb-kernel::object)
=> result

## Arguments and Values:
object := T

“‘lisp
#?(pred 0)
:invokes-debugger NOT
“‘
result := boolean

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Reader: org-current-subjects (instance)

# ORG-CURRENT-SUBJECTS

## Description:
return current subjects.

“‘lisp
#?(org-current-subjects org)
=> (NIL)
, :test
“‘

### syntax
(ORG-CURRENT-SUBJECTS #:arg0)
=> result
### setf
(SETF (ORG-CURRENT-SUBJECTS #:ARG1) #:ARG0)
=> new-value

## Arguments and Values:
arg0 := org, otherwise implementation dependent condition.

“‘lisp
#?(org-current-subjects 0)
:signals condition
“‘
result := cons which includes current subjects.

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Target Slot

current-subjects.

Writer: (setf org-current-subjects) (instance)
Package

jingoh.org.

Source

org.lisp.

Target Slot

current-subjects.

Reader: org-name (instance)

# ORG-NAME

## Description:
Return org name.

“‘lisp
#?(org-name o)
=> NIL
“‘

### syntax
(ORG-NAME #:arg0)
=> result

## Arguments and Values:
arg0 := org, Otherwise implementation dependent condition.

“‘lisp
#?(org-name 0)
:signals condition
“‘
result := symbol represents org name.

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Target Slot

name.

Reader: org-options (instance)

# ORG-OPTIONS

## Description:
return current options.

“‘lisp
#?(org-options org)
=> NIL
“‘

### syntax
(ORG-OPTIONS #:arg0)
=> result
### setf
(SETF (ORG-OPTIONS #:ARG1) #:ARG0)
=> new-value

## Arguments and Values:
arg0 := org, otherwise implementation dependent condition.

“‘lisp
#?(org-options 0)
:signals condition
“‘
result := list which includes options

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Target Slot

options.

Writer: (setf org-options) (instance)
Package

jingoh.org.

Source

org.lisp.

Target Slot

options.

Function: org-p (object)

# ORG-P

## Description:
When arg is ORG, return T, otherwise NIL.

“‘lisp
#?(org-p (make-org))
=> T
“‘

“‘lisp
#?(org-p 0)
=> NIL
“‘

### syntax
(ORG-P #:arg0)
=> result

## Arguments and Values:
arg0 := any lisp object.
result := boolean

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Reader: org-package (instance)

# ORG-PACKAGE

## Description:
return package which org in.

“‘lisp
#?(org-package org)
:be-the package
“‘

### syntax
(ORG-PACKAGE #:arg0)
=> result

## Arguments and Values:
arg0 := org, otherwise implementation dependent condition.

“‘lisp
#?(org-package 0)
:signals condition
“‘
result := package

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Target Slot

package.

Function: org-requirements-count (org)

# ORG-REQUIREMENTS-COUNT

## Description:
Return number of requirements.

“‘lisp
#?(let ((org (make-org)))
(princ (org-requirements-count org)) (add-requirement ’subject 0 org)
(princ (org-requirements-count org)))
:outputs "01"
“‘

### syntax
(ORG-REQUIREMENTS-COUNT org)
=> result

## Arguments and Values:
org := org, otherwise implementation dependent condition.

“‘lisp
#?(org-requirements-count 0)
:signals condition
“‘
result := non negative integer.

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Reader: org-specifications (instance)

# ORG-SPECIFICATIONS

## Description:
return vector which includes specifications.

“‘lisp
#?(org-specifications org)
=> #()
, :test
“‘

### syntax
(ORG-SPECIFICATIONS #:arg0)
=> result
### setf
(SETF (ORG-SPECIFICATIONS #:ARG1) #:ARG0)
=> new-value

## Arguments and Values:
arg0 := org, otherwise implementation dependent condition.

“‘lisp
#?(org-specifications 0)
:signals condition
“‘
result := vector which includes specifications.

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Target Slot

specifications.

Writer: (setf org-specifications) (instance)
Package

jingoh.org.

Source

org.lisp.

Target Slot

specifications.

Function: register-org (name org)

# REGISTER-ORG

## Description:
register specified org into underlying org database.

“‘lisp
#?(register-org :hoge (make-org))
:be-the org
“‘

### syntax
(REGISTER-ORG name org)
=> result

## Arguments and Values:
name := symbol, otherwise implementation dependent condition.

“‘lisp
#?(register-org 0 (make-org))
:signals condition
“‘
org := Org, otherwise implementation dependent condition.

“‘lisp
#?(register-org :hoge 0)
:signals condition
“‘
result := org

## Affected By:
underlying org database.

## Side-Effects:
modify underlying org database.

“‘lisp
#?(let (acc)
(push (find-org :hoge nil) acc)
(register-org :hoge (make-org))
(push (find-org :hoge nil) acc)
(nreverse acc))
:satisfies (lambda ($result)
(destructuring-bind (existp org) $result
(& (null existp)
(org-p org))))
“‘

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

deforg.lisp.

Function: replace-macro-character (char sub-char)

# REPLACE-MACRO-CHARACTER

## Description:
Wrapper to CL:SET-DISPATCH-MACRO-CHARACTER.
When you want to customize dispatch macro character, you should use this,
otherwise :LINE number will be confused.

### syntax
(REPLACE-MACRO-CHARACTER char sub-char)
=> result

## Arguments and Values:
char := character, otherwise error.

“‘lisp
#?(replace-macro-character 0 #\?)
:signals TYPE-ERROR
“‘
sub-char := character, otherwise error.

“‘lisp
#?(replace-macro-character #\# "not-character")
:signals type-error
“‘
result := implementation-dependent

## Affected By:
none

## Side-Effects:
Modify ‘*readtable*‘ state.
Modify ‘JINGOH.READER::*DISPATCH-MACRO-CHARACTER*‘, ‘JINGOH.READER::*DISPATCH-MACRO-SUB-CHAR*‘.

## Notes:

## Exceptional-Situations:

Package

jingoh.reader.

Source

reader.lisp.

Function: requirement-form (requirement)
Package

jingoh.tester.

Source

tester.lisp.

Function: reserved-keywords (gf)

# RESERVED-KEYWORDS

## Description:
return dispatch keys.

“‘lisp
#?(reserved-keywords #’make-requirement)
:satisfies (lambda ($result)
(& (listp $result)
(null (set-difference $result
’(=> :be-the :satisfies :values :outputs :multiple-value-satisfies :output-satisfies :expanded-to :equivalents :signals :invokes-debugger))))) “‘

### syntax
(RESERVED-KEYWORDS gf)
=> result

## Arguments and Values:
gf := instance of make-requirement.
result := list which contanis dispatch keys.

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

miscellaneous.lisp.

Function: sexp= (sexp1 sexp2)

# SEXP=

## Description:
tests equalilty as syntax. This is useful to test MACROEXPENDed form.

“‘lisp
#?(sexp= ’(let ((#0=#:var 0)) #0#)
’(let ((var 0)) var))
=> T
“‘

“‘lisp
#?(sexp= ’#:foo ’var)
=> T
“‘

“‘lisp
#?(sexp= ’foo ’#:foo)
=> NIL
“‘

### syntax
(SEXP= sexp1 sexp2)
=> result

## Arguments and Values:
sexp1 := form, which may include GENSYMed symbol.
sexp2 := form.
result := boolean

## Affected By:
none

## Side-Effects:
none

## Notes:
Still alpha quality.

## Exceptional-Situations:

Package

jingoh.tester.

Source

miscellaneous.lisp.

Function: test-issue-p (object)

# TEST-ISSUE-P

## Description:
Tests arg is test-issue.

“‘lisp
#?(let ((issues (mapcar #’make-instance *test-issues*)))
(every #’test-issue-p issues))
=> T
“‘

“‘lisp
#?(let ((issues (mapcar #’make-instance (set-difference *issues* *test-issues*)))) (notany #’test-issue-p issues))
=> T
“‘

### syntax
(TEST-ISSUE-P sb-kernel::object)
=> result

## Arguments and Values:
object := T

“‘lisp
#?(test-issue-p :hoge)
:invokes-debugger NOT
“‘
result := boolean

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Reader: test-issue-test (instance)

# TEST-ISSUE-TEST

## Description:
return test function name.

“‘lisp
#?(loop :for name :in *test-issues*
:always (eq ’equalp (test-issue-test (make-instance name :test ’equalp)))) => T
“‘

### syntax
(TEST-ISSUE-TEST sb-kernel:instance)
=> result
### setf
(SETF (TEST-ISSUE-TEST SB-KERNEL:INSTANCE) SB-KERNEL::VALUE)
=> new-value

## Arguments and Values:
instance := test-issue, otherwise error.

“‘lisp
#?(test-issue-test 0)
:signals error
, :lazy
“‘

“‘lisp
#?(loop :for name :in (set-difference *issues* *test-issues*)
:never (ignore-errors (test-issue-test (make-instance name))))
=> T
“‘
result := function name.

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Target Slot

test.

Writer: (setf test-issue-test) (instance)
Package

jingoh.tester.

Source

report.lisp.

Target Slot

test.

Function: the-push-instance-form (place type test-form expected actual line comment &rest options)

# THE-PUSH-INSTANCE-FORM

## Description:
helper for writing make-requirement.

“‘lisp
#?(the-push-instance-form 0 1 2 3 4 5 6 7)
=> (push (make-instance ’1 :form 2 :expected ’3 :actual 4 :line 5 :comment 6 7) 0)
, :test
“‘

### syntax
(THE-PUSH-INSTANCE-FORM place type test-form expected actual position &rest options) => result

## Arguments and Values:
place := symbol as variable.
type := symbol as issue name.
test-form := form which is tested.
expected := value which is expected return value of test-form.
actual := actual return value of test-form.
position := non negative integer as file position.
options := additional key value pair for issue constructor.
result := form

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

tester.lisp.

Function: the-standard-handling-form (result parameters test-form expected &rest body)

# THE-STANDARD-HANDLING-FORM

## Description:
Helper for writing make-requirement.

“‘lisp
#?(the-standard-handling-form 0 () 1 2 3)
=> (lambda ()
(let (0 (output ""))
(handler-case (setf output (with-output-to-string (*standard-output*) (with-integrated-output-stream (*standard-output*)
3)))
(warning (condition)
(push (make-instance ’warning-was-signaled :form ’1 :expected ’2
:actual condition :line nil :comment nil
:message (princ-to-string condition))
0))
(error (condition)
(push (make-instance ’error-was-signaled :form ’1 :expected ’2
:actual condition :line nil :comment nil
:message (princ-to-string condition))
0)))
(unless (string= "" output)
(push (make-instance ’unexpected-output :form ’1 :expected ’""
:actual output :line nil :comment nil)
0))
0))
, :test
“‘
If :ignore-signals is specified with type of warning, warning clause is not generated.

“‘lisp
#?(the-standard-handling-form 0 ’(:ignore-signals warning) 1 2 3)
=> (lambda ()
(let (0 (output ""))
(handler-case (setf output (with-output-to-string (*standard-output*) (with-integrated-output-stream (*standard-output*)
(handler-bind ((warning
(lambda (condition)
(when (find-restart ’muffle-warning condition)
(muffle-warning condition)))))
3))))
(error (condition)
(push (make-instance ’error-was-signaled :form ’1 :expected ’2
:actual condition :line nil :comment nil
:message (princ-to-string condition))
0)))
(unless (string= "" output)
(push (make-instance ’unexpected-output :form ’1 :expected ’""
:actual output :line nil :comment nil)
0))
0))
, :test
“‘

### syntax
(THE-STANDARD-HANDLING-FORM result parameters test-form expected &rest body)
=> result

## Arguments and Values:
result := symbol as variable.
parameters := plist which contains parameters.
test-form := form which is tested.
expected := expected value of test-form.
body := form which make context which test is done.
result := form

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

tester.lisp.

Function: unexpected-output-p (object)

# ERROR-WAS-SIGNALED-P, WARNING-WAS-SIGNALED-P, DEBUGGER-WAS-INVOKED-P, UNMATCH-CONDITION-P, UNEXPECTED-SUCCESS-P, UNEXPECTED-OUTPUT-P, ISSUE-OF-MULTIPLE-VALUES-P, MISSING-RESTARTS-P, UNSATISFIED-CLAUSE-P, WRONG-FORMAT-P

## [Predicates]

## Description:
Tests.

“‘lisp
#?(let* ((pred-name (symbol-name ’pred))
(issue-name (find-symbol (subseq pred-name 0 (- (length pred-name) 2)))))
(pred (make-instance issue-name)))
=> T
“‘

### syntax
(ERROR-WAS-SIGNALED-P sb-kernel::object)
=> result

## Arguments and Values:
object := T

“‘lisp
#?(pred 0)
:invokes-debugger NOT
“‘
result := boolean

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Function: unexpected-success-p (object)

# ERROR-WAS-SIGNALED-P, WARNING-WAS-SIGNALED-P, DEBUGGER-WAS-INVOKED-P, UNMATCH-CONDITION-P, UNEXPECTED-SUCCESS-P, UNEXPECTED-OUTPUT-P, ISSUE-OF-MULTIPLE-VALUES-P, MISSING-RESTARTS-P, UNSATISFIED-CLAUSE-P, WRONG-FORMAT-P

## [Predicates]

## Description:
Tests.

“‘lisp
#?(let* ((pred-name (symbol-name ’pred))
(issue-name (find-symbol (subseq pred-name 0 (- (length pred-name) 2)))))
(pred (make-instance issue-name)))
=> T
“‘

### syntax
(ERROR-WAS-SIGNALED-P sb-kernel::object)
=> result

## Arguments and Values:
object := T

“‘lisp
#?(pred 0)
:invokes-debugger NOT
“‘
result := boolean

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Function: unmatch-condition-p (object)

# ERROR-WAS-SIGNALED-P, WARNING-WAS-SIGNALED-P, DEBUGGER-WAS-INVOKED-P, UNMATCH-CONDITION-P, UNEXPECTED-SUCCESS-P, UNEXPECTED-OUTPUT-P, ISSUE-OF-MULTIPLE-VALUES-P, MISSING-RESTARTS-P, UNSATISFIED-CLAUSE-P, WRONG-FORMAT-P

## [Predicates]

## Description:
Tests.

“‘lisp
#?(let* ((pred-name (symbol-name ’pred))
(issue-name (find-symbol (subseq pred-name 0 (- (length pred-name) 2)))))
(pred (make-instance issue-name)))
=> T
“‘

### syntax
(ERROR-WAS-SIGNALED-P sb-kernel::object)
=> result

## Arguments and Values:
object := T

“‘lisp
#?(pred 0)
:invokes-debugger NOT
“‘
result := boolean

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Reader: unsatisfied-clause-args (instance)

# UNSATISFIED-CLAUSE-ARGS

## Description:
return args.

“‘lisp
#?(unsatisfied-clause-args (make-instance ’unsatisfied-clause :args :hoge)) => :HOGE
“‘

### syntax
(UNSATISFIED-CLAUSE-ARGS sb-kernel:instance)
=> result
### setf
(SETF (UNSATISFIED-CLAUSE-ARGS SB-KERNEL:INSTANCE) SB-KERNEL::VALUE)
=> new-value

## Arguments and Values:
instance := unsatified-clause, otherwise error.

“‘lisp
#?(loop :for name :in (remove ’unsatisfied-clause *issues*)
:never (ignore-errors (unsatisfied-clause-args (make-instance name)))) => T
“‘

“‘lisp
#?(unsatisfied-clause-args 0)
:signals error
, :lazy
“‘
result := list which contains arg.

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Target Slot

args.

Writer: (setf unsatisfied-clause-args) (instance)
Package

jingoh.tester.

Source

report.lisp.

Target Slot

args.

Function: unsatisfied-clause-p (object)

# ERROR-WAS-SIGNALED-P, WARNING-WAS-SIGNALED-P, DEBUGGER-WAS-INVOKED-P, UNMATCH-CONDITION-P, UNEXPECTED-SUCCESS-P, UNEXPECTED-OUTPUT-P, ISSUE-OF-MULTIPLE-VALUES-P, MISSING-RESTARTS-P, UNSATISFIED-CLAUSE-P, WRONG-FORMAT-P

## [Predicates]

## Description:
Tests.

“‘lisp
#?(let* ((pred-name (symbol-name ’pred))
(issue-name (find-symbol (subseq pred-name 0 (- (length pred-name) 2)))))
(pred (make-instance issue-name)))
=> T
“‘

### syntax
(ERROR-WAS-SIGNALED-P sb-kernel::object)
=> result

## Arguments and Values:
object := T

“‘lisp
#?(pred 0)
:invokes-debugger NOT
“‘
result := boolean

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Function: warning-was-signaled-p (object)

# ERROR-WAS-SIGNALED-P, WARNING-WAS-SIGNALED-P, DEBUGGER-WAS-INVOKED-P, UNMATCH-CONDITION-P, UNEXPECTED-SUCCESS-P, UNEXPECTED-OUTPUT-P, ISSUE-OF-MULTIPLE-VALUES-P, MISSING-RESTARTS-P, UNSATISFIED-CLAUSE-P, WRONG-FORMAT-P

## [Predicates]

## Description:
Tests.

“‘lisp
#?(let* ((pred-name (symbol-name ’pred))
(issue-name (find-symbol (subseq pred-name 0 (- (length pred-name) 2)))))
(pred (make-instance issue-name)))
=> T
“‘

### syntax
(ERROR-WAS-SIGNALED-P sb-kernel::object)
=> result

## Arguments and Values:
object := T

“‘lisp
#?(pred 0)
:invokes-debugger NOT
“‘
result := boolean

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Function: wrong-format-p (object)

# ERROR-WAS-SIGNALED-P, WARNING-WAS-SIGNALED-P, DEBUGGER-WAS-INVOKED-P, UNMATCH-CONDITION-P, UNEXPECTED-SUCCESS-P, UNEXPECTED-OUTPUT-P, ISSUE-OF-MULTIPLE-VALUES-P, MISSING-RESTARTS-P, UNSATISFIED-CLAUSE-P, WRONG-FORMAT-P

## [Predicates]

## Description:
Tests.

“‘lisp
#?(let* ((pred-name (symbol-name ’pred))
(issue-name (find-symbol (subseq pred-name 0 (- (length pred-name) 2)))))
(pred (make-instance issue-name)))
=> T
“‘

### syntax
(ERROR-WAS-SIGNALED-P sb-kernel::object)
=> result

## Arguments and Values:
object := T

“‘lisp
#?(pred 0)
:invokes-debugger NOT
“‘
result := boolean

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.


5.1.4 Generic functions

Generic Reader: api (condition)

# API
# [Generic-Function] API

## Description:
return api which is signaled condition.

### syntax
(API clos::object)
=> result

## Argument Precedence Order: clos::object

## Method signature:
(API (CLOS::OBJECT MISSING))

## Arguments and Values:
object := missing
result := symbol

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Methods
Reader Method: api ((condition missing))
Source

conditions.lisp.

Target Slot

api.

Generic Reader: args (condition)
Package

jingoh.tester.

Methods
Reader Method: args ((condition unsatisfied))
Source

tester.lisp.

Target Slot

args.

Generic Reader: datum (condition)

# DATUM
# [Generic-Function] DATUM

## Description:
inherited from CL:TYPE-ERROR, see hyperspec.

### syntax
(DATUM clos::object)
=> result

## Argument Precedence Order: clos::object

## Method signature:

## Arguments and Values:
object := MISSING
result := T

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Methods
Reader Method: datum ((condition missing))
Source

conditions.lisp.

Target Slot

datum.

Generic Function: make-requirement (form key expected &rest params)

# MAKE-REQUIREMENT

## Description:
make requirement.

### syntax
(MAKE-REQUIREMENT &rest sb-pcl::args)
=> result

## Argument Precedence Order:
form key expected

## Method signature:
* (MAKE-REQUIREMENT (TEST-FORM T) (KEY (EQL :OUTPUT-SATISFIES)) (EXPECTED T) &REST PARAMETERS)
* (MAKE-REQUIREMENT (TEST-FORM T) (KEY (EQL :EXPANDED-TO)) (EXPECTED T) &REST PARAMETERS)
* (MAKE-REQUIREMENT (TEST-FORM T) (KEY (EQL :EQUIVALENTS)) (EXPECTED T) &REST PARAMETERS)
* (MAKE-REQUIREMENT (TEST-FORM T) (KEY (EQL :BE-THE)) (EXPECTED T) &REST PARAMETERS)
* (MAKE-REQUIREMENT (TEST-FORM T) (KEY (EQL :MULTIPLE-VALUE-SATISFIES)) (EXPECTED T) &REST PARAMETERS)
* (MAKE-REQUIREMENT (TEST-FORM T) (KEY (EQL =>)) (EXPECTED (EQL IMPLEMENTATION-DEPENDENT)) &REST PARAMETERS) * (MAKE-REQUIREMENT (TEST-FORM T) (KEY (EQL =>)) (EXPECTED (EQL UNSPECIFIED)) &REST PARAMETERS)
* (MAKE-REQUIREMENT (TEST-FORM T) (KEY (EQL :SATISFIES)) (EXPECTED T) &REST PARAMETERS)
* (MAKE-REQUIREMENT (TEST-FORM T) (KEY (EQL :OUTPUTS)) (EXPECTED T) &REST PARAMETERS)
* (MAKE-REQUIREMENT (TEST-FORM T) (KEY (EQL :VALUES)) (EXPECTED T) &REST PARAMETERS)
* (MAKE-REQUIREMENT (TEST-FORM T) (KEY (EQL :INVOKES-DEBUGGER)) (EXPECTED T) &REST PARAMETERS)
* (MAKE-REQUIREMENT (TEST-FORM T) (KEY (EQL :INVOKES-DEBUGGER)) (EXPECTED (EQL NOT)) &REST PARAMETERS)
* (MAKE-REQUIREMENT (TEST-FORM T) (KEY (EQL :INVOKES-DEBUGGER)) (EXPECTED NULL) &REST PARAMETERS)
* (MAKE-REQUIREMENT (TEST-FORM T) (KEY (EQL :SIGNALS)) (EXPECTED T) &REST PARAMETERS)

## Arguments and Values:
args :=
result := lambda-form, but not specified.

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

tester.lisp.

Methods
Method: make-requirement (test-form (key (eql :output-satisfies)) expected &rest parameters)
Method: make-requirement (test-form (key (eql :expanded-to)) expected &rest parameters)
Method: make-requirement (test-form (key (eql :equivalents)) expected &rest parameters)
Method: make-requirement (test-form (key (eql :be-the)) expected &rest parameters)
Method: make-requirement (test-form (key (eql :multiple-value-satisfies)) expected &rest parameters)
Method: make-requirement (test-form (key (eql jingoh.tester:=>)) (expected (eql jingoh.tester:implementation-dependent)) &rest parameters)
Method: make-requirement (test-form (key (eql jingoh.tester:=>)) (expected (eql jingoh.tester:unspecified)) &rest parameters)
Method: make-requirement (test-form (key (eql :satisfies)) expected &rest parameters)
Method: make-requirement (test-form (key (eql :outputs)) expected &rest parameters)
Method: make-requirement (test-form (key (eql :values)) expected &rest parameters)
Method: make-requirement (test-form (key (eql :invokes-debugger)) expected &rest parameters)
Method: make-requirement (test-form (key (eql :invokes-debugger)) (expected (eql not)) &rest parameters)
Method: make-requirement (test-form (key (eql :invokes-debugger)) (expected null) &rest parameters)
Method: make-requirement (test-form (key (eql :signals)) expected &rest parameters)
Method: make-requirement (test-form (key (eql jingoh.tester:=>)) expected &rest parameters)

5.1.5 Standalone methods

Method: print-object ((issue unsatisfied-clause) stream)
Source

report.lisp.

Method: print-object ((issue issue) stream)
Source

report.lisp.

Method: print-object ((c break-on-finish) stream)
Source

examine.lisp.

Method: print-object ((o org) output)
Source

org.lisp.

Method: print-object ((s spec) output)
Source

org.lisp.


5.1.6 Conditions

Condition: macro-char-confliction

# MACRO-CHAR-CONFLICTION

## Description:
Signaled when dispatch macro character is conflicted.

### Class Precedence List: (case in SBCL)

macro-char-confliction simple-error simple-condition error serious-condition condition slot-object t

### Effective Slots:

FORMAT-CONTROL [Type] T
[READER] simple-condition-format-control
FORMAT-ARGUMENTS [Type] T
[READER] simple-condition-format-arguments

## Notes:

Package

jingoh.reader.

Source

reader.lisp.

Direct superclasses

simple-error.

Condition: missing

# MISSING
Super condition.

## Class Precedence List: (case in CLISP)
missing error serious-condition condition standard-object t

## Effective Slots:
API [Type] SYMBOL
[READER] api
Which API missing.
DATUM [Type] T
[READER] datum

## Notes:

Package

jingoh.org.

Source

conditions.lisp.

Direct superclasses

error.

Direct subclasses
Direct methods
Direct slots
Slot: api
Initform

(quote nil)

Initargs

:api

Readers

api.

Writers

This slot is read-only.

Slot: datum
Initform

(quote nil)

Initargs

:datum

Readers

datum.

Writers

This slot is read-only.

Condition: missing-org

# MISSING-ORG
# [Condition] MISSING-ORG

## Class Precedence List: (case in CLISP)
missing-org missing error serious-condition condition standard-object t

## Effective Slots:
API [Type] SYMBOL
[READER] api
DATUM [Type] T
[READER] datum

## Notes:

Package

jingoh.org.

Source

conditions.lisp.

Direct superclasses

missing.

Condition: missing-subject

# MISSING-SUBJECT
# [Condition] MISSING-SUBJECT

## Class Precedence List: (case in CLISP)
missing-subject missing error serious-condition condition standard-object t

## Effective Slots:
API [Type] SYMBOL
[READER] api
DATUM [Type] T
[READER] datum

## Notes:

Package

jingoh.org.

Source

conditions.lisp.

Direct superclasses

missing.

Condition: syntax-error

# SYNTAX-ERROR

## Description:
signaled when macro expansion time.

### Class Precedence List: (case in SBCL)

syntax-error simple-error simple-condition program-error error serious-condition condition slot-object t

### Effective Slots:

FORMAT-CONTROL [Type] T
[READER] simple-condition-format-control
FORMAT-ARGUMENTS [Type] T
[READER] simple-condition-format-arguments

## Notes:

Package

jingoh.tester.

Source

miscellaneous.lisp.

Direct superclasses
  • program-error.
  • simple-error.

Next: , Previous: , Up: Public Interface   [Contents][Index]

5.1.7 Structures

Structure: condition-issue

# CONDITION-ISSUE, ERROR-WAS-SIGNALED, WARNING-WAS-SIGNALED, DEBUGGER-WAS-INVOKED, UNMATCH-CONDITION

## Effective Slots:
MESSAGE [Type] T

“‘lisp
#?(condition-issue-message (make-instance ’object :message "message"))
=> "message"
, :test
“‘

## Notes:

Package

jingoh.tester.

Source

report.lisp.

Direct superclasses

issue.

Direct subclasses
Direct slots
Slot: message
Readers

condition-issue-message.

Writers

(setf condition-issue-message).

Structure: debugger-was-invoked

# CONDITION-ISSUE, ERROR-WAS-SIGNALED, WARNING-WAS-SIGNALED, DEBUGGER-WAS-INVOKED, UNMATCH-CONDITION

## Effective Slots:
MESSAGE [Type] T

“‘lisp
#?(condition-issue-message (make-instance ’object :message "message"))
=> "message"
, :test
“‘

## Notes:

Package

jingoh.tester.

Source

report.lisp.

Direct superclasses

condition-issue.

Structure: error-was-signaled

# CONDITION-ISSUE, ERROR-WAS-SIGNALED, WARNING-WAS-SIGNALED, DEBUGGER-WAS-INVOKED, UNMATCH-CONDITION

## Effective Slots:
MESSAGE [Type] T

“‘lisp
#?(condition-issue-message (make-instance ’object :message "message"))
=> "message"
, :test
“‘

## Notes:

Package

jingoh.tester.

Source

report.lisp.

Direct superclasses

condition-issue.

Structure: issue

# ISSUE, TEST-ISSUE, WRONG-FORMAT, CONDITION-ISSUE, ERROR-WAS-SIGNALED, WARNING-WAS-SIGNALED, DEBUGGER-WAS-INVOKED, UNMATCH-CONDITION, UNEXPECTED-SUCCESS, UNEXPECTED-OUTPUT, ISSUE-OF-MULTIPLE-VALUES, MISSING-RESTARTS, UNSATISFIED-CLAUSE

## [Structure] ISSUE

### inheritence DAG

“‘
issue
|—test-issue
| |—wrong-format
|—condition-issue
| |—error-was-signaled
| |—warning-was-signaled
| |—debugger-was-invoked
| |—unmatch-condition
|—unexpected-success
|—unexpected-output
|—issue-of-multiple-values
|—missing-restarts
|—unsatisfied-clause
“‘

## Class Precedence List: (case in SBCL)
issue structure-object slot-object t

## Effective Slots:
FORM [Type] T

“‘lisp
#?(issue-form (make-instance ’object :form :get!))
=> :get!
“‘
EXPECTED [Type] T

“‘lisp
#?(issue-expected (make-instance ’object :expected :get!))
=> :get!
“‘
ACTUAL [Type] T

“‘lisp
#?(issue-actual (make-instance ’object :actual :get!))
=> :get!
“‘
LINE [Type] T

“‘lisp
#?(issue-line (make-instance ’object :line 0))
=> 0
“‘

## Notes:
Can construct with MAKE-INSTANCE.
Slot names are not exported.
# UNSATISFIED-CLAUSE

## Effective Slots:
ARGS [Type] T

“‘lisp
#?(unsatisfied-clause-args (make-instance ’unsatisfied-clause :args ’(:args :hoge)))
=> (:ARGS :HOGE)
, :test
“‘

## Notes:

Package

jingoh.tester.

Source

report.lisp.

Direct superclasses

structure-object.

Direct subclasses
Direct methods

print-object.

Direct slots
Slot: form
Readers

issue-form.

Writers

(setf issue-form).

Slot: expected
Readers

issue-expected.

Writers

(setf issue-expected).

Slot: actual
Readers

issue-actual.

Writers

(setf issue-actual).

Slot: line
Readers

issue-line.

Writers

(setf issue-line).

Slot: comment
Readers

issue-comment.

Writers

(setf issue-comment).

Structure: issue-of-multiple-values

# ISSUE, TEST-ISSUE, WRONG-FORMAT, CONDITION-ISSUE, ERROR-WAS-SIGNALED, WARNING-WAS-SIGNALED, DEBUGGER-WAS-INVOKED, UNMATCH-CONDITION, UNEXPECTED-SUCCESS, UNEXPECTED-OUTPUT, ISSUE-OF-MULTIPLE-VALUES, MISSING-RESTARTS, UNSATISFIED-CLAUSE

## [Structure] ISSUE

### inheritence DAG

“‘
issue
|—test-issue
| |—wrong-format
|—condition-issue
| |—error-was-signaled
| |—warning-was-signaled
| |—debugger-was-invoked
| |—unmatch-condition
|—unexpected-success
|—unexpected-output
|—issue-of-multiple-values
|—missing-restarts
|—unsatisfied-clause
“‘

## Class Precedence List: (case in SBCL)
issue structure-object slot-object t

## Effective Slots:
FORM [Type] T

“‘lisp
#?(issue-form (make-instance ’object :form :get!))
=> :get!
“‘
EXPECTED [Type] T

“‘lisp
#?(issue-expected (make-instance ’object :expected :get!))
=> :get!
“‘
ACTUAL [Type] T

“‘lisp
#?(issue-actual (make-instance ’object :actual :get!))
=> :get!
“‘
LINE [Type] T

“‘lisp
#?(issue-line (make-instance ’object :line 0))
=> 0
“‘

## Notes:
Can construct with MAKE-INSTANCE.
Slot names are not exported.
# UNSATISFIED-CLAUSE

## Effective Slots:
ARGS [Type] T

“‘lisp
#?(unsatisfied-clause-args (make-instance ’unsatisfied-clause :args ’(:args :hoge)))
=> (:ARGS :HOGE)
, :test
“‘

## Notes:

Package

jingoh.tester.

Source

report.lisp.

Direct superclasses

test-issue.

Structure: jingoh-internal-issue
Package

jingoh.tester.

Source

report.lisp.

Direct superclasses

condition-issue.

Structure: missing-restarts

# ISSUE, TEST-ISSUE, WRONG-FORMAT, CONDITION-ISSUE, ERROR-WAS-SIGNALED, WARNING-WAS-SIGNALED, DEBUGGER-WAS-INVOKED, UNMATCH-CONDITION, UNEXPECTED-SUCCESS, UNEXPECTED-OUTPUT, ISSUE-OF-MULTIPLE-VALUES, MISSING-RESTARTS, UNSATISFIED-CLAUSE

## [Structure] ISSUE

### inheritence DAG

“‘
issue
|—test-issue
| |—wrong-format
|—condition-issue
| |—error-was-signaled
| |—warning-was-signaled
| |—debugger-was-invoked
| |—unmatch-condition
|—unexpected-success
|—unexpected-output
|—issue-of-multiple-values
|—missing-restarts
|—unsatisfied-clause
“‘

## Class Precedence List: (case in SBCL)
issue structure-object slot-object t

## Effective Slots:
FORM [Type] T

“‘lisp
#?(issue-form (make-instance ’object :form :get!))
=> :get!
“‘
EXPECTED [Type] T

“‘lisp
#?(issue-expected (make-instance ’object :expected :get!))
=> :get!
“‘
ACTUAL [Type] T

“‘lisp
#?(issue-actual (make-instance ’object :actual :get!))
=> :get!
“‘
LINE [Type] T

“‘lisp
#?(issue-line (make-instance ’object :line 0))
=> 0
“‘

## Notes:
Can construct with MAKE-INSTANCE.
Slot names are not exported.
# UNSATISFIED-CLAUSE

## Effective Slots:
ARGS [Type] T

“‘lisp
#?(unsatisfied-clause-args (make-instance ’unsatisfied-clause :args ’(:args :hoge)))
=> (:ARGS :HOGE)
, :test
“‘

## Notes:

Package

jingoh.tester.

Source

report.lisp.

Direct superclasses

issue.

Structure: org

# ORG
Represents ORGanization which specify system’s requirements.

## Class Precedence List: (case in CLISP)
org structure-object t

## Effective Slots:
NAME [Type] SYMBOL
[READER] org-name
PACKAGE [Type] PACKAGE
[READER] org-package
CURRENT-SUBJECTS [Type] CONS
[ACCESSOR] org-current-subjects
OPTIONS [Type] LIST
[ACCESSOR] org-options
SPECIFICATIONS [Type] VECTOR
[ACCESSOR] org-specifications

## Notes:

Package

jingoh.org.

Source

org.lisp.

Direct superclasses

structure-object.

Direct methods

print-object.

Direct slots
Slot: name
Type

symbol

Readers

org-name.

Writers

This slot is read-only.

Slot: package
Package

common-lisp.

Type

package

Initform

*package*

Readers

org-package.

Writers

This slot is read-only.

Slot: current-subjects
Type

cons

Initform

(sb-int:quasiquote (nil))

Readers

org-current-subjects.

Writers

(setf org-current-subjects).

Slot: options
Type

list

Readers

org-options.

Writers

(setf org-options).

Slot: specifications
Type

(vector jingoh.org::spec *)

Initform

(make-array 0 :fill-pointer 0 :adjustable t :element-type (quote jingoh.org::spec))

Readers

org-specifications.

Writers

(setf org-specifications).

Structure: test-issue

# TEST-ISSUE, WRONG-FORMAT

## Effective Slots:
TEST [Type] T

“‘lisp
#?(test-issue-test (make-instance ’object :test #’eql)) :satisfies (lambda ($result)
(& (functionp $result)
(eq ’eql (millet:function-name $result))))
“‘

## Notes:

Package

jingoh.tester.

Source

report.lisp.

Direct superclasses

issue.

Direct subclasses
Direct slots
Slot: test
Readers

test-issue-test.

Writers

(setf test-issue-test).

Structure: unexpected-output

# ISSUE, TEST-ISSUE, WRONG-FORMAT, CONDITION-ISSUE, ERROR-WAS-SIGNALED, WARNING-WAS-SIGNALED, DEBUGGER-WAS-INVOKED, UNMATCH-CONDITION, UNEXPECTED-SUCCESS, UNEXPECTED-OUTPUT, ISSUE-OF-MULTIPLE-VALUES, MISSING-RESTARTS, UNSATISFIED-CLAUSE

## [Structure] ISSUE

### inheritence DAG

“‘
issue
|—test-issue
| |—wrong-format
|—condition-issue
| |—error-was-signaled
| |—warning-was-signaled
| |—debugger-was-invoked
| |—unmatch-condition
|—unexpected-success
|—unexpected-output
|—issue-of-multiple-values
|—missing-restarts
|—unsatisfied-clause
“‘

## Class Precedence List: (case in SBCL)
issue structure-object slot-object t

## Effective Slots:
FORM [Type] T

“‘lisp
#?(issue-form (make-instance ’object :form :get!))
=> :get!
“‘
EXPECTED [Type] T

“‘lisp
#?(issue-expected (make-instance ’object :expected :get!))
=> :get!
“‘
ACTUAL [Type] T

“‘lisp
#?(issue-actual (make-instance ’object :actual :get!))
=> :get!
“‘
LINE [Type] T

“‘lisp
#?(issue-line (make-instance ’object :line 0))
=> 0
“‘

## Notes:
Can construct with MAKE-INSTANCE.
Slot names are not exported.
# UNSATISFIED-CLAUSE

## Effective Slots:
ARGS [Type] T

“‘lisp
#?(unsatisfied-clause-args (make-instance ’unsatisfied-clause :args ’(:args :hoge)))
=> (:ARGS :HOGE)
, :test
“‘

## Notes:

Package

jingoh.tester.

Source

report.lisp.

Direct superclasses

issue.

Structure: unexpected-success

# ISSUE, TEST-ISSUE, WRONG-FORMAT, CONDITION-ISSUE, ERROR-WAS-SIGNALED, WARNING-WAS-SIGNALED, DEBUGGER-WAS-INVOKED, UNMATCH-CONDITION, UNEXPECTED-SUCCESS, UNEXPECTED-OUTPUT, ISSUE-OF-MULTIPLE-VALUES, MISSING-RESTARTS, UNSATISFIED-CLAUSE

## [Structure] ISSUE

### inheritence DAG

“‘
issue
|—test-issue
| |—wrong-format
|—condition-issue
| |—error-was-signaled
| |—warning-was-signaled
| |—debugger-was-invoked
| |—unmatch-condition
|—unexpected-success
|—unexpected-output
|—issue-of-multiple-values
|—missing-restarts
|—unsatisfied-clause
“‘

## Class Precedence List: (case in SBCL)
issue structure-object slot-object t

## Effective Slots:
FORM [Type] T

“‘lisp
#?(issue-form (make-instance ’object :form :get!))
=> :get!
“‘
EXPECTED [Type] T

“‘lisp
#?(issue-expected (make-instance ’object :expected :get!))
=> :get!
“‘
ACTUAL [Type] T

“‘lisp
#?(issue-actual (make-instance ’object :actual :get!))
=> :get!
“‘
LINE [Type] T

“‘lisp
#?(issue-line (make-instance ’object :line 0))
=> 0
“‘

## Notes:
Can construct with MAKE-INSTANCE.
Slot names are not exported.
# UNSATISFIED-CLAUSE

## Effective Slots:
ARGS [Type] T

“‘lisp
#?(unsatisfied-clause-args (make-instance ’unsatisfied-clause :args ’(:args :hoge)))
=> (:ARGS :HOGE)
, :test
“‘

## Notes:

Package

jingoh.tester.

Source

report.lisp.

Direct superclasses

issue.

Structure: unmatch-condition

# CONDITION-ISSUE, ERROR-WAS-SIGNALED, WARNING-WAS-SIGNALED, DEBUGGER-WAS-INVOKED, UNMATCH-CONDITION

## Effective Slots:
MESSAGE [Type] T

“‘lisp
#?(condition-issue-message (make-instance ’object :message "message"))
=> "message"
, :test
“‘

## Notes:

Package

jingoh.tester.

Source

report.lisp.

Direct superclasses

condition-issue.

Structure: unsatisfied-clause

# ISSUE, TEST-ISSUE, WRONG-FORMAT, CONDITION-ISSUE, ERROR-WAS-SIGNALED, WARNING-WAS-SIGNALED, DEBUGGER-WAS-INVOKED, UNMATCH-CONDITION, UNEXPECTED-SUCCESS, UNEXPECTED-OUTPUT, ISSUE-OF-MULTIPLE-VALUES, MISSING-RESTARTS, UNSATISFIED-CLAUSE

## [Structure] ISSUE

### inheritence DAG

“‘
issue
|—test-issue
| |—wrong-format
|—condition-issue
| |—error-was-signaled
| |—warning-was-signaled
| |—debugger-was-invoked
| |—unmatch-condition
|—unexpected-success
|—unexpected-output
|—issue-of-multiple-values
|—missing-restarts
|—unsatisfied-clause
“‘

## Class Precedence List: (case in SBCL)
issue structure-object slot-object t

## Effective Slots:
FORM [Type] T

“‘lisp
#?(issue-form (make-instance ’object :form :get!))
=> :get!
“‘
EXPECTED [Type] T

“‘lisp
#?(issue-expected (make-instance ’object :expected :get!))
=> :get!
“‘
ACTUAL [Type] T

“‘lisp
#?(issue-actual (make-instance ’object :actual :get!))
=> :get!
“‘
LINE [Type] T

“‘lisp
#?(issue-line (make-instance ’object :line 0))
=> 0
“‘

## Notes:
Can construct with MAKE-INSTANCE.
Slot names are not exported.
# UNSATISFIED-CLAUSE

## Effective Slots:
ARGS [Type] T

“‘lisp
#?(unsatisfied-clause-args (make-instance ’unsatisfied-clause :args ’(:args :hoge)))
=> (:ARGS :HOGE)
, :test
“‘

## Notes:

Package

jingoh.tester.

Source

report.lisp.

Direct superclasses

issue.

Direct methods

print-object.

Direct slots
Slot: args
Readers

unsatisfied-clause-args.

Writers

(setf unsatisfied-clause-args).

Structure: warning-was-signaled

# CONDITION-ISSUE, ERROR-WAS-SIGNALED, WARNING-WAS-SIGNALED, DEBUGGER-WAS-INVOKED, UNMATCH-CONDITION

## Effective Slots:
MESSAGE [Type] T

“‘lisp
#?(condition-issue-message (make-instance ’object :message "message"))
=> "message"
, :test
“‘

## Notes:

Package

jingoh.tester.

Source

report.lisp.

Direct superclasses

condition-issue.

Structure: wrong-format

# TEST-ISSUE, WRONG-FORMAT

## Effective Slots:
TEST [Type] T

“‘lisp
#?(test-issue-test (make-instance ’object :test #’eql)) :satisfies (lambda ($result)
(& (functionp $result)
(eq ’eql (millet:function-name $result))))
“‘

## Notes:

Package

jingoh.tester.

Source

report.lisp.

Direct superclasses

test-issue.


Previous: , Up: Public Interface   [Contents][Index]

5.1.8 Types

Type: org-designator ()

# ORG-DESIGNATOR

## Description:
Represents org.
(or (and symbol (not boolean)) org)

“‘lisp
#?(typep T ’org-designator)
=> NIL
“‘

“‘lisp
#?(typep NIL ’org-designator)
=> NIL
“‘

“‘lisp
#?(typep :hoge ’org-designator)
=> T
“‘

“‘lisp
#?(typep (make-org) ’org-designator) => T
“‘

## Compound Type Specifier Kind: none

## Compound Type Specifier Syntax: none

## Compound Type Specifier Arguments: none

## Compound Type Specifier Description: none

Package

jingoh.org.

Source

org.lisp.

Type: subject-designator ()

# SUBJECT-DESIGNATOR

## Description:
Represents subject.
Symbol or boolean.
When T, it represents current subject. When NIL, it represents all subject.

## Compound Type Specifier Kind: none

## Compound Type Specifier Syntax: none

## Compound Type Specifier Arguments: none

## Compound Type Specifier Description: none
# special variables

Package

jingoh.org.

Source

org.lisp.


5.2 Internals


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

5.2.1 Special variables

Special Variable: *counter*
Package

jingoh.reader.

Source

reader.lisp.

Special Variable: *dispatch-macro-character*
Package

jingoh.reader.

Source

reader.lisp.

Special Variable: *dispatch-macro-sub-char*
Package

jingoh.reader.

Source

reader.lisp.

Special Variable: *line*
Package

jingoh.reader.

Source

reader.lisp.

Special Variable: *line-pos*
Package

jingoh.reader.

Source

reader.lisp.

Special Variable: *lines*
Package

jingoh.reader.

Source

reader.lisp.

Special Variable: *option-keys*
Package

jingoh.org.

Source

org.lisp.

Special Variable: *orgs*
Package

jingoh.org.

Source

deforg.lisp.

Special Variable: *reader-package*
Package

jingoh.reader.

Source

reader.lisp.

Special Variable: *requirement-form*

Previous test form. Debug use.

Package

jingoh.examiner.

Source

examine.lisp.


5.2.2 Ordinary functions

Function: #+counter (stream character number)
Package

jingoh.reader.

Source

reader.lisp.

Function: #?counter (stream character number)
Package

jingoh.reader.

Source

reader.lisp.

Function: #?reader-body (stream number)
Package

jingoh.reader.

Source

reader.lisp.

Function: %collect-spec-lines (input)

# %COLLECT-SPEC-LINES

## Description:

### syntax (%COLLECT-SPEC-LINES INPUT)
=> result

## Arguments and Values:
input := input stream, otherwise error.

“‘lisp
#?(%collect-spec-lines "not stream")
:signals error
“‘
result := list thats element is line numbers where #? form appears.

“‘lisp
#?(with-input-from-string (in (format nil "#?(+) => 0~%#?(*) => 1")) (%collect-spec-lines in))
=> (1 2)
, :test
“‘

## Affected By:
*counter*, internal use. eclector.readtable:readtable. *dispatch-macro-character*.
*dispatch-macro-sub-char*.

## Side-Effects:
Consume stream contents.

## Notes:

## Exceptional-Situations:
If form in invalid, an error is signaled.

“‘lisp
#?(with-input-from-string (in ")")
(%collect-spec-lines in))
:signals error
“‘

## Tests.
Handling the end-of-file.

“‘lisp
#?(with-input-from-string (in "")
(%collect-spec-lines in))
=> NIL
“‘
Handling read time conditional.

“‘lisp
#?(with-input-from-string (in (format nil "#+()~%hoge~%#?(+) => 0")) (%collect-spec-lines in))
=> (3)
, :test
“‘

Package

jingoh.reader.

Source

reader.lisp.

Function: <iterate-all-requirements> (<org> var body <return>)
Package

jingoh.org.

Source

miscellaneous.lisp.

Function: <iterate-specified-subjects-requirements> (var body gname <org> <return>)
Package

jingoh.org.

Source

miscellaneous.lisp.

Function: block-comment (stream character number)

# |block-comment|

## Description:
Dispatch macro function for block comment, a.k.a ‘#|‘.
Consume block comment from STREAM with counting newlines.

### syntax
(|block-comment| stream character number)
=> result

## Arguments and Values:
stream := input stream, otherwise error.

“‘lisp
#?(|block-comment| "not-stream" #\| nil)
:signals error
“‘
character := #\|, ignored.
number := NIL, ignored.

“‘lisp
#?(with-input-from-string (s "outer comment.
#234| <— this number will be ignored. |#
outer end |# :next")
(|block-comment| s ’#:ignored ’#:ignored)
(read s))
=> :NEXT
“‘
result := (values)

## Affected By:

## Side-Effects:
Increse ‘JINGOH.READER::*LINE*‘.

“‘lisp
#?(with-input-from-string (s (format nil "comment~%|#"))
(|block-comment| s ’#:ignored ’#:ignored)
*line*)
=> 2
“‘

## Notes:
Works same with common lisp, i.e. tag must nested.

“‘lisp
#?(with-input-from-string (s "outer comment #| nested |# outer end|#:next") (|block-comment| s ’#:ignored ’#:ignored)
(read s))
=> :NEXT
“‘

“‘lisp
#?(with-input-from-string (s "outer comment #| nested |# but without outer end tag.~%:next") (|block-comment| s ’#:ignored ’#:ignored))
:signals END-OF-FILE
“‘

## Exceptional-Situations:
When missing end tag ‘|#‘, signals END-OF-FILE.

“‘lisp
#?(with-input-from-string (s "Missing end tag")
(|block-comment| s ’#:ignored ’#:ignored))
:signals END-OF-FILE
“‘

Package

jingoh.reader.

Source

reader.lisp.

Function: break-on-fails (result)
Package

jingoh.examiner.

Source

examine.lisp.

Function: break-on-finish (&optional issues)
Package

jingoh.examiner.

Source

examine.lisp.

Function: collect-spec-lines (input)
Package

jingoh.reader.

Source

reader.lisp.

Function: condition-issue-actual (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf condition-issue-actual) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: condition-issue-comment (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf condition-issue-comment) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: condition-issue-expected (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf condition-issue-expected) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: condition-issue-form (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf condition-issue-form) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: condition-issue-line (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf condition-issue-line) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: copy-condition-issue (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: copy-cons (cons)
Package

jingoh.tester.

Source

miscellaneous.lisp.

Function: copy-debugger-was-invoked (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: copy-error-was-signaled (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: copy-issue (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: copy-issue-of-multiple-values (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: copy-jingoh-internal-issue (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: copy-missing-restarts (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: copy-test-issue (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: copy-unexpected-output (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: copy-unexpected-success (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: copy-unmatch-condition (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: copy-unsatisfied-clause (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: copy-warning-was-signaled (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: copy-wrong-format (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: debugger-was-invoked-actual (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf debugger-was-invoked-actual) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: debugger-was-invoked-comment (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf debugger-was-invoked-comment) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: debugger-was-invoked-expected (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf debugger-was-invoked-expected) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: debugger-was-invoked-form (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf debugger-was-invoked-form) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: debugger-was-invoked-line (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf debugger-was-invoked-line) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: debugger-was-invoked-message (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf debugger-was-invoked-message) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: error-was-signaled-actual (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf error-was-signaled-actual) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: error-was-signaled-comment (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf error-was-signaled-comment) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: error-was-signaled-expected (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf error-was-signaled-expected) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: error-was-signaled-form (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf error-was-signaled-form) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: error-was-signaled-line (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf error-was-signaled-line) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: error-was-signaled-message (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf error-was-signaled-message) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: find-subject (subject &optional org)
Package

jingoh.org.

Source

miscellaneous.lisp.

Function: function-designator-p (symbol)
Package

jingoh.tester.

Source

miscellaneous.lisp.

Function: ignore-signals (type params)
Package

jingoh.tester.

Source

miscellaneous.lisp.

Reader: issue-comment (instance)
Writer: (setf issue-comment) (instance)
Package

jingoh.tester.

Source

report.lisp.

Target Slot

comment.

Function: issue-of-multiple-values-actual (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf issue-of-multiple-values-actual) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: issue-of-multiple-values-comment (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf issue-of-multiple-values-comment) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: issue-of-multiple-values-expected (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf issue-of-multiple-values-expected) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: issue-of-multiple-values-form (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf issue-of-multiple-values-form) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: issue-of-multiple-values-line (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf issue-of-multiple-values-line) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: issue-of-multiple-values-test (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf issue-of-multiple-values-test) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: jingoh-internal-issue-actual (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf jingoh-internal-issue-actual) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: jingoh-internal-issue-comment (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf jingoh-internal-issue-comment) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: jingoh-internal-issue-expected (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf jingoh-internal-issue-expected) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: jingoh-internal-issue-form (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf jingoh-internal-issue-form) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: jingoh-internal-issue-line (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf jingoh-internal-issue-line) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: jingoh-internal-issue-message (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf jingoh-internal-issue-message) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: jingoh-internal-issue-p (object)
Package

jingoh.tester.

Source

report.lisp.

Function: line-comment (stream character)
Package

jingoh.reader.

Source

reader.lisp.

Function: line-counter (stream character)
Package

jingoh.reader.

Source

reader.lisp.

Function: make-condition-issue (&key form expected actual line comment message)
Package

jingoh.tester.

Source

report.lisp.

Function: make-debugger-was-invoked (&key form expected actual line comment message)
Package

jingoh.tester.

Source

report.lisp.

Function: make-error-was-signaled (&key form expected actual line comment message)
Package

jingoh.tester.

Source

report.lisp.

Function: make-issue (&key form expected actual line comment)
Package

jingoh.tester.

Source

report.lisp.

Function: make-issue-of-multiple-values (&key form expected actual line comment test)
Package

jingoh.tester.

Source

report.lisp.

Function: make-jingoh-internal-issue (&key form expected actual line comment message)
Package

jingoh.tester.

Source

report.lisp.

Function: make-missing-restarts (&key form expected actual line comment)
Package

jingoh.tester.

Source

report.lisp.

Function: make-test-issue (&key form expected actual line comment test)
Package

jingoh.tester.

Source

report.lisp.

Function: make-unexpected-output (&key form expected actual line comment)
Package

jingoh.tester.

Source

report.lisp.

Function: make-unexpected-success (&key form expected actual line comment)
Package

jingoh.tester.

Source

report.lisp.

Function: make-unmatch-condition (&key form expected actual line comment message)
Package

jingoh.tester.

Source

report.lisp.

Function: make-unsatisfied-clause (&key form expected actual line comment args)
Package

jingoh.tester.

Source

report.lisp.

Function: make-warning-was-signaled (&key form expected actual line comment message)
Package

jingoh.tester.

Source

report.lisp.

Function: make-wrong-format (&key form expected actual line comment test)
Package

jingoh.tester.

Source

report.lisp.

Function: missing-restarts-actual (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf missing-restarts-actual) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: missing-restarts-comment (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf missing-restarts-comment) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: missing-restarts-expected (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf missing-restarts-expected) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: missing-restarts-form (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf missing-restarts-form) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: missing-restarts-line (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf missing-restarts-line) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: print-dot (result)
Package

jingoh.examiner.

Source

examine.lisp.

Function: print-progress (subject &optional goto)
Package

jingoh.examiner.

Source

examine.lisp.

Function: print-requirement (result requirement)
Package

jingoh.examiner.

Source

examine.lisp.

Function: print-summary (issues &optional *standard-output*)
Package

jingoh.examiner.

Source

examine.lisp.

Function: should-print-vivid-p (issue)
Package

jingoh.tester.

Source

report.lisp.

Function: slots<=obj (obj)
Package

jingoh.tester.

Source

miscellaneous.lisp.

Function: spec (subject req)
Package

jingoh.org.

Source

org.lisp.

Reader: spec-requirements (instance)
Writer: (setf spec-requirements) (instance)
Package

jingoh.org.

Source

org.lisp.

Target Slot

requirements.

Reader: spec-subject (instance)
Package

jingoh.org.

Source

org.lisp.

Target Slot

subject.

Function: string-line-counter (stream character)
Package

jingoh.reader.

Source

reader.lisp.

Function: test-issue-actual (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf test-issue-actual) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: test-issue-comment (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf test-issue-comment) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: test-issue-expected (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf test-issue-expected) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: test-issue-form (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf test-issue-form) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: test-issue-line (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf test-issue-line) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unexpected-output-actual (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unexpected-output-actual) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unexpected-output-comment (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unexpected-output-comment) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unexpected-output-expected (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unexpected-output-expected) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unexpected-output-form (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unexpected-output-form) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unexpected-output-line (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unexpected-output-line) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unexpected-success-actual (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unexpected-success-actual) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unexpected-success-comment (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unexpected-success-comment) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unexpected-success-expected (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unexpected-success-expected) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unexpected-success-form (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unexpected-success-form) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unexpected-success-line (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unexpected-success-line) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unmatch-condition-actual (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unmatch-condition-actual) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unmatch-condition-comment (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unmatch-condition-comment) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unmatch-condition-expected (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unmatch-condition-expected) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unmatch-condition-form (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unmatch-condition-form) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unmatch-condition-line (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unmatch-condition-line) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unmatch-condition-message (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unmatch-condition-message) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unsatisfied-clause-actual (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unsatisfied-clause-actual) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unsatisfied-clause-comment (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unsatisfied-clause-comment) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unsatisfied-clause-expected (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unsatisfied-clause-expected) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unsatisfied-clause-form (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unsatisfied-clause-form) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: unsatisfied-clause-line (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf unsatisfied-clause-line) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: vprint-issue (output issue)
Package

jingoh.tester.

Source

report.lisp.

Function: vprint-unsatisfied-clause (output issue)
Package

jingoh.tester.

Source

report.lisp.

Function: warning-was-signaled-actual (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf warning-was-signaled-actual) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: warning-was-signaled-comment (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf warning-was-signaled-comment) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: warning-was-signaled-expected (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf warning-was-signaled-expected) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: warning-was-signaled-form (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf warning-was-signaled-form) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: warning-was-signaled-line (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf warning-was-signaled-line) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: warning-was-signaled-message (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf warning-was-signaled-message) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: wrong-format-actual (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf wrong-format-actual) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: wrong-format-comment (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf wrong-format-comment) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: wrong-format-expected (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf wrong-format-expected) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: wrong-format-form (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf wrong-format-form) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: wrong-format-line (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf wrong-format-line) (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: wrong-format-test (instance)
Package

jingoh.tester.

Source

report.lisp.

Function: (setf wrong-format-test) (instance)
Package

jingoh.tester.

Source

report.lisp.


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

5.2.3 Generic functions

Generic Reader: issues (condition)
Package

jingoh.examiner.

Methods
Reader Method: issues ((condition break-on-finish))
Source

examine.lisp.

Target Slot

issues.

Generic Reader: test-form (condition)
Package

jingoh.tester.

Methods
Reader Method: test-form ((condition unsatisfied))
Source

tester.lisp.

Target Slot

test-form.


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

5.2.4 Conditions

Condition: break-on-fails
Package

jingoh.examiner.

Source

examine.lisp.

Direct superclasses

error.

Condition: break-on-finish
Package

jingoh.examiner.

Source

examine.lisp.

Direct superclasses

error.

Direct methods
Direct slots
Slot: issues
Initargs

:issues

Readers

issues.

Writers

This slot is read-only.

Condition: unsatisfied
Package

jingoh.tester.

Source

tester.lisp.

Direct superclasses

error.

Direct methods
Direct slots
Slot: test-form
Initargs

:test-form

Readers

test-form.

Writers

This slot is read-only.

Slot: args
Initform

(quote nil)

Initargs

:args

Readers

args.

Writers

This slot is read-only.


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

5.2.5 Structures

Structure: spec
Package

jingoh.org.

Source

org.lisp.

Direct superclasses

structure-object.

Direct methods

print-object.

Direct slots
Slot: subject
Type

symbol

Readers

spec-subject.

Writers

This slot is read-only.

Slot: requirements
Type

(vector jingoh.org::requirement *)

Initform

#()

Readers

spec-requirements.

Writers

(setf spec-requirements).


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

5.2.6 Types

Type: requirement ()
Package

jingoh.org.

Source

org.lisp.


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

Jump to:   #   %   &   (   <   ?  
A   B   C   D   E   F   G   I   J   L   M   O   P   R   S   T   U   V   W  
Index Entry  Section

#
#+counter: Private ordinary functions
#?counter: Private ordinary functions
#?reader: Public ordinary functions
#?reader-body: Private ordinary functions

%
%collect-spec-lines: Private ordinary functions

&
&: Public macros

(
(setf condition-issue-actual): Private ordinary functions
(setf condition-issue-comment): Private ordinary functions
(setf condition-issue-expected): Private ordinary functions
(setf condition-issue-form): Private ordinary functions
(setf condition-issue-line): Private ordinary functions
(setf condition-issue-message): Public ordinary functions
(setf debugger-was-invoked-actual): Private ordinary functions
(setf debugger-was-invoked-comment): Private ordinary functions
(setf debugger-was-invoked-expected): Private ordinary functions
(setf debugger-was-invoked-form): Private ordinary functions
(setf debugger-was-invoked-line): Private ordinary functions
(setf debugger-was-invoked-message): Private ordinary functions
(setf error-was-signaled-actual): Private ordinary functions
(setf error-was-signaled-comment): Private ordinary functions
(setf error-was-signaled-expected): Private ordinary functions
(setf error-was-signaled-form): Private ordinary functions
(setf error-was-signaled-line): Private ordinary functions
(setf error-was-signaled-message): Private ordinary functions
(setf issue-actual): Public ordinary functions
(setf issue-comment): Private ordinary functions
(setf issue-expected): Public ordinary functions
(setf issue-form): Public ordinary functions
(setf issue-line): Public ordinary functions
(setf issue-of-multiple-values-actual): Private ordinary functions
(setf issue-of-multiple-values-comment): Private ordinary functions
(setf issue-of-multiple-values-expected): Private ordinary functions
(setf issue-of-multiple-values-form): Private ordinary functions
(setf issue-of-multiple-values-line): Private ordinary functions
(setf issue-of-multiple-values-test): Private ordinary functions
(setf jingoh-internal-issue-actual): Private ordinary functions
(setf jingoh-internal-issue-comment): Private ordinary functions
(setf jingoh-internal-issue-expected): Private ordinary functions
(setf jingoh-internal-issue-form): Private ordinary functions
(setf jingoh-internal-issue-line): Private ordinary functions
(setf jingoh-internal-issue-message): Private ordinary functions
(setf missing-restarts-actual): Private ordinary functions
(setf missing-restarts-comment): Private ordinary functions
(setf missing-restarts-expected): Private ordinary functions
(setf missing-restarts-form): Private ordinary functions
(setf missing-restarts-line): Private ordinary functions
(setf org-current-subjects): Public ordinary functions
(setf org-options): Public ordinary functions
(setf org-specifications): Public ordinary functions
(setf spec-requirements): Private ordinary functions
(setf test-issue-actual): Private ordinary functions
(setf test-issue-comment): Private ordinary functions
(setf test-issue-expected): Private ordinary functions
(setf test-issue-form): Private ordinary functions
(setf test-issue-line): Private ordinary functions
(setf test-issue-test): Public ordinary functions
(setf unexpected-output-actual): Private ordinary functions
(setf unexpected-output-comment): Private ordinary functions
(setf unexpected-output-expected): Private ordinary functions
(setf unexpected-output-form): Private ordinary functions
(setf unexpected-output-line): Private ordinary functions
(setf unexpected-success-actual): Private ordinary functions
(setf unexpected-success-comment): Private ordinary functions
(setf unexpected-success-expected): Private ordinary functions
(setf unexpected-success-form): Private ordinary functions
(setf unexpected-success-line): Private ordinary functions
(setf unmatch-condition-actual): Private ordinary functions
(setf unmatch-condition-comment): Private ordinary functions
(setf unmatch-condition-expected): Private ordinary functions
(setf unmatch-condition-form): Private ordinary functions
(setf unmatch-condition-line): Private ordinary functions
(setf unmatch-condition-message): Private ordinary functions
(setf unsatisfied-clause-actual): Private ordinary functions
(setf unsatisfied-clause-args): Public ordinary functions
(setf unsatisfied-clause-comment): Private ordinary functions
(setf unsatisfied-clause-expected): Private ordinary functions
(setf unsatisfied-clause-form): Private ordinary functions
(setf unsatisfied-clause-line): Private ordinary functions
(setf warning-was-signaled-actual): Private ordinary functions
(setf warning-was-signaled-comment): Private ordinary functions
(setf warning-was-signaled-expected): Private ordinary functions
(setf warning-was-signaled-form): Private ordinary functions
(setf warning-was-signaled-line): Private ordinary functions
(setf warning-was-signaled-message): Private ordinary functions
(setf wrong-format-actual): Private ordinary functions
(setf wrong-format-comment): Private ordinary functions
(setf wrong-format-expected): Private ordinary functions
(setf wrong-format-form): Private ordinary functions
(setf wrong-format-line): Private ordinary functions
(setf wrong-format-test): Private ordinary functions

<
<iterate-all-requirements>: Private ordinary functions
<iterate-specified-subjects-requirements>: Private ordinary functions

?
?: Public macros

A
add-new-option-key: Public ordinary functions
add-requirement: Public ordinary functions
api: Public generic functions
api: Public generic functions
args: Public generic functions
args: Public generic functions

B
block-comment: Private ordinary functions
break-on-fails: Private ordinary functions
break-on-finish: Private ordinary functions

C
canonicalize: Public ordinary functions
check: Public ordinary functions
clear-option-keys: Public ordinary functions
collect-spec-lines: Private ordinary functions
common-requirements-about: Public macros
condition-issue-actual: Private ordinary functions
condition-issue-comment: Private ordinary functions
condition-issue-expected: Private ordinary functions
condition-issue-form: Private ordinary functions
condition-issue-line: Private ordinary functions
condition-issue-message: Public ordinary functions
condition-issue-p: Public ordinary functions
copy-condition-issue: Private ordinary functions
copy-cons: Private ordinary functions
copy-debugger-was-invoked: Private ordinary functions
copy-error-was-signaled: Private ordinary functions
copy-issue: Private ordinary functions
copy-issue-of-multiple-values: Private ordinary functions
copy-jingoh-internal-issue: Private ordinary functions
copy-missing-restarts: Private ordinary functions
copy-test-issue: Private ordinary functions
copy-unexpected-output: Private ordinary functions
copy-unexpected-success: Private ordinary functions
copy-unmatch-condition: Private ordinary functions
copy-unsatisfied-clause: Private ordinary functions
copy-warning-was-signaled: Private ordinary functions
copy-wrong-format: Private ordinary functions

D
datum: Public generic functions
datum: Public generic functions
debugger-was-invoked-actual: Private ordinary functions
debugger-was-invoked-comment: Private ordinary functions
debugger-was-invoked-expected: Private ordinary functions
debugger-was-invoked-form: Private ordinary functions
debugger-was-invoked-line: Private ordinary functions
debugger-was-invoked-message: Private ordinary functions
debugger-was-invoked-p: Public ordinary functions
deforg: Public macros
defspec: Public macros
delete-option-key: Public ordinary functions
delete-org: Public ordinary functions
delete-subject: Public ordinary functions
do-requirements: Public macros

E
enable: Public macros
encallable: Public ordinary functions
error-was-signaled-actual: Private ordinary functions
error-was-signaled-comment: Private ordinary functions
error-was-signaled-expected: Private ordinary functions
error-was-signaled-form: Private ordinary functions
error-was-signaled-line: Private ordinary functions
error-was-signaled-message: Private ordinary functions
error-was-signaled-p: Public ordinary functions
examine: Public ordinary functions

F
find-option-key: Public ordinary functions
find-org: Public ordinary functions
find-subject: Private ordinary functions
Function, #+counter: Private ordinary functions
Function, #?counter: Private ordinary functions
Function, #?reader: Public ordinary functions
Function, #?reader-body: Private ordinary functions
Function, %collect-spec-lines: Private ordinary functions
Function, (setf condition-issue-actual): Private ordinary functions
Function, (setf condition-issue-comment): Private ordinary functions
Function, (setf condition-issue-expected): Private ordinary functions
Function, (setf condition-issue-form): Private ordinary functions
Function, (setf condition-issue-line): Private ordinary functions
Function, (setf condition-issue-message): Public ordinary functions
Function, (setf debugger-was-invoked-actual): Private ordinary functions
Function, (setf debugger-was-invoked-comment): Private ordinary functions
Function, (setf debugger-was-invoked-expected): Private ordinary functions
Function, (setf debugger-was-invoked-form): Private ordinary functions
Function, (setf debugger-was-invoked-line): Private ordinary functions
Function, (setf debugger-was-invoked-message): Private ordinary functions
Function, (setf error-was-signaled-actual): Private ordinary functions
Function, (setf error-was-signaled-comment): Private ordinary functions
Function, (setf error-was-signaled-expected): Private ordinary functions
Function, (setf error-was-signaled-form): Private ordinary functions
Function, (setf error-was-signaled-line): Private ordinary functions
Function, (setf error-was-signaled-message): Private ordinary functions
Function, (setf issue-actual): Public ordinary functions
Function, (setf issue-comment): Private ordinary functions
Function, (setf issue-expected): Public ordinary functions
Function, (setf issue-form): Public ordinary functions
Function, (setf issue-line): Public ordinary functions
Function, (setf issue-of-multiple-values-actual): Private ordinary functions
Function, (setf issue-of-multiple-values-comment): Private ordinary functions
Function, (setf issue-of-multiple-values-expected): Private ordinary functions
Function, (setf issue-of-multiple-values-form): Private ordinary functions
Function, (setf issue-of-multiple-values-line): Private ordinary functions
Function, (setf issue-of-multiple-values-test): Private ordinary functions
Function, (setf jingoh-internal-issue-actual): Private ordinary functions
Function, (setf jingoh-internal-issue-comment): Private ordinary functions
Function, (setf jingoh-internal-issue-expected): Private ordinary functions
Function, (setf jingoh-internal-issue-form): Private ordinary functions
Function, (setf jingoh-internal-issue-line): Private ordinary functions
Function, (setf jingoh-internal-issue-message): Private ordinary functions
Function, (setf missing-restarts-actual): Private ordinary functions
Function, (setf missing-restarts-comment): Private ordinary functions
Function, (setf missing-restarts-expected): Private ordinary functions
Function, (setf missing-restarts-form): Private ordinary functions
Function, (setf missing-restarts-line): Private ordinary functions
Function, (setf org-current-subjects): Public ordinary functions
Function, (setf org-options): Public ordinary functions
Function, (setf org-specifications): Public ordinary functions
Function, (setf spec-requirements): Private ordinary functions
Function, (setf test-issue-actual): Private ordinary functions
Function, (setf test-issue-comment): Private ordinary functions
Function, (setf test-issue-expected): Private ordinary functions
Function, (setf test-issue-form): Private ordinary functions
Function, (setf test-issue-line): Private ordinary functions
Function, (setf test-issue-test): Public ordinary functions
Function, (setf unexpected-output-actual): Private ordinary functions
Function, (setf unexpected-output-comment): Private ordinary functions
Function, (setf unexpected-output-expected): Private ordinary functions
Function, (setf unexpected-output-form): Private ordinary functions
Function, (setf unexpected-output-line): Private ordinary functions
Function, (setf unexpected-success-actual): Private ordinary functions
Function, (setf unexpected-success-comment): Private ordinary functions
Function, (setf unexpected-success-expected): Private ordinary functions
Function, (setf unexpected-success-form): Private ordinary functions
Function, (setf unexpected-success-line): Private ordinary functions
Function, (setf unmatch-condition-actual): Private ordinary functions
Function, (setf unmatch-condition-comment): Private ordinary functions
Function, (setf unmatch-condition-expected): Private ordinary functions
Function, (setf unmatch-condition-form): Private ordinary functions
Function, (setf unmatch-condition-line): Private ordinary functions
Function, (setf unmatch-condition-message): Private ordinary functions
Function, (setf unsatisfied-clause-actual): Private ordinary functions
Function, (setf unsatisfied-clause-args): Public ordinary functions
Function, (setf unsatisfied-clause-comment): Private ordinary functions
Function, (setf unsatisfied-clause-expected): Private ordinary functions
Function, (setf unsatisfied-clause-form): Private ordinary functions
Function, (setf unsatisfied-clause-line): Private ordinary functions
Function, (setf warning-was-signaled-actual): Private ordinary functions
Function, (setf warning-was-signaled-comment): Private ordinary functions
Function, (setf warning-was-signaled-expected): Private ordinary functions
Function, (setf warning-was-signaled-form): Private ordinary functions
Function, (setf warning-was-signaled-line): Private ordinary functions
Function, (setf warning-was-signaled-message): Private ordinary functions
Function, (setf wrong-format-actual): Private ordinary functions
Function, (setf wrong-format-comment): Private ordinary functions
Function, (setf wrong-format-expected): Private ordinary functions
Function, (setf wrong-format-form): Private ordinary functions
Function, (setf wrong-format-line): Private ordinary functions
Function, (setf wrong-format-test): Private ordinary functions
Function, <iterate-all-requirements>: Private ordinary functions
Function, <iterate-specified-subjects-requirements>: Private ordinary functions
Function, add-new-option-key: Public ordinary functions
Function, add-requirement: Public ordinary functions
Function, block-comment: Private ordinary functions
Function, break-on-fails: Private ordinary functions
Function, break-on-finish: Private ordinary functions
Function, canonicalize: Public ordinary functions
Function, check: Public ordinary functions
Function, clear-option-keys: Public ordinary functions
Function, collect-spec-lines: Private ordinary functions
Function, condition-issue-actual: Private ordinary functions
Function, condition-issue-comment: Private ordinary functions
Function, condition-issue-expected: Private ordinary functions
Function, condition-issue-form: Private ordinary functions
Function, condition-issue-line: Private ordinary functions
Function, condition-issue-message: Public ordinary functions
Function, condition-issue-p: Public ordinary functions
Function, copy-condition-issue: Private ordinary functions
Function, copy-cons: Private ordinary functions
Function, copy-debugger-was-invoked: Private ordinary functions
Function, copy-error-was-signaled: Private ordinary functions
Function, copy-issue: Private ordinary functions
Function, copy-issue-of-multiple-values: Private ordinary functions
Function, copy-jingoh-internal-issue: Private ordinary functions
Function, copy-missing-restarts: Private ordinary functions
Function, copy-test-issue: Private ordinary functions
Function, copy-unexpected-output: Private ordinary functions
Function, copy-unexpected-success: Private ordinary functions
Function, copy-unmatch-condition: Private ordinary functions
Function, copy-unsatisfied-clause: Private ordinary functions
Function, copy-warning-was-signaled: Private ordinary functions
Function, copy-wrong-format: Private ordinary functions
Function, debugger-was-invoked-actual: Private ordinary functions
Function, debugger-was-invoked-comment: Private ordinary functions
Function, debugger-was-invoked-expected: Private ordinary functions
Function, debugger-was-invoked-form: Private ordinary functions
Function, debugger-was-invoked-line: Private ordinary functions
Function, debugger-was-invoked-message: Private ordinary functions
Function, debugger-was-invoked-p: Public ordinary functions
Function, delete-option-key: Public ordinary functions
Function, delete-org: Public ordinary functions
Function, delete-subject: Public ordinary functions
Function, encallable: Public ordinary functions
Function, error-was-signaled-actual: Private ordinary functions
Function, error-was-signaled-comment: Private ordinary functions
Function, error-was-signaled-expected: Private ordinary functions
Function, error-was-signaled-form: Private ordinary functions
Function, error-was-signaled-line: Private ordinary functions
Function, error-was-signaled-message: Private ordinary functions
Function, error-was-signaled-p: Public ordinary functions
Function, examine: Public ordinary functions
Function, find-option-key: Public ordinary functions
Function, find-org: Public ordinary functions
Function, find-subject: Private ordinary functions
Function, function-designator-p: Private ordinary functions
Function, ignore-signals: Private ordinary functions
Function, issue-actual: Public ordinary functions
Function, issue-comment: Private ordinary functions
Function, issue-expected: Public ordinary functions
Function, issue-form: Public ordinary functions
Function, issue-line: Public ordinary functions
Function, issue-of-multiple-values-actual: Private ordinary functions
Function, issue-of-multiple-values-comment: Private ordinary functions
Function, issue-of-multiple-values-expected: Private ordinary functions
Function, issue-of-multiple-values-form: Private ordinary functions
Function, issue-of-multiple-values-line: Private ordinary functions
Function, issue-of-multiple-values-p: Public ordinary functions
Function, issue-of-multiple-values-test: Private ordinary functions
Function, issue-p: Public ordinary functions
Function, jingoh-internal-issue-actual: Private ordinary functions
Function, jingoh-internal-issue-comment: Private ordinary functions
Function, jingoh-internal-issue-expected: Private ordinary functions
Function, jingoh-internal-issue-form: Private ordinary functions
Function, jingoh-internal-issue-line: Private ordinary functions
Function, jingoh-internal-issue-message: Private ordinary functions
Function, jingoh-internal-issue-p: Private ordinary functions
Function, line-comment: Private ordinary functions
Function, line-counter: Private ordinary functions
Function, list-all-option-keys: Public ordinary functions
Function, make-condition-issue: Private ordinary functions
Function, make-debugger-was-invoked: Private ordinary functions
Function, make-error-was-signaled: Private ordinary functions
Function, make-issue: Private ordinary functions
Function, make-issue-of-multiple-values: Private ordinary functions
Function, make-jingoh-internal-issue: Private ordinary functions
Function, make-missing-restarts: Private ordinary functions
Function, make-org: Public ordinary functions
Function, make-test-issue: Private ordinary functions
Function, make-unexpected-output: Private ordinary functions
Function, make-unexpected-success: Private ordinary functions
Function, make-unmatch-condition: Private ordinary functions
Function, make-unsatisfied-clause: Private ordinary functions
Function, make-warning-was-signaled: Private ordinary functions
Function, make-wrong-format: Private ordinary functions
Function, missing-restarts-actual: Private ordinary functions
Function, missing-restarts-comment: Private ordinary functions
Function, missing-restarts-expected: Private ordinary functions
Function, missing-restarts-form: Private ordinary functions
Function, missing-restarts-line: Private ordinary functions
Function, missing-restarts-p: Public ordinary functions
Function, org-current-subjects: Public ordinary functions
Function, org-name: Public ordinary functions
Function, org-options: Public ordinary functions
Function, org-p: Public ordinary functions
Function, org-package: Public ordinary functions
Function, org-requirements-count: Public ordinary functions
Function, org-specifications: Public ordinary functions
Function, print-dot: Private ordinary functions
Function, print-progress: Private ordinary functions
Function, print-requirement: Private ordinary functions
Function, print-summary: Private ordinary functions
Function, register-org: Public ordinary functions
Function, replace-macro-character: Public ordinary functions
Function, requirement-form: Public ordinary functions
Function, reserved-keywords: Public ordinary functions
Function, sexp=: Public ordinary functions
Function, should-print-vivid-p: Private ordinary functions
Function, slots<=obj: Private ordinary functions
Function, spec: Private ordinary functions
Function, spec-requirements: Private ordinary functions
Function, spec-subject: Private ordinary functions
Function, string-line-counter: Private ordinary functions
Function, test-issue-actual: Private ordinary functions
Function, test-issue-comment: Private ordinary functions
Function, test-issue-expected: Private ordinary functions
Function, test-issue-form: Private ordinary functions
Function, test-issue-line: Private ordinary functions
Function, test-issue-p: Public ordinary functions
Function, test-issue-test: Public ordinary functions
Function, the-push-instance-form: Public ordinary functions
Function, the-standard-handling-form: Public ordinary functions
Function, unexpected-output-actual: Private ordinary functions
Function, unexpected-output-comment: Private ordinary functions
Function, unexpected-output-expected: Private ordinary functions
Function, unexpected-output-form: Private ordinary functions
Function, unexpected-output-line: Private ordinary functions
Function, unexpected-output-p: Public ordinary functions
Function, unexpected-success-actual: Private ordinary functions
Function, unexpected-success-comment: Private ordinary functions
Function, unexpected-success-expected: Private ordinary functions
Function, unexpected-success-form: Private ordinary functions
Function, unexpected-success-line: Private ordinary functions
Function, unexpected-success-p: Public ordinary functions
Function, unmatch-condition-actual: Private ordinary functions
Function, unmatch-condition-comment: Private ordinary functions
Function, unmatch-condition-expected: Private ordinary functions
Function, unmatch-condition-form: Private ordinary functions
Function, unmatch-condition-line: Private ordinary functions
Function, unmatch-condition-message: Private ordinary functions
Function, unmatch-condition-p: Public ordinary functions
Function, unsatisfied-clause-actual: Private ordinary functions
Function, unsatisfied-clause-args: Public ordinary functions
Function, unsatisfied-clause-comment: Private ordinary functions
Function, unsatisfied-clause-expected: Private ordinary functions
Function, unsatisfied-clause-form: Private ordinary functions
Function, unsatisfied-clause-line: Private ordinary functions
Function, unsatisfied-clause-p: Public ordinary functions
Function, vprint-issue: Private ordinary functions
Function, vprint-unsatisfied-clause: Private ordinary functions
Function, warning-was-signaled-actual: Private ordinary functions
Function, warning-was-signaled-comment: Private ordinary functions
Function, warning-was-signaled-expected: Private ordinary functions
Function, warning-was-signaled-form: Private ordinary functions
Function, warning-was-signaled-line: Private ordinary functions
Function, warning-was-signaled-message: Private ordinary functions
Function, warning-was-signaled-p: Public ordinary functions
Function, wrong-format-actual: Private ordinary functions
Function, wrong-format-comment: Private ordinary functions
Function, wrong-format-expected: Private ordinary functions
Function, wrong-format-form: Private ordinary functions
Function, wrong-format-line: Private ordinary functions
Function, wrong-format-p: Public ordinary functions
Function, wrong-format-test: Private ordinary functions
function-designator-p: Private ordinary functions

G
Generic Function, api: Public generic functions
Generic Function, args: Public generic functions
Generic Function, datum: Public generic functions
Generic Function, issues: Private generic functions
Generic Function, make-requirement: Public generic functions
Generic Function, test-form: Private generic functions

I
ignore-signals: Private ordinary functions
in-org: Public macros
issue-actual: Public ordinary functions
issue-comment: Private ordinary functions
issue-expected: Public ordinary functions
issue-form: Public ordinary functions
issue-line: Public ordinary functions
issue-of-multiple-values-actual: Private ordinary functions
issue-of-multiple-values-comment: Private ordinary functions
issue-of-multiple-values-expected: Private ordinary functions
issue-of-multiple-values-form: Private ordinary functions
issue-of-multiple-values-line: Private ordinary functions
issue-of-multiple-values-p: Public ordinary functions
issue-of-multiple-values-test: Private ordinary functions
issue-p: Public ordinary functions
issues: Private generic functions
issues: Private generic functions

J
jingoh-internal-issue-actual: Private ordinary functions
jingoh-internal-issue-comment: Private ordinary functions
jingoh-internal-issue-expected: Private ordinary functions
jingoh-internal-issue-form: Private ordinary functions
jingoh-internal-issue-line: Private ordinary functions
jingoh-internal-issue-message: Private ordinary functions
jingoh-internal-issue-p: Private ordinary functions

L
line-comment: Private ordinary functions
line-counter: Private ordinary functions
list-all-option-keys: Public ordinary functions

M
Macro, &: Public macros
Macro, ?: Public macros
Macro, common-requirements-about: Public macros
Macro, deforg: Public macros
Macro, defspec: Public macros
Macro, do-requirements: Public macros
Macro, enable: Public macros
Macro, in-org: Public macros
Macro, requirements-about: Public macros
Macro, setup: Public macros
Macro, with-examiner-context: Public macros
Macro, with-integrated-output-stream: Public macros
make-condition-issue: Private ordinary functions
make-debugger-was-invoked: Private ordinary functions
make-error-was-signaled: Private ordinary functions
make-issue: Private ordinary functions
make-issue-of-multiple-values: Private ordinary functions
make-jingoh-internal-issue: Private ordinary functions
make-missing-restarts: Private ordinary functions
make-org: Public ordinary functions
make-requirement: Public generic functions
make-requirement: Public generic functions
make-requirement: Public generic functions
make-requirement: Public generic functions
make-requirement: Public generic functions
make-requirement: Public generic functions
make-requirement: Public generic functions
make-requirement: Public generic functions
make-requirement: Public generic functions
make-requirement: Public generic functions
make-requirement: Public generic functions
make-requirement: Public generic functions
make-requirement: Public generic functions
make-requirement: Public generic functions
make-requirement: Public generic functions
make-requirement: Public generic functions
make-test-issue: Private ordinary functions
make-unexpected-output: Private ordinary functions
make-unexpected-success: Private ordinary functions
make-unmatch-condition: Private ordinary functions
make-unsatisfied-clause: Private ordinary functions
make-warning-was-signaled: Private ordinary functions
make-wrong-format: Private ordinary functions
Method, api: Public generic functions
Method, args: Public generic functions
Method, datum: Public generic functions
Method, issues: Private generic functions
Method, make-requirement: Public generic functions
Method, make-requirement: Public generic functions
Method, make-requirement: Public generic functions
Method, make-requirement: Public generic functions
Method, make-requirement: Public generic functions
Method, make-requirement: Public generic functions
Method, make-requirement: Public generic functions
Method, make-requirement: Public generic functions
Method, make-requirement: Public generic functions
Method, make-requirement: Public generic functions
Method, make-requirement: Public generic functions
Method, make-requirement: Public generic functions
Method, make-requirement: Public generic functions
Method, make-requirement: Public generic functions
Method, make-requirement: Public generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, test-form: Private generic functions
missing-restarts-actual: Private ordinary functions
missing-restarts-comment: Private ordinary functions
missing-restarts-expected: Private ordinary functions
missing-restarts-form: Private ordinary functions
missing-restarts-line: Private ordinary functions
missing-restarts-p: Public ordinary functions

O
org-current-subjects: Public ordinary functions
org-name: Public ordinary functions
org-options: Public ordinary functions
org-p: Public ordinary functions
org-package: Public ordinary functions
org-requirements-count: Public ordinary functions
org-specifications: Public ordinary functions

P
print-dot: Private ordinary functions
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-progress: Private ordinary functions
print-requirement: Private ordinary functions
print-summary: Private ordinary functions

R
register-org: Public ordinary functions
replace-macro-character: Public ordinary functions
requirement-form: Public ordinary functions
requirements-about: Public macros
reserved-keywords: Public ordinary functions

S
setup: Public macros
sexp=: Public ordinary functions
should-print-vivid-p: Private ordinary functions
slots<=obj: Private ordinary functions
spec: Private ordinary functions
spec-requirements: Private ordinary functions
spec-subject: Private ordinary functions
string-line-counter: Private ordinary functions

T
test-form: Private generic functions
test-form: Private generic functions
test-issue-actual: Private ordinary functions
test-issue-comment: Private ordinary functions
test-issue-expected: Private ordinary functions
test-issue-form: Private ordinary functions
test-issue-line: Private ordinary functions
test-issue-p: Public ordinary functions
test-issue-test: Public ordinary functions
the-push-instance-form: Public ordinary functions
the-standard-handling-form: Public ordinary functions

U
unexpected-output-actual: Private ordinary functions
unexpected-output-comment: Private ordinary functions
unexpected-output-expected: Private ordinary functions
unexpected-output-form: Private ordinary functions
unexpected-output-line: Private ordinary functions
unexpected-output-p: Public ordinary functions
unexpected-success-actual: Private ordinary functions
unexpected-success-comment: Private ordinary functions
unexpected-success-expected: Private ordinary functions
unexpected-success-form: Private ordinary functions
unexpected-success-line: Private ordinary functions
unexpected-success-p: Public ordinary functions
unmatch-condition-actual: Private ordinary functions
unmatch-condition-comment: Private ordinary functions
unmatch-condition-expected: Private ordinary functions
unmatch-condition-form: Private ordinary functions
unmatch-condition-line: Private ordinary functions
unmatch-condition-message: Private ordinary functions
unmatch-condition-p: Public ordinary functions
unsatisfied-clause-actual: Private ordinary functions
unsatisfied-clause-args: Public ordinary functions
unsatisfied-clause-comment: Private ordinary functions
unsatisfied-clause-expected: Private ordinary functions
unsatisfied-clause-form: Private ordinary functions
unsatisfied-clause-line: Private ordinary functions
unsatisfied-clause-p: Public ordinary functions

V
vprint-issue: Private ordinary functions
vprint-unsatisfied-clause: Private ordinary functions

W
warning-was-signaled-actual: Private ordinary functions
warning-was-signaled-comment: Private ordinary functions
warning-was-signaled-expected: Private ordinary functions
warning-was-signaled-form: Private ordinary functions
warning-was-signaled-line: Private ordinary functions
warning-was-signaled-message: Private ordinary functions
warning-was-signaled-p: Public ordinary functions
with-examiner-context: Public macros
with-integrated-output-stream: Public macros
wrong-format-actual: Private ordinary functions
wrong-format-comment: Private ordinary functions
wrong-format-expected: Private ordinary functions
wrong-format-form: Private ordinary functions
wrong-format-line: Private ordinary functions
wrong-format-p: Public ordinary functions
wrong-format-test: Private ordinary functions

Jump to:   #   %   &   (   <   ?  
A   B   C   D   E   F   G   I   J   L   M   O   P   R   S   T   U   V   W  

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

A.3 Variables

Jump to:   *  
A   C   D   E   F   I   L   M   N   O   P   R   S   T  
Index Entry  Section

*
*break-on-finish*: Public special variables
*counter*: Private special variables
*dispatch-macro-character*: Private special variables
*dispatch-macro-sub-char*: Private special variables
*issues*: Public special variables
*line*: Private special variables
*line-pos*: Private special variables
*lines*: Private special variables
*on-fails*: Public special variables
*option-keys*: Private special variables
*org*: Public special variables
*orgs*: Private special variables
*read-print*: Public special variables
*read-verbose*: Public special variables
*reader-package*: Private special variables
*requirement-form*: Private special variables
*verbose*: Public special variables

A
actual: Public structures
api: Public conditions
args: Public structures
args: Private conditions

C
comment: Public structures
current-subjects: Public structures

D
datum: Public conditions

E
expected: Public structures

F
form: Public structures

I
issues: Private conditions

L
line: Public structures

M
message: Public structures

N
name: Public structures

O
options: Public structures

P
package: Public structures

R
requirements: Private structures

S
Slot, actual: Public structures
Slot, api: Public conditions
Slot, args: Public structures
Slot, args: Private conditions
Slot, comment: Public structures
Slot, current-subjects: Public structures
Slot, datum: Public conditions
Slot, expected: Public structures
Slot, form: Public structures
Slot, issues: Private conditions
Slot, line: Public structures
Slot, message: Public structures
Slot, name: Public structures
Slot, options: Public structures
Slot, package: Public structures
Slot, requirements: Private structures
Slot, specifications: Public structures
Slot, subject: Private structures
Slot, test: Public structures
Slot, test-form: Private conditions
Special Variable, *break-on-finish*: Public special variables
Special Variable, *counter*: Private special variables
Special Variable, *dispatch-macro-character*: Private special variables
Special Variable, *dispatch-macro-sub-char*: Private special variables
Special Variable, *issues*: Public special variables
Special Variable, *line*: Private special variables
Special Variable, *line-pos*: Private special variables
Special Variable, *lines*: Private special variables
Special Variable, *on-fails*: Public special variables
Special Variable, *option-keys*: Private special variables
Special Variable, *org*: Public special variables
Special Variable, *orgs*: Private special variables
Special Variable, *read-print*: Public special variables
Special Variable, *read-verbose*: Public special variables
Special Variable, *reader-package*: Private special variables
Special Variable, *requirement-form*: Private special variables
Special Variable, *verbose*: Public special variables
specifications: Public structures
subject: Private structures

T
test: Public structures
test-form: Private conditions

Jump to:   *  
A   C   D   E   F   I   L   M   N   O   P   R   S   T  

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

A.4 Data types

Jump to:   B   C   D   E   F   I   J   M   O   P   R   S   T   U   W  
Index Entry  Section

B
break-on-fails: Private conditions
break-on-finish: Private conditions

C
Condition, break-on-fails: Private conditions
Condition, break-on-finish: Private conditions
Condition, macro-char-confliction: Public conditions
Condition, missing: Public conditions
Condition, missing-org: Public conditions
Condition, missing-subject: Public conditions
Condition, syntax-error: Public conditions
Condition, unsatisfied: Private conditions
condition-issue: Public structures
conditions.lisp: The jingoh․org/conditions․lisp file

D
debugger-was-invoked: Public structures
deforg.lisp: The jingoh․org/deforg․lisp file

E
error-was-signaled: Public structures
examine.lisp: The jingoh․examiner/examine․lisp file

F
File, conditions.lisp: The jingoh․org/conditions․lisp file
File, deforg.lisp: The jingoh․org/deforg․lisp file
File, examine.lisp: The jingoh․examiner/examine․lisp file
File, jingoh.asd: The jingoh/jingoh․asd file
File, jingoh.examiner.asd: The jingoh․examiner/jingoh․examiner․asd file
File, jingoh.org.asd: The jingoh․org/jingoh․org․asd file
File, jingoh.reader.asd: The jingoh․reader/jingoh․reader․asd file
File, jingoh.tester.asd: The jingoh․tester/jingoh․tester․asd file
File, miscellaneous.lisp: The jingoh․org/miscellaneous․lisp file
File, miscellaneous.lisp: The jingoh․tester/miscellaneous․lisp file
File, org.lisp: The jingoh․org/org․lisp file
File, package.lisp: The jingoh/package․lisp file
File, package.lisp: The jingoh․org/package․lisp file
File, package.lisp: The jingoh․tester/package․lisp file
File, reader.lisp: The jingoh․reader/reader․lisp file
File, report.lisp: The jingoh․tester/report․lisp file
File, tester.lisp: The jingoh․tester/tester․lisp file

I
issue: Public structures
issue-of-multiple-values: Public structures

J
jingoh: The jingoh system
jingoh: The jingoh package
jingoh-internal-issue: Public structures
jingoh.asd: The jingoh/jingoh․asd file
jingoh.examiner: The jingoh․examiner system
jingoh.examiner: The jingoh․examiner package
jingoh.examiner.asd: The jingoh․examiner/jingoh․examiner․asd file
jingoh.org: The jingoh․org system
jingoh.org: The jingoh․org package
jingoh.org.asd: The jingoh․org/jingoh․org․asd file
jingoh.reader: The jingoh․reader system
jingoh.reader: The jingoh․reader package
jingoh.reader.asd: The jingoh․reader/jingoh․reader․asd file
jingoh.tester: The jingoh․tester system
jingoh.tester: The jingoh․tester package
jingoh.tester.asd: The jingoh․tester/jingoh․tester․asd file

M
macro-char-confliction: Public conditions
miscellaneous.lisp: The jingoh․org/miscellaneous․lisp file
miscellaneous.lisp: The jingoh․tester/miscellaneous․lisp file
missing: Public conditions
missing-org: Public conditions
missing-restarts: Public structures
missing-subject: Public conditions

O
org: Public structures
org-designator: Public types
org.lisp: The jingoh․org/org․lisp file

P
Package, jingoh: The jingoh package
Package, jingoh.examiner: The jingoh․examiner package
Package, jingoh.org: The jingoh․org package
Package, jingoh.reader: The jingoh․reader package
Package, jingoh.tester: The jingoh․tester package
package.lisp: The jingoh/package․lisp file
package.lisp: The jingoh․org/package․lisp file
package.lisp: The jingoh․tester/package․lisp file

R
reader.lisp: The jingoh․reader/reader․lisp file
report.lisp: The jingoh․tester/report․lisp file
requirement: Private types

S
spec: Private structures
Structure, condition-issue: Public structures
Structure, debugger-was-invoked: Public structures
Structure, error-was-signaled: Public structures
Structure, issue: Public structures
Structure, issue-of-multiple-values: Public structures
Structure, jingoh-internal-issue: Public structures
Structure, missing-restarts: Public structures
Structure, org: Public structures
Structure, spec: Private structures
Structure, test-issue: Public structures
Structure, unexpected-output: Public structures
Structure, unexpected-success: Public structures
Structure, unmatch-condition: Public structures
Structure, unsatisfied-clause: Public structures
Structure, warning-was-signaled: Public structures
Structure, wrong-format: Public structures
subject-designator: Public types
syntax-error: Public conditions
System, jingoh: The jingoh system
System, jingoh.examiner: The jingoh․examiner system
System, jingoh.org: The jingoh․org system
System, jingoh.reader: The jingoh․reader system
System, jingoh.tester: The jingoh․tester system

T
test-issue: Public structures
tester.lisp: The jingoh․tester/tester․lisp file
Type, org-designator: Public types
Type, requirement: Private types
Type, subject-designator: Public types

U
unexpected-output: Public structures
unexpected-success: Public structures
unmatch-condition: Public structures
unsatisfied: Private conditions
unsatisfied-clause: Public structures

W
warning-was-signaled: Public structures
wrong-format: Public structures

Jump to:   B   C   D   E   F   I   J   M   O   P   R   S   T   U   W