The jingoh Reference Manual

Table of Contents

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 3.0 "Montgomery Scott" on Fri Jun 26 11:23:42 2020 GMT+0.


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

1 Introduction

JINGOH 0.0.0

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


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

2 Systems

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


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

2.1 jingoh

Author

Shinichi Sato

License

MIT

Description

DSL to notate specification, rather than test framework.

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 (file)

Component

package.lisp (file)


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

2.2 jingoh.examiner

Author

SATO Shinichi

License

MIT

Description

Jingoh module for test running and control/config output.

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.12

Dependencies
Source

jingoh.examiner.asd (file)

Component

examine.lisp (file)


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

2.3 jingoh.reader

Author

SATO Shinichi

License

MIT

Description

Jingoh module to provide reader macro.

Long Description

## Abstract concepts

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

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

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

Version

2.2.4

Dependencies
Source

jingoh.reader.asd (file)

Component

reader.lisp (file)


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

2.4 jingoh.tester

Author

SATO Shinichi

License

MIT

Description

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

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.1.10

Dependencies
Source

jingoh.tester.asd (file)

Components

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

2.5 jingoh.org

Author

SATO Shinichi

License

MIT

Description

Jingoh’s background database system

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

0.1.11

Dependencies
Source

jingoh.org.asd (file)

Components

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

3 Files

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


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

3.1 Lisp


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

3.1.1 jingoh.asd

Location

jingoh.asd

Systems

jingoh (system)


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

3.1.2 jingoh.examiner.asd

Location

examiner/jingoh.examiner.asd

Systems

jingoh.examiner (system)


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

3.1.3 jingoh.reader.asd

Location

reader/jingoh.reader.asd

Systems

jingoh.reader (system)


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

3.1.4 jingoh.tester.asd

Location

tester/jingoh.tester.asd

Systems

jingoh.tester (system)


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

3.1.5 jingoh.org.asd

Location

org/jingoh.org.asd

Systems

jingoh.org (system)


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

3.1.6 jingoh/package.lisp

Parent

jingoh (system)

Location

package.lisp

Packages

jingoh

Exported Definitions

setup (macro)


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

3.1.7 jingoh.examiner/examine.lisp

Parent

jingoh.examiner (system)

Location

examiner/src/examine.lisp

Packages

jingoh.examiner

Exported Definitions
Internal Definitions

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

3.1.8 jingoh.reader/reader.lisp

Parent

jingoh.reader (system)

Location

reader/src/reader.lisp

Packages

jingoh.reader

Exported Definitions
Internal Definitions

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

3.1.9 jingoh.tester/package.lisp

Parent

jingoh.tester (system)

Location

tester/src/package.lisp

Packages

jingoh.tester


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

3.1.10 jingoh.tester/report.lisp

Dependency

package.lisp (file)

Parent

jingoh.tester (system)

Location

tester/src/report.lisp

Exported Definitions
Internal Definitions

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

3.1.11 jingoh.tester/miscellaneous.lisp

Dependency

package.lisp (file)

Parent

jingoh.tester (system)

Location

tester/src/miscellaneous.lisp

Exported Definitions
Internal Definitions

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

3.1.12 jingoh.tester/tester.lisp

Dependencies
Parent

jingoh.tester (system)

Location

tester/src/tester.lisp

Exported Definitions
Internal Definitions

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

3.1.13 jingoh.org/package.lisp

Parent

jingoh.org (system)

Location

org/src/package.lisp

Packages

jingoh.org


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

3.1.14 jingoh.org/conditions.lisp

Dependency

package.lisp (file)

Parent

jingoh.org (system)

Location

org/src/conditions.lisp

Exported Definitions

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

3.1.15 jingoh.org/org.lisp

Dependency

package.lisp (file)

Parent

jingoh.org (system)

Location

org/src/org.lisp

Exported Definitions
Internal Definitions

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

3.1.16 jingoh.org/deforg.lisp

Dependency

org.lisp (file)

Parent

jingoh.org (system)

Location

org/src/deforg.lisp

Exported Definitions
Internal Definitions

*orgs* (special variable)


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

3.1.17 jingoh.org/miscellaneous.lisp

Dependencies
Parent

jingoh.org (system)

Location

org/src/miscellaneous.lisp

Exported Definitions
Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 jingoh

Source

package.lisp (file)

Use List
Exported Definitions

setup (macro)


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

4.2 jingoh.examiner

Source

examine.lisp (file)

Use List
Used By List

jingoh

Exported Definitions
Internal Definitions

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

4.3 jingoh.reader

Source

reader.lisp (file)

Use List
Used By List

jingoh

Exported Definitions
Internal Definitions

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

4.4 jingoh.tester

Source

package.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

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

4.5 jingoh.org

Source

package.lisp (file)

Nickname

org

Use List
Used By List
Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Special variables

Special Variable: *break-on-finish*

Breaks when finish examine.

Package

jingoh.examiner

Source

examine.lisp (file)

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 list
“‘
Initial value is NIL

## Affected By:
EXAMINE

## Notes:
Debug use.

Package

jingoh.examiner

Source

examine.lisp (file)

Special Variable: *on-fails*

# \*ON-FAILS\*

## Description:
Specify EXAMINE’s behavior.

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

“‘lisp
#? *ON-FAILS*
:be-the (member :error :stop nil)
“‘
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 (file)

Special Variable: *org*

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

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

## Affected By:
IN-ORG

## Notes:
# conditions

Package

jingoh.org

Source

deforg.lisp (file)

Special Variable: *print-vivid*

# \*PRINT-VIVID\*

## Description:
Controls print vividly or not.
Value type is BOOLEAN

“‘lisp
#? *PRINT-VIVID*
:be-the boolean
“‘
Initial value is T

## Affected By:
jingoh.examiner:examine

## Notes:
refered by print-object specialized by issue, jingoh.tester::diff, and jingoh.tester::diff-string.

Package

jingoh.tester

Source

report.lisp (file)

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 boolean
“‘
Initial value is NIL

## Affected By:
none

## Notes:

Package

jingoh.reader

Source

reader.lisp (file)

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 boolean
“‘
Initial value is NIL

## Affected By:
none

## Notes:

Package

jingoh.reader

Source

reader.lisp (file)

Special Variable: *verbose*

# \*VERBOSE\*

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

“‘lisp
#? *VERBOSE*
:be-the (mod 3)
“‘
Initial value is 2

## Affected By:
EXAMINE

## Notes:

Package

jingoh.examiner

Source

examine.lisp (file)


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

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 (file)

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
“‘
To test debugger is invoked or not, use :invokes-debugger

“‘lisp
#?(? (invoke-debugger (make-condition ’error)) :invokes-debugger ERROR)
=> NIL
“‘
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))
(map-requirements #’check))
=> (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:

Package

jingoh.tester

Source

tester.lisp (file)

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 check-bnf:syntax-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 (file)

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 check-bnf:syntax-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 (file)

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 (file)

Macro: do-requirements (VAR &optional SUBJECT-DESIGNATOR ORG RETURN-FORM) &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 error is signaled.

“‘lisp
#?(do-requirements (req t 0)
(princ req))
:signals NOT-ORG
, :lazy
“‘
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 (file)

Macro: enable &optional CHAR

# ENABLE

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

“‘lisp
#?(let ((*readtable* (copy-readtable nil)))
(values (get-dispatch-macro-character #\# #\?) (enable)
(get-dispatch-macro-character #\# #\?))) :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 (file)

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 check-bnf:syntax-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 (file)

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 check-bnf:syntax-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 (file)

Macro: setup NAME
Package

jingoh

Source

package.lisp (file)

Macro: with-examiner-context FORM
Package

jingoh.examiner

Source

examine.lisp (file)

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

jingoh.tester

Source

miscellaneous.lisp (file)


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

5.1.3 Compiler macros

Compiler Macro: do-requirements (VAR &optional SUBJECT-DESIGNATOR ORG RETURN) &body BODY
Package

jingoh.org

Source

miscellaneous.lisp (file)


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

5.1.4 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:

Package

jingoh.reader

Source

reader.lisp (file)

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 type-error
“‘
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 (file)

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 error.

“‘lisp
#?(add-requirement "subject" 0)
:signals TYPE-ERROR
“‘
requirement := any lisp object. unspecified.
org := org, otherwise error.

“‘lisp
#?(add-requirement ’subject :value 0)
:signals NOT-ORG
“‘
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 (file)

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 (file)

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 (file)

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 (file)

Function: 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 (file)

Writer

(setf condition-issue-message) (function)

Function: (setf condition-issue-message) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Reader

condition-issue-message (function)

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 (file)

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 (file)

Function: delete-option-key KEY

# DELETE-OPTION-KEY

## Description:

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

## Arguments and Values:
key := T

“‘lisp
#?(delete-option-key "not keyword")
=> 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 (file)

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 (file)

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 error

“‘lisp
#?(delete-subject ’subject 0)
:signals TYPE-ERROR
“‘
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:

Package

jingoh.org

Source

deforg.lisp (file)

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)
=> CAR
“‘

“‘lisp
#?(encallable #’car t)
:be-the function
“‘

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

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

“‘lisp
#?(encallable (lambda (x) (print x)))
:be-the (cons (eql lambda)T)
“‘

### 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 (file)

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 (file)

Function: examine ORG &key SUBJECT (ON-FAILS *ON-FAILS*) (VERBOSE *VERBOSE*) (VIVID *PRINT-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 missing-org
“‘
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 (file)

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)
=> 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 (file)

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 0 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 (file)

Function: 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 (file)

Writer

(setf issue-actual) (function)

Function: (setf issue-actual) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Reader

issue-actual (function)

Function: 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 (file)

Writer

(setf issue-expected) (function)

Function: (setf issue-expected) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Reader

issue-expected (function)

Function: 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 (file)

Writer

(setf issue-form) (function)

Function: (setf issue-form) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Reader

issue-form (function)

Function: 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 (file)

Writer

(setf issue-line) (function)

Function: (setf issue-line) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Reader

issue-line (function)

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 (file)

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 (file)

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 (file)

Function: make-org &key (NAME NAME) (PACKAGE PACKAGE) (CURRENT-SUBJECTS CURRENT-SUBJECTS) (OPTIONS OPTIONS) (SPECIFICATIONS 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 (file)

Function: map-requirements FUNCTION &optional SUBJECT ORG

# MAP-REQUIREMENTS

## Description:
Apply FUNCTION and collect its return value.

“‘lisp
#?(map-requirements #’1+)
=> (1 2)
, :test
“‘

### syntax
(MAP-REQUIREMENTS function &optional (subject t) (org \*org\*)) => result

## Arguments and Values:
function := (function(requirement)T)
subject := subject designator, described later.
org := org, otherwise error.

“‘lisp
#?(map-requirements #’1+ t 0)
:signals NOT-ORG
“‘
result := list

## Affected By:
*org* when ORG is not specified.
Org curret subject when subject is not specified.

## Side-Effects:
none
Notes:

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

“‘lisp
#?(map-requirements #’1+ :no-such-subject)
:signals MISSING-SUBJECT
“‘

Package

jingoh.org

Source

miscellaneous.lisp (file)

Function: mismatch-sexp ACTUAL EXPECTED

# MISMATCH-SEXP

## Description:
When sexp is not syntactically equal, markup such diffs.

“‘lisp
#?(prin1 (mismatch-sexp :foo :bar))
:outputs #.(cl-ansi-text:red ":FOO")
“‘

### syntax
(MISMATCH-SEXP actual expected)
=> result

## Arguments and Values:
actual := form
expected := form
result := form which may be markuped.
*NOTE!* - markuped object is diff object. Do not confused.

“‘lisp
#?(mismatch-sexp :foo :bar)
:be-the jingoh.tester::diff
“‘

## Affected By:
‘*print-vivid*‘ ‘jingoh.tester::*color-hook*‘
when ‘*print-vivid*‘ is nil, printed notation is not colored.

“‘lisp
#?(let ((*print-vivid* nil))
(prin1 (mismatch-sexp :foo :bar)))
:outputs ":FOO"
“‘

“‘lisp
#?(let ((*print-vivid* nil))
(princ (mismatch-sexp "foo" "foobar")))
:outputs "\"foo\""
“‘

## Side-Effects:
none

## Notes:
For debug use.
Like SEXP=, this handle uninterned symbol in expected as variable.

“‘lisp
#?(mismatch-sexp ’#:var ’hoge)
=> #:var
, :test
“‘

## Exceptional-Situations:

## string-output tests
When actual shorter than expected, string ":NULL" is added last.

“‘lisp
#?(let ((*color-hook* #’identity)) ; without coloring.
(prin1 (mismatch-sexp "foo" "fooo")))
:outputs "\"foo:NULL\""
“‘
when actual longer than expected, such part is printed with coloring.

“‘lisp
#?(let ((*color-hook* (constantly " instead of coloring")))
(prin1 (mismatch-sexp "foobar" "foo")))
:outputs "\"foo instead of coloring\""
“‘

“‘lisp
#?(let ((*color-hook* (constantly "instead of coloring")))
(prin1 (mismatch-sexp "foo" "bar")))
:outputs "\"instead of coloring\""
“‘

## Examples.

“‘lisp
#?(let ((*print-vivid* nil))
(prin1(mismatch-sexp #2A() #2A((1 2) (3 4)))))
:outputs #.(prin1-to-string’(:DIFFERENT-DIMENSIONS :EXPECTED (2 2) :ACTUAL (0 0) #2A())) , :test
“‘

Package

jingoh.tester

Source

report.lisp (file)

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 (file)

Function: 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 error.

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org

Source

org.lisp (file)

Writer

(setf org-current-subjects) (function)

Function: (setf org-current-subjects) VALUE INSTANCE
Package

jingoh.org

Source

org.lisp (file)

Reader

org-current-subjects (function)

Function: 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 error.

“‘lisp
#?(org-name 0)
:signals TYPE-ERROR
, :lazy
“‘
result := symbol represents org name.

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org

Source

org.lisp (file)

Function: 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 error.

“‘lisp
#?(org-options 0)
:signals TYPE-ERROR
, :lazy
“‘
result := list which includes options

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org

Source

org.lisp (file)

Writer

(setf org-options) (function)

Function: (setf org-options) VALUE INSTANCE
Package

jingoh.org

Source

org.lisp (file)

Reader

org-options (function)

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 (file)

Function: 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 error.

“‘lisp
#?(org-package 0) :signals TYPE-ERROR
, :lazy
“‘
result := package

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org

Source

org.lisp (file)

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 error.

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org

Source

miscellaneous.lisp (file)

Function: 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 error.

“‘lisp
#?(org-specifications 0)
:signals TYPE-ERROR
, :lazy
“‘
result := vector which includes specifications.

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org

Source

org.lisp (file)

Writer

(setf org-specifications) (function)

Function: (setf org-specifications) VALUE INSTANCE
Package

jingoh.org

Source

org.lisp (file)

Reader

org-specifications (function)

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 error.

“‘lisp
#?(register-org 0 (make-org))
:signals TYPE-ERROR
, :lazy
“‘
org := Org, otherwise error.

“‘lisp
#?(register-org :hoge 0)
:signals TYPE-ERROR
, :lazy
“‘
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 (file)

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 (file)

Function: requirement-form REQUIREMENT
Package

jingoh.tester

Source

tester.lisp (file)

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 (file)

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 (file)

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 (file)

Function: 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 (file)

Writer

(setf test-issue-test) (function)

Function: (setf test-issue-test) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Reader

test-issue-test (function)

Function: the-push-instance-form PLACE TYPE TEST-FORM EXPECTED ACTUAL LINE &rest OPTIONS

# THE-PUSH-INSTANCE-FORM

## Description:
helper for writing make-requirement.

“‘lisp
#?(the-push-instance-form 0 1 2 3 4 5 6)
=> (push (make-instance ’1 :form 2 :expected ’3 :actual 4 :line 5 6)
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 (file)

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
:message (princ-to-string condition))
0))
(error (condition)
(push (make-instance ’error-was-signaled :form ’1 :expected ’2 :actual condition :line nil
:message (princ-to-string condition))
0)))
(unless (string= "" output)
(push (make-instance ’unexpected-output :form ’1 :expected ’""
:actual output :line 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 (file)

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 (file)

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 (file)

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 (file)

Function: 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 (file)

Writer

(setf unsatisfied-clause-args) (function)

Function: (setf unsatisfied-clause-args) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Reader

unsatisfied-clause-args (function)

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 (file)

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 (file)

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 (file)


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

5.1.5 Generic functions

Generic Function: 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))
(API (CLOS::OBJECT NOT-ORG))

## Arguments and Values:
object := (or missing not-org) result := symbol

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org

Methods
Method: api (CONDITION missing)
Source

conditions.lisp (file)

Method: api (CONDITION not-org)
Source

conditions.lisp (file)

Generic Function: args CONDITION
Package

jingoh.tester

Methods
Method: args (CONDITION unsatisfied)
Source

tester.lisp (file)

Generic Function: 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
Method: datum (CONDITION missing)
Source

conditions.lisp (file)

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 (file)

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 =>)) (EXPECTED (eql implementation-dependent)) &rest PARAMETERS
Method: make-requirement TEST-FORM (KEY (eql =>)) (EXPECTED (eql 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 =>)) EXPECTED &rest PARAMETERS

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

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 (file)

Direct superclasses

simple-error (condition)

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 (file)

Direct superclasses

error (condition)

Direct subclasses
Direct methods
Direct slots
Slot: api
Initargs

:api

Initform

(quote nil)

Readers

api (generic function)

Slot: datum
Initargs

:datum

Initform

(quote nil)

Readers

datum (generic function)

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 (file)

Direct superclasses

missing (condition)

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 (file)

Direct superclasses

missing (condition)

Condition: not-org ()

# NOT-ORG

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

## Effective Slots:
API [Type] SYMBOL
[READER] api
Which API got not org value.
$DATUM [Type] T
[READER] type-error-datum
$EXPECTED-TYPE [Type] T
[READER] type-error-expected-type

## Notes:

Package

jingoh.org

Source

conditions.lisp (file)

Direct superclasses

type-error (condition)

Direct methods

api (method)

Direct slots
Slot: api
Initargs

:api

Readers

api (generic function)

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 (file)

Direct superclasses
  • program-error (condition)
  • simple-error (condition)

Next: , Previous: , Up: Exported definitions   [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 (file)

Direct superclasses

issue (structure)

Direct subclasses
Direct slots
Slot: message
Readers

condition-issue-message (function)

Writers

(setf condition-issue-message) (function)

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 (file)

Direct superclasses

condition-issue (structure)

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 (file)

Direct superclasses

condition-issue (structure)

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 (file)

Direct superclasses

structure-object (structure)

Direct subclasses
Direct methods

print-object (method)

Direct slots
Slot: form
Readers

issue-form (function)

Writers

(setf issue-form) (function)

Slot: expected
Readers

issue-expected (function)

Writers

(setf issue-expected) (function)

Slot: actual
Readers

issue-actual (function)

Writers

(setf issue-actual) (function)

Slot: line
Readers

issue-line (function)

Writers

(setf issue-line) (function)

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 (file)

Direct superclasses

test-issue (structure)

Structure: jingoh-internal-issue ()
Package

jingoh.tester

Source

report.lisp (file)

Direct superclasses

condition-issue (structure)

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 (file)

Direct superclasses

issue (structure)

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 (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots
Slot: name
Type

symbol

Readers

org-name (function)

Writers

(setf org-name) (function)

Slot: package
Type

package

Initform

*package*

Readers

org-package (function)

Writers

(setf org-package) (function)

Slot: current-subjects
Type

cons

Initform

(sb-int:quasiquote (nil))

Readers

org-current-subjects (function)

Writers

(setf org-current-subjects) (function)

Slot: options
Type

list

Readers

org-options (function)

Writers

(setf org-options) (function)

Slot: specifications
Type

vector

Initform

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

Readers

org-specifications (function)

Writers

(setf org-specifications) (function)

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 (file)

Direct superclasses

issue (structure)

Direct subclasses
Direct slots
Slot: test
Readers

test-issue-test (function)

Writers

(setf test-issue-test) (function)

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 (file)

Direct superclasses

issue (structure)

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 (file)

Direct superclasses

issue (structure)

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 (file)

Direct superclasses

condition-issue (structure)

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 (file)

Direct superclasses

issue (structure)

Direct methods

print-object (method)

Direct slots
Slot: args
Readers

unsatisfied-clause-args (function)

Writers

(setf unsatisfied-clause-args) (function)

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 (file)

Direct superclasses

condition-issue (structure)

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 (file)

Direct superclasses

test-issue (structure)


Previous: , Up: Exported definitions   [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 (file)

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 (file)


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

5.2 Internal definitions


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

5.2.1 Special variables

Special Variable: *color-hook*
Package

jingoh.tester

Source

report.lisp (file)

Special Variable: *dispatch-macro-character*
Package

jingoh.reader

Source

reader.lisp (file)

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

jingoh.reader

Source

reader.lisp (file)

Special Variable: *line*
Package

jingoh.reader

Source

reader.lisp (file)

Special Variable: *line-pos*
Package

jingoh.reader

Source

reader.lisp (file)

Special Variable: *lines*
Package

jingoh.reader

Source

reader.lisp (file)

Special Variable: *option-keys*
Package

jingoh.org

Source

org.lisp (file)

Special Variable: *orgs*
Package

jingoh.org

Source

deforg.lisp (file)

Special Variable: *requirement-form*

Previous test form. Debug use.

Package

jingoh.examiner

Source

examine.lisp (file)


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

5.2.2 Functions

Function: #?counter STREAM CHARACTER NUMBER
Package

jingoh.reader

Source

reader.lisp (file)

Function: #?reader-body STREAM NUMBER
Package

jingoh.reader

Source

reader.lisp (file)

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 (file)

Function: break-on-fails RESULT
Package

jingoh.examiner

Source

examine.lisp (file)

Function: break-on-finish &optional ISSUES
Package

jingoh.examiner

Source

examine.lisp (file)

Function: collect-spec-lines PATHNAME
Package

jingoh.reader

Source

reader.lisp (file)

Function: condition-issue-actual INSTANCE
Function: (setf condition-issue-actual) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: condition-issue-expected INSTANCE
Function: (setf condition-issue-expected) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: condition-issue-form INSTANCE
Function: (setf condition-issue-form) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: condition-issue-line INSTANCE
Function: (setf condition-issue-line) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: copy-condition-issue INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: copy-debugger-was-invoked INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: copy-diff INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: copy-diff-comparable INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: copy-error-was-signaled INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: copy-issue INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: copy-issue-of-multiple-values INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: copy-jingoh-internal-issue INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: copy-missing-restarts INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: copy-pathname-diff INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: copy-string-diff INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: copy-test-issue INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: copy-unexpected-output INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: copy-unexpected-success INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: copy-unmatch-condition INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: copy-unsatisfied-clause INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: copy-warning-was-signaled INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: copy-wrong-format INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: debugger-was-invoked-actual INSTANCE
Function: (setf debugger-was-invoked-actual) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: debugger-was-invoked-expected INSTANCE
Function: (setf debugger-was-invoked-expected) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: debugger-was-invoked-form INSTANCE
Function: (setf debugger-was-invoked-form) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: debugger-was-invoked-line INSTANCE
Function: (setf debugger-was-invoked-line) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: debugger-was-invoked-message INSTANCE
Function: (setf debugger-was-invoked-message) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: diff-comparable-object INSTANCE
Function: (setf diff-comparable-object) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: diff-comparable-origin INSTANCE
Function: (setf diff-comparable-origin) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: diff-comparable-p OBJECT
Package

jingoh.tester

Source

report.lisp (file)

Function: diff-object INSTANCE
Function: (setf diff-object) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: diff-p OBJECT
Package

jingoh.tester

Source

report.lisp (file)

Function: error-was-signaled-actual INSTANCE
Function: (setf error-was-signaled-actual) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: error-was-signaled-expected INSTANCE
Function: (setf error-was-signaled-expected) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: error-was-signaled-form INSTANCE
Function: (setf error-was-signaled-form) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: error-was-signaled-line INSTANCE
Function: (setf error-was-signaled-line) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: error-was-signaled-message INSTANCE
Function: (setf error-was-signaled-message) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: find-subject SUBJECT &optional ORG
Package

jingoh.org

Source

miscellaneous.lisp (file)

Function: function-designator-p SYMBOL
Package

jingoh.tester

Source

miscellaneous.lisp (file)

Function: ignore-signals TYPE PARAMS
Package

jingoh.tester

Source

miscellaneous.lisp (file)

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

jingoh.tester

Source

report.lisp (file)

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

jingoh.tester

Source

report.lisp (file)

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

jingoh.tester

Source

report.lisp (file)

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

jingoh.tester

Source

report.lisp (file)

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

jingoh.tester

Source

report.lisp (file)

Function: jingoh-internal-issue-actual INSTANCE
Function: (setf jingoh-internal-issue-actual) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: jingoh-internal-issue-expected INSTANCE
Function: (setf jingoh-internal-issue-expected) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: jingoh-internal-issue-form INSTANCE
Function: (setf jingoh-internal-issue-form) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: jingoh-internal-issue-line INSTANCE
Function: (setf jingoh-internal-issue-line) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: jingoh-internal-issue-message INSTANCE
Function: (setf jingoh-internal-issue-message) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: jingoh-internal-issue-p OBJECT
Package

jingoh.tester

Source

report.lisp (file)

Function: line-comment STREAM CHARACTER
Package

jingoh.reader

Source

reader.lisp (file)

Function: line-counter STREAM CHARACTER
Package

jingoh.reader

Source

reader.lisp (file)

Function: make-condition-issue &key (FORM FORM) (EXPECTED EXPECTED) (ACTUAL ACTUAL) (LINE LINE) (MESSAGE MESSAGE)
Package

jingoh.tester

Source

report.lisp (file)

Function: make-debugger-was-invoked &key (FORM FORM) (EXPECTED EXPECTED) (ACTUAL ACTUAL) (LINE LINE) (MESSAGE MESSAGE)
Package

jingoh.tester

Source

report.lisp (file)

Function: make-diff-comparable &key (OBJECT OBJECT) (ORIGIN ORIGIN)
Package

jingoh.tester

Source

report.lisp (file)

Function: make-error-was-signaled &key (FORM FORM) (EXPECTED EXPECTED) (ACTUAL ACTUAL) (LINE LINE) (MESSAGE MESSAGE)
Package

jingoh.tester

Source

report.lisp (file)

Function: make-issue &key (FORM FORM) (EXPECTED EXPECTED) (ACTUAL ACTUAL) (LINE LINE)
Package

jingoh.tester

Source

report.lisp (file)

Function: make-issue-of-multiple-values &key (FORM FORM) (EXPECTED EXPECTED) (ACTUAL ACTUAL) (LINE LINE) (TEST TEST)
Package

jingoh.tester

Source

report.lisp (file)

Function: make-jingoh-internal-issue &key (FORM FORM) (EXPECTED EXPECTED) (ACTUAL ACTUAL) (LINE LINE) (MESSAGE MESSAGE)
Package

jingoh.tester

Source

report.lisp (file)

Function: make-missing-restarts &key (FORM FORM) (EXPECTED EXPECTED) (ACTUAL ACTUAL) (LINE LINE)
Package

jingoh.tester

Source

report.lisp (file)

Function: make-test-issue &key (FORM FORM) (EXPECTED EXPECTED) (ACTUAL ACTUAL) (LINE LINE) (TEST TEST)
Package

jingoh.tester

Source

report.lisp (file)

Function: make-unexpected-output &key (FORM FORM) (EXPECTED EXPECTED) (ACTUAL ACTUAL) (LINE LINE)
Package

jingoh.tester

Source

report.lisp (file)

Function: make-unexpected-success &key (FORM FORM) (EXPECTED EXPECTED) (ACTUAL ACTUAL) (LINE LINE)
Package

jingoh.tester

Source

report.lisp (file)

Function: make-unmatch-condition &key (FORM FORM) (EXPECTED EXPECTED) (ACTUAL ACTUAL) (LINE LINE) (MESSAGE MESSAGE)
Package

jingoh.tester

Source

report.lisp (file)

Function: make-unsatisfied-clause &key (FORM FORM) (EXPECTED EXPECTED) (ACTUAL ACTUAL) (LINE LINE) (ARGS ARGS)
Package

jingoh.tester

Source

report.lisp (file)

Function: make-warning-was-signaled &key (FORM FORM) (EXPECTED EXPECTED) (ACTUAL ACTUAL) (LINE LINE) (MESSAGE MESSAGE)
Package

jingoh.tester

Source

report.lisp (file)

Function: make-wrong-format &key (FORM FORM) (EXPECTED EXPECTED) (ACTUAL ACTUAL) (LINE LINE) (TEST TEST)
Package

jingoh.tester

Source

report.lisp (file)

Function: markup OBJECT
Package

jingoh.tester

Source

report.lisp (file)

Function: markup-pathname OBJECT ORIGIN
Package

jingoh.tester

Source

report.lisp (file)

Function: markup-string OBJECT ORIGIN
Package

jingoh.tester

Source

report.lisp (file)

Function: missing-restarts-actual INSTANCE
Function: (setf missing-restarts-actual) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: missing-restarts-expected INSTANCE
Function: (setf missing-restarts-expected) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: missing-restarts-form INSTANCE
Function: (setf missing-restarts-form) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: missing-restarts-line INSTANCE
Function: (setf missing-restarts-line) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: pathname-diff-object INSTANCE
Function: (setf pathname-diff-object) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: pathname-diff-origin INSTANCE
Function: (setf pathname-diff-origin) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: pathname-diff-p OBJECT
Package

jingoh.tester

Source

report.lisp (file)

Function: print-dot RESULT
Package

jingoh.examiner

Source

examine.lisp (file)

Function: print-progress SUBJECT &optional GOTO
Package

jingoh.examiner

Source

examine.lisp (file)

Function: print-requirement RESULT REQUIREMENT
Package

jingoh.examiner

Source

examine.lisp (file)

Function: print-summary ISSUES &optional *STANDARD-OUTPUT*
Package

jingoh.examiner

Source

examine.lisp (file)

Function: regex-replace ISSUE STRING
Package

jingoh.tester

Source

report.lisp (file)

Function: should-print-vivid-p ISSUE
Package

jingoh.tester

Source

report.lisp (file)

Function: slots<=obj OBJ
Package

jingoh.tester

Source

report.lisp (file)

Function: spec SUBJECT REQ &aux REQUIREMENTS
Package

jingoh.org

Source

org.lisp (file)

Function: spec-requirements INSTANCE
Function: (setf spec-requirements) VALUE INSTANCE
Package

jingoh.org

Source

org.lisp (file)

Function: spec-subject INSTANCE
Package

jingoh.org

Source

org.lisp (file)

Function: string-diff-object INSTANCE
Function: (setf string-diff-object) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: string-diff-origin INSTANCE
Function: (setf string-diff-origin) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: string-diff-p OBJECT
Package

jingoh.tester

Source

report.lisp (file)

Function: string-line-counter STREAM CHARACTER
Package

jingoh.reader

Source

reader.lisp (file)

Function: test-issue-actual INSTANCE
Function: (setf test-issue-actual) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: test-issue-expected INSTANCE
Function: (setf test-issue-expected) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: test-issue-form INSTANCE
Function: (setf test-issue-form) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: test-issue-line INSTANCE
Function: (setf test-issue-line) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: the-nil-subject-procedure ORG VAR BODY RETURN
Package

jingoh.org

Source

miscellaneous.lisp (file)

Function: the-subject-procedure VAR BODY GNAME ORG RETURN
Package

jingoh.org

Source

miscellaneous.lisp (file)

Function: unexpected-output-actual INSTANCE
Function: (setf unexpected-output-actual) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: unexpected-output-expected INSTANCE
Function: (setf unexpected-output-expected) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: unexpected-output-form INSTANCE
Function: (setf unexpected-output-form) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: unexpected-output-line INSTANCE
Function: (setf unexpected-output-line) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: unexpected-success-actual INSTANCE
Function: (setf unexpected-success-actual) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: unexpected-success-expected INSTANCE
Function: (setf unexpected-success-expected) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: unexpected-success-form INSTANCE
Function: (setf unexpected-success-form) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: unexpected-success-line INSTANCE
Function: (setf unexpected-success-line) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: unmatch-condition-actual INSTANCE
Function: (setf unmatch-condition-actual) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: unmatch-condition-expected INSTANCE
Function: (setf unmatch-condition-expected) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: unmatch-condition-form INSTANCE
Function: (setf unmatch-condition-form) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: unmatch-condition-line INSTANCE
Function: (setf unmatch-condition-line) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: unmatch-condition-message INSTANCE
Function: (setf unmatch-condition-message) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: unsatisfied-clause-actual INSTANCE
Function: (setf unsatisfied-clause-actual) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: unsatisfied-clause-expected INSTANCE
Function: (setf unsatisfied-clause-expected) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: unsatisfied-clause-form INSTANCE
Function: (setf unsatisfied-clause-form) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: unsatisfied-clause-line INSTANCE
Function: (setf unsatisfied-clause-line) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: warning-was-signaled-actual INSTANCE
Function: (setf warning-was-signaled-actual) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: warning-was-signaled-expected INSTANCE
Function: (setf warning-was-signaled-expected) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: warning-was-signaled-form INSTANCE
Function: (setf warning-was-signaled-form) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: warning-was-signaled-line INSTANCE
Function: (setf warning-was-signaled-line) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: warning-was-signaled-message INSTANCE
Function: (setf warning-was-signaled-message) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: wrong-format-actual INSTANCE
Function: (setf wrong-format-actual) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: wrong-format-expected INSTANCE
Function: (setf wrong-format-expected) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: wrong-format-form INSTANCE
Function: (setf wrong-format-form) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: wrong-format-line INSTANCE
Function: (setf wrong-format-line) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)

Function: wrong-format-test INSTANCE
Function: (setf wrong-format-test) VALUE INSTANCE
Package

jingoh.tester

Source

report.lisp (file)


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

5.2.3 Generic functions

Generic Function: issues CONDITION
Package

jingoh.examiner

Methods
Method: issues (CONDITION break-on-finish)
Source

examine.lisp (file)

Generic Function: test-form CONDITION
Package

jingoh.tester

Methods
Method: test-form (CONDITION unsatisfied)
Source

tester.lisp (file)


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

5.2.4 Conditions

Condition: break-on-fails ()
Package

jingoh.examiner

Source

examine.lisp (file)

Direct superclasses

error (condition)

Condition: break-on-finish ()
Package

jingoh.examiner

Source

examine.lisp (file)

Direct superclasses

error (condition)

Direct methods
  • print-object (method)
  • issues (method)
Direct slots
Slot: issues
Initargs

:issues

Readers

issues (generic function)

Condition: unsatisfied ()
Package

jingoh.tester

Source

tester.lisp (file)

Direct superclasses

error (condition)

Direct methods
Direct slots
Slot: test-form
Initargs

:test-form

Readers

test-form (generic function)

Slot: args
Initargs

:args

Initform

(quote nil)

Readers

args (generic function)


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

5.2.5 Structures

Structure: diff ()
Package

jingoh.tester

Source

report.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses

diff-comparable (structure)

Direct methods

print-object (method)

Direct slots
Slot: object
Readers

diff-object (function)

Writers

(setf diff-object) (function)

Structure: diff-comparable ()
Package

jingoh.tester

Source

report.lisp (file)

Direct superclasses

diff (structure)

Direct subclasses
Direct slots
Slot: origin
Readers

diff-comparable-origin (function)

Writers

(setf diff-comparable-origin) (function)

Structure: pathname-diff ()
Package

jingoh.tester

Source

report.lisp (file)

Direct superclasses

diff-comparable (structure)

Direct methods

print-object (method)

Structure: spec ()
Package

jingoh.org

Source

org.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots
Slot: subject
Type

symbol

Readers

spec-subject (function)

Writers

(setf spec-subject) (function)

Slot: requirements
Type

vector

Initform

#()

Readers

spec-requirements (function)

Writers

(setf spec-requirements) (function)

Structure: string-diff ()
Package

jingoh.tester

Source

report.lisp (file)

Direct superclasses

diff-comparable (structure)

Direct methods

print-object (method)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   J   L  
Index Entry  Section

F
File, Lisp, jingoh.asd: The jingoh․asd file
File, Lisp, jingoh.examiner.asd: The jingoh․examiner․asd file
File, Lisp, jingoh.examiner/examine.lisp: The jingoh․examiner/examine․lisp file
File, Lisp, jingoh.org.asd: The jingoh․org․asd file
File, Lisp, jingoh.org/conditions.lisp: The jingoh․org/conditions․lisp file
File, Lisp, jingoh.org/deforg.lisp: The jingoh․org/deforg․lisp file
File, Lisp, jingoh.org/miscellaneous.lisp: The jingoh․org/miscellaneous․lisp file
File, Lisp, jingoh.org/org.lisp: The jingoh․org/org․lisp file
File, Lisp, jingoh.org/package.lisp: The jingoh․org/package․lisp file
File, Lisp, jingoh.reader.asd: The jingoh․reader․asd file
File, Lisp, jingoh.reader/reader.lisp: The jingoh․reader/reader․lisp file
File, Lisp, jingoh.tester.asd: The jingoh․tester․asd file
File, Lisp, jingoh.tester/miscellaneous.lisp: The jingoh․tester/miscellaneous․lisp file
File, Lisp, jingoh.tester/package.lisp: The jingoh․tester/package․lisp file
File, Lisp, jingoh.tester/report.lisp: The jingoh․tester/report․lisp file
File, Lisp, jingoh.tester/tester.lisp: The jingoh․tester/tester․lisp file
File, Lisp, jingoh/package.lisp: The jingoh/package․lisp file

J
jingoh.asd: The jingoh․asd file
jingoh.examiner.asd: The jingoh․examiner․asd file
jingoh.examiner/examine.lisp: The jingoh․examiner/examine․lisp file
jingoh.org.asd: The jingoh․org․asd file
jingoh.org/conditions.lisp: The jingoh․org/conditions․lisp file
jingoh.org/deforg.lisp: The jingoh․org/deforg․lisp file
jingoh.org/miscellaneous.lisp: The jingoh․org/miscellaneous․lisp file
jingoh.org/org.lisp: The jingoh․org/org․lisp file
jingoh.org/package.lisp: The jingoh․org/package․lisp file
jingoh.reader.asd: The jingoh․reader․asd file
jingoh.reader/reader.lisp: The jingoh․reader/reader․lisp file
jingoh.tester.asd: The jingoh․tester․asd file
jingoh.tester/miscellaneous.lisp: The jingoh․tester/miscellaneous․lisp file
jingoh.tester/package.lisp: The jingoh․tester/package․lisp file
jingoh.tester/report.lisp: The jingoh․tester/report․lisp file
jingoh.tester/tester.lisp: The jingoh․tester/tester․lisp file
jingoh/package.lisp: The jingoh/package․lisp file

L
Lisp File, jingoh.asd: The jingoh․asd file
Lisp File, jingoh.examiner.asd: The jingoh․examiner․asd file
Lisp File, jingoh.examiner/examine.lisp: The jingoh․examiner/examine․lisp file
Lisp File, jingoh.org.asd: The jingoh․org․asd file
Lisp File, jingoh.org/conditions.lisp: The jingoh․org/conditions․lisp file
Lisp File, jingoh.org/deforg.lisp: The jingoh․org/deforg․lisp file
Lisp File, jingoh.org/miscellaneous.lisp: The jingoh․org/miscellaneous․lisp file
Lisp File, jingoh.org/org.lisp: The jingoh․org/org․lisp file
Lisp File, jingoh.org/package.lisp: The jingoh․org/package․lisp file
Lisp File, jingoh.reader.asd: The jingoh․reader․asd file
Lisp File, jingoh.reader/reader.lisp: The jingoh․reader/reader․lisp file
Lisp File, jingoh.tester.asd: The jingoh․tester․asd file
Lisp File, jingoh.tester/miscellaneous.lisp: The jingoh․tester/miscellaneous․lisp file
Lisp File, jingoh.tester/package.lisp: The jingoh․tester/package․lisp file
Lisp File, jingoh.tester/report.lisp: The jingoh․tester/report․lisp file
Lisp File, jingoh.tester/tester.lisp: The jingoh․tester/tester․lisp file
Lisp File, jingoh/package.lisp: The jingoh/package․lisp file

Jump to:   F   J   L  

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   W  
Index Entry  Section

#
#?counter: Internal functions
#?reader: Exported functions
#?reader-body: Internal functions

&
&: Exported macros

(
(setf condition-issue-actual): Internal functions
(setf condition-issue-expected): Internal functions
(setf condition-issue-form): Internal functions
(setf condition-issue-line): Internal functions
(setf condition-issue-message): Exported functions
(setf debugger-was-invoked-actual): Internal functions
(setf debugger-was-invoked-expected): Internal functions
(setf debugger-was-invoked-form): Internal functions
(setf debugger-was-invoked-line): Internal functions
(setf debugger-was-invoked-message): Internal functions
(setf diff-comparable-object): Internal functions
(setf diff-comparable-origin): Internal functions
(setf diff-object): Internal functions
(setf error-was-signaled-actual): Internal functions
(setf error-was-signaled-expected): Internal functions
(setf error-was-signaled-form): Internal functions
(setf error-was-signaled-line): Internal functions
(setf error-was-signaled-message): Internal functions
(setf issue-actual): Exported functions
(setf issue-expected): Exported functions
(setf issue-form): Exported functions
(setf issue-line): Exported functions
(setf issue-of-multiple-values-actual): Internal functions
(setf issue-of-multiple-values-expected): Internal functions
(setf issue-of-multiple-values-form): Internal functions
(setf issue-of-multiple-values-line): Internal functions
(setf issue-of-multiple-values-test): Internal functions
(setf jingoh-internal-issue-actual): Internal functions
(setf jingoh-internal-issue-expected): Internal functions
(setf jingoh-internal-issue-form): Internal functions
(setf jingoh-internal-issue-line): Internal functions
(setf jingoh-internal-issue-message): Internal functions
(setf missing-restarts-actual): Internal functions
(setf missing-restarts-expected): Internal functions
(setf missing-restarts-form): Internal functions
(setf missing-restarts-line): Internal functions
(setf org-current-subjects): Exported functions
(setf org-options): Exported functions
(setf org-specifications): Exported functions
(setf pathname-diff-object): Internal functions
(setf pathname-diff-origin): Internal functions
(setf spec-requirements): Internal functions
(setf string-diff-object): Internal functions
(setf string-diff-origin): Internal functions
(setf test-issue-actual): Internal functions
(setf test-issue-expected): Internal functions
(setf test-issue-form): Internal functions
(setf test-issue-line): Internal functions
(setf test-issue-test): Exported functions
(setf unexpected-output-actual): Internal functions
(setf unexpected-output-expected): Internal functions
(setf unexpected-output-form): Internal functions
(setf unexpected-output-line): Internal functions
(setf unexpected-success-actual): Internal functions
(setf unexpected-success-expected): Internal functions
(setf unexpected-success-form): Internal functions
(setf unexpected-success-line): Internal functions
(setf unmatch-condition-actual): Internal functions
(setf unmatch-condition-expected): Internal functions
(setf unmatch-condition-form): Internal functions
(setf unmatch-condition-line): Internal functions
(setf unmatch-condition-message): Internal functions
(setf unsatisfied-clause-actual): Internal functions
(setf unsatisfied-clause-args): Exported functions
(setf unsatisfied-clause-expected): Internal functions
(setf unsatisfied-clause-form): Internal functions
(setf unsatisfied-clause-line): Internal functions
(setf warning-was-signaled-actual): Internal functions
(setf warning-was-signaled-expected): Internal functions
(setf warning-was-signaled-form): Internal functions
(setf warning-was-signaled-line): Internal functions
(setf warning-was-signaled-message): Internal functions
(setf wrong-format-actual): Internal functions
(setf wrong-format-expected): Internal functions
(setf wrong-format-form): Internal functions
(setf wrong-format-line): Internal functions
(setf wrong-format-test): Internal functions

?
?: Exported macros

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

B
block-comment: Internal functions
break-on-fails: Internal functions
break-on-finish: Internal functions

C
canonicalize: Exported functions
check: Exported functions
clear-option-keys: Exported functions
collect-spec-lines: Internal functions
common-requirements-about: Exported macros
Compiler Macro, do-requirements: Exported compiler macros
condition-issue-actual: Internal functions
condition-issue-expected: Internal functions
condition-issue-form: Internal functions
condition-issue-line: Internal functions
condition-issue-message: Exported functions
condition-issue-p: Exported functions
copy-condition-issue: Internal functions
copy-debugger-was-invoked: Internal functions
copy-diff: Internal functions
copy-diff-comparable: Internal functions
copy-error-was-signaled: Internal functions
copy-issue: Internal functions
copy-issue-of-multiple-values: Internal functions
copy-jingoh-internal-issue: Internal functions
copy-missing-restarts: Internal functions
copy-pathname-diff: Internal functions
copy-string-diff: Internal functions
copy-test-issue: Internal functions
copy-unexpected-output: Internal functions
copy-unexpected-success: Internal functions
copy-unmatch-condition: Internal functions
copy-unsatisfied-clause: Internal functions
copy-warning-was-signaled: Internal functions
copy-wrong-format: Internal functions

D
datum: Exported generic functions
datum: Exported generic functions
debugger-was-invoked-actual: Internal functions
debugger-was-invoked-expected: Internal functions
debugger-was-invoked-form: Internal functions
debugger-was-invoked-line: Internal functions
debugger-was-invoked-message: Internal functions
debugger-was-invoked-p: Exported functions
deforg: Exported macros
defspec: Exported macros
delete-option-key: Exported functions
delete-org: Exported functions
delete-subject: Exported functions
diff-comparable-object: Internal functions
diff-comparable-origin: Internal functions
diff-comparable-p: Internal functions
diff-object: Internal functions
diff-p: Internal functions
do-requirements: Exported macros
do-requirements: Exported compiler macros

E
enable: Exported macros
encallable: Exported functions
error-was-signaled-actual: Internal functions
error-was-signaled-expected: Internal functions
error-was-signaled-form: Internal functions
error-was-signaled-line: Internal functions
error-was-signaled-message: Internal functions
error-was-signaled-p: Exported functions
examine: Exported functions

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

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

I
ignore-signals: Internal functions
in-org: Exported macros
issue-actual: Exported functions
issue-expected: Exported functions
issue-form: Exported functions
issue-line: Exported functions
issue-of-multiple-values-actual: Internal functions
issue-of-multiple-values-expected: Internal functions
issue-of-multiple-values-form: Internal functions
issue-of-multiple-values-line: Internal functions
issue-of-multiple-values-p: Exported functions
issue-of-multiple-values-test: Internal functions
issue-p: Exported functions
issues: Internal generic functions
issues: Internal generic functions

J
jingoh-internal-issue-actual: Internal functions
jingoh-internal-issue-expected: Internal functions
jingoh-internal-issue-form: Internal functions
jingoh-internal-issue-line: Internal functions
jingoh-internal-issue-message: Internal functions
jingoh-internal-issue-p: Internal functions

L
line-comment: Internal functions
line-counter: Internal functions
list-all-option-keys: Exported functions

M
Macro, &: Exported macros
Macro, ?: Exported macros
Macro, common-requirements-about: Exported macros
Macro, deforg: Exported macros
Macro, defspec: Exported macros
Macro, do-requirements: Exported macros
Macro, enable: Exported macros
Macro, in-org: Exported macros
Macro, requirements-about: Exported macros
Macro, setup: Exported macros
Macro, with-examiner-context: Exported macros
Macro, with-integrated-output-stream: Exported macros
make-condition-issue: Internal functions
make-debugger-was-invoked: Internal functions
make-diff-comparable: Internal functions
make-error-was-signaled: Internal functions
make-issue: Internal functions
make-issue-of-multiple-values: Internal functions
make-jingoh-internal-issue: Internal functions
make-missing-restarts: Internal functions
make-org: Exported functions
make-requirement: Exported generic functions
make-requirement: Exported generic functions
make-requirement: Exported generic functions
make-requirement: Exported generic functions
make-requirement: Exported generic functions
make-requirement: Exported generic functions
make-requirement: Exported generic functions
make-requirement: Exported generic functions
make-requirement: Exported generic functions
make-requirement: Exported generic functions
make-requirement: Exported generic functions
make-requirement: Exported generic functions
make-requirement: Exported generic functions
make-requirement: Exported generic functions
make-requirement: Exported generic functions
make-requirement: Exported generic functions
make-test-issue: Internal functions
make-unexpected-output: Internal functions
make-unexpected-success: Internal functions
make-unmatch-condition: Internal functions
make-unsatisfied-clause: Internal functions
make-warning-was-signaled: Internal functions
make-wrong-format: Internal functions
map-requirements: Exported functions
markup: Internal functions
markup-pathname: Internal functions
markup-string: Internal functions
Method, api: Exported generic functions
Method, api: Exported generic functions
Method, args: Exported generic functions
Method, datum: Exported generic functions
Method, issues: Internal generic functions
Method, make-requirement: Exported generic functions
Method, make-requirement: Exported generic functions
Method, make-requirement: Exported generic functions
Method, make-requirement: Exported generic functions
Method, make-requirement: Exported generic functions
Method, make-requirement: Exported generic functions
Method, make-requirement: Exported generic functions
Method, make-requirement: Exported generic functions
Method, make-requirement: Exported generic functions
Method, make-requirement: Exported generic functions
Method, make-requirement: Exported generic functions
Method, make-requirement: Exported generic functions
Method, make-requirement: Exported generic functions
Method, make-requirement: Exported generic functions
Method, make-requirement: Exported generic functions
Method, test-form: Internal generic functions
mismatch-sexp: Exported functions
missing-restarts-actual: Internal functions
missing-restarts-expected: Internal functions
missing-restarts-form: Internal functions
missing-restarts-line: Internal functions
missing-restarts-p: Exported functions

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

P
pathname-diff-object: Internal functions
pathname-diff-origin: Internal functions
pathname-diff-p: Internal functions
print-dot: Internal functions
print-progress: Internal functions
print-requirement: Internal functions
print-summary: Internal functions

R
regex-replace: Internal functions
register-org: Exported functions
replace-macro-character: Exported functions
requirement-form: Exported functions
requirements-about: Exported macros
reserved-keywords: Exported functions

S
setup: Exported macros
sexp=: Exported functions
should-print-vivid-p: Internal functions
slots<=obj: Internal functions
spec: Internal functions
spec-requirements: Internal functions
spec-subject: Internal functions
string-diff-object: Internal functions
string-diff-origin: Internal functions
string-diff-p: Internal functions
string-line-counter: Internal functions

T
test-form: Internal generic functions
test-form: Internal generic functions
test-issue-actual: Internal functions
test-issue-expected: Internal functions
test-issue-form: Internal functions
test-issue-line: Internal functions
test-issue-p: Exported functions
test-issue-test: Exported functions
the-nil-subject-procedure: Internal functions
the-push-instance-form: Exported functions
the-standard-handling-form: Exported functions
the-subject-procedure: Internal functions

U
unexpected-output-actual: Internal functions
unexpected-output-expected: Internal functions
unexpected-output-form: Internal functions
unexpected-output-line: Internal functions
unexpected-output-p: Exported functions
unexpected-success-actual: Internal functions
unexpected-success-expected: Internal functions
unexpected-success-form: Internal functions
unexpected-success-line: Internal functions
unexpected-success-p: Exported functions
unmatch-condition-actual: Internal functions
unmatch-condition-expected: Internal functions
unmatch-condition-form: Internal functions
unmatch-condition-line: Internal functions
unmatch-condition-message: Internal functions
unmatch-condition-p: Exported functions
unsatisfied-clause-actual: Internal functions
unsatisfied-clause-args: Exported functions
unsatisfied-clause-expected: Internal functions
unsatisfied-clause-form: Internal functions
unsatisfied-clause-line: Internal functions
unsatisfied-clause-p: Exported functions

W
warning-was-signaled-actual: Internal functions
warning-was-signaled-expected: Internal functions
warning-was-signaled-form: Internal functions
warning-was-signaled-line: Internal functions
warning-was-signaled-message: Internal functions
warning-was-signaled-p: Exported functions
with-examiner-context: Exported macros
with-integrated-output-stream: Exported macros
wrong-format-actual: Internal functions
wrong-format-expected: Internal functions
wrong-format-form: Internal functions
wrong-format-line: Internal functions
wrong-format-p: Exported functions
wrong-format-test: Internal functions

Jump to:   #   &   (   ?  
A   B   C   D   E   F   G   I   J   L   M   O   P   R   S   T   U   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*: Exported special variables
*color-hook*: Internal special variables
*dispatch-macro-character*: Internal special variables
*dispatch-macro-sub-char*: Internal special variables
*issues*: Exported special variables
*line*: Internal special variables
*line-pos*: Internal special variables
*lines*: Internal special variables
*on-fails*: Exported special variables
*option-keys*: Internal special variables
*org*: Exported special variables
*orgs*: Internal special variables
*print-vivid*: Exported special variables
*read-print*: Exported special variables
*read-verbose*: Exported special variables
*requirement-form*: Internal special variables
*verbose*: Exported special variables

A
actual: Exported structures
api: Exported conditions
api: Exported conditions
args: Exported structures
args: Internal conditions

C
current-subjects: Exported structures

D
datum: Exported conditions

E
expected: Exported structures

F
form: Exported structures

I
issues: Internal conditions

L
line: Exported structures

M
message: Exported structures

N
name: Exported structures

O
object: Internal structures
options: Exported structures
origin: Internal structures

P
package: Exported structures

R
requirements: Internal structures

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

T
test: Exported structures
test-form: Internal 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   I   J   M   N   O   P   S   T   U   W  
Index Entry  Section

B
break-on-fails: Internal conditions
break-on-finish: Internal conditions

C
Condition, break-on-fails: Internal conditions
Condition, break-on-finish: Internal conditions
Condition, macro-char-confliction: Exported conditions
Condition, missing: Exported conditions
Condition, missing-org: Exported conditions
Condition, missing-subject: Exported conditions
Condition, not-org: Exported conditions
Condition, syntax-error: Exported conditions
Condition, unsatisfied: Internal conditions
condition-issue: Exported structures

D
debugger-was-invoked: Exported structures
diff: Internal structures
diff-comparable: Internal structures

E
error-was-signaled: Exported structures

I
issue: Exported structures
issue-of-multiple-values: Exported structures

J
jingoh: The jingoh system
jingoh: The jingoh package
jingoh-internal-issue: Exported structures
jingoh.examiner: The jingoh․examiner system
jingoh.examiner: The jingoh․examiner package
jingoh.org: The jingoh․org system
jingoh.org: The jingoh․org package
jingoh.reader: The jingoh․reader system
jingoh.reader: The jingoh․reader package
jingoh.tester: The jingoh․tester system
jingoh.tester: The jingoh․tester package

M
macro-char-confliction: Exported conditions
missing: Exported conditions
missing-org: Exported conditions
missing-restarts: Exported structures
missing-subject: Exported conditions

N
not-org: Exported conditions

O
org: Exported structures
org-designator: Exported types

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
pathname-diff: Internal structures

S
spec: Internal structures
string-diff: Internal structures
Structure, condition-issue: Exported structures
Structure, debugger-was-invoked: Exported structures
Structure, diff: Internal structures
Structure, diff-comparable: Internal structures
Structure, error-was-signaled: Exported structures
Structure, issue: Exported structures
Structure, issue-of-multiple-values: Exported structures
Structure, jingoh-internal-issue: Exported structures
Structure, missing-restarts: Exported structures
Structure, org: Exported structures
Structure, pathname-diff: Internal structures
Structure, spec: Internal structures
Structure, string-diff: Internal structures
Structure, test-issue: Exported structures
Structure, unexpected-output: Exported structures
Structure, unexpected-success: Exported structures
Structure, unmatch-condition: Exported structures
Structure, unsatisfied-clause: Exported structures
Structure, warning-was-signaled: Exported structures
Structure, wrong-format: Exported structures
subject-designator: Exported types
syntax-error: Exported 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: Exported structures
Type, org-designator: Exported types
Type, subject-designator: Exported types

U
unexpected-output: Exported structures
unexpected-success: Exported structures
unmatch-condition: Exported structures
unsatisfied: Internal conditions
unsatisfied-clause: Exported structures

W
warning-was-signaled: Exported structures
wrong-format: Exported structures

Jump to:   B   C   D   E   I   J   M   N   O   P   S   T   U   W