The jingoh Reference Manual

3.1.1 jingoh/jingoh.asd

Source

jingoh.asd.

Parent Component

jingoh (system).

ASDF Systems

jingoh.

---

3.1.2 jingoh.org/jingoh.org.asd

Source

jingoh.org.asd.

Parent Component

jingoh.org (system).

ASDF Systems

jingoh.org.

---

3.1.3 jingoh.tester/jingoh.tester.asd

Source

jingoh.tester.asd.

Parent Component

jingoh.tester (system).

ASDF Systems

jingoh.tester.

---

3.1.4 jingoh.examiner/jingoh.examiner.asd

Source

jingoh.examiner.asd.

Parent Component

jingoh.examiner (system).

ASDF Systems

jingoh.examiner.

---

3.1.5 jingoh.reader/jingoh.reader.asd

Source

jingoh.reader.asd.

Parent Component

jingoh.reader (system).

ASDF Systems

jingoh.reader.

---

3.1.6 jingoh/package.lisp

Source

jingoh.asd.

Parent Component

jingoh (system).

Packages

jingoh.

Public Interface

setup (macro).

---

3.1.7 jingoh.org/package.lisp

Source

jingoh.org.asd.

Parent Component

jingoh.org (system).

Packages

jingoh.org.

---

3.1.8 jingoh.org/conditions.lisp

Dependency

package.lisp (file).

Source

jingoh.org.asd.

Parent Component

jingoh.org (system).

Public Interface

• api (reader method).
• datum (reader method).
• missing (condition).
• missing-org (condition).
• missing-subject (condition).

---

3.1.9 jingoh.org/org.lisp

Dependency

conditions.lisp (file).

Source

jingoh.org.asd.

Parent Component

jingoh.org (system).

Public Interface

• add-new-option-key (function).
• clear-option-keys (function).
• delete-option-key (function).
• find-option-key (function).
• list-all-option-keys (function).
• make-org (function).
• org (structure).
• org-current-subjects (reader).
• (setf org-current-subjects) (writer).
• org-designator (type).
• org-name (reader).
• org-options (reader).
• (setf org-options) (writer).
• org-p (function).
• org-package (reader).
• org-requirements-count (function).
• org-specifications (reader).
• (setf org-specifications) (writer).
• print-object (method).
• print-object (method).
• subject-designator (type).

Internals

• *option-keys* (special variable).
• requirement (type).
• spec (function).
• spec (structure).
• spec-requirements (reader).
• (setf spec-requirements) (writer).
• spec-subject (reader).

---

3.1.10 jingoh.org/deforg.lisp

Dependency

org.lisp (file).

Source

jingoh.org.asd.

Parent Component

jingoh.org (system).

Public Interface

• *org* (special variable).
• common-requirements-about (macro).
• deforg (macro).
• delete-org (function).
• delete-subject (function).
• find-org (function).
• in-org (macro).
• register-org (function).
• requirements-about (macro).

Internals

*orgs* (special variable).

---

3.1.11 jingoh.org/miscellaneous.lisp

Dependencies

• deforg.lisp (file).
• conditions.lisp (file).

Source

jingoh.org.asd.

Parent Component

jingoh.org (system).

Public Interface

• add-requirement (function).
• do-requirements (macro).

Internals

• <iterate-all-requirements> (function).
• <iterate-specified-subjects-requirements> (function).
• find-subject (function).

---

3.1.12 jingoh.tester/package.lisp

Source

jingoh.tester.asd.

Parent Component

jingoh.tester (system).

Packages

jingoh.tester.

---

3.1.13 jingoh.tester/report.lisp

Dependency

package.lisp (file).

Source

jingoh.tester.asd.

Parent Component

jingoh.tester (system).

Public Interface

• condition-issue (structure).
• condition-issue-message (reader).
• (setf condition-issue-message) (writer).
• condition-issue-p (function).
• debugger-was-invoked (structure).
• debugger-was-invoked-p (function).
• error-was-signaled (structure).
• error-was-signaled-p (function).
• issue (structure).
• issue-actual (reader).
• (setf issue-actual) (writer).
• issue-expected (reader).
• (setf issue-expected) (writer).
• issue-form (reader).
• (setf issue-form) (writer).
• issue-line (reader).
• (setf issue-line) (writer).
• issue-of-multiple-values (structure).
• issue-of-multiple-values-p (function).
• issue-p (function).
• jingoh-internal-issue (structure).
• missing-restarts (structure).
• missing-restarts-p (function).
• print-object (method).
• print-object (method).
• test-issue (structure).
• test-issue-p (function).
• test-issue-test (reader).
• (setf test-issue-test) (writer).
• unexpected-output (structure).
• unexpected-output-p (function).
• unexpected-success (structure).
• unexpected-success-p (function).
• unmatch-condition (structure).
• unmatch-condition-p (function).
• unsatisfied-clause (structure).
• unsatisfied-clause-args (reader).
• (setf unsatisfied-clause-args) (writer).
• unsatisfied-clause-p (function).
• warning-was-signaled (structure).
• warning-was-signaled-p (function).
• wrong-format (structure).
• wrong-format-p (function).

Internals

• condition-issue-actual (function).
• (setf condition-issue-actual) (function).
• condition-issue-comment (function).
• (setf condition-issue-comment) (function).
• condition-issue-expected (function).
• (setf condition-issue-expected) (function).
• condition-issue-form (function).
• (setf condition-issue-form) (function).
• condition-issue-line (function).
• (setf condition-issue-line) (function).
• copy-condition-issue (function).
• copy-debugger-was-invoked (function).
• copy-error-was-signaled (function).
• copy-issue (function).
• copy-issue-of-multiple-values (function).
• copy-jingoh-internal-issue (function).
• copy-missing-restarts (function).
• copy-test-issue (function).
• copy-unexpected-output (function).
• copy-unexpected-success (function).
• copy-unmatch-condition (function).
• copy-unsatisfied-clause (function).
• copy-warning-was-signaled (function).
• copy-wrong-format (function).
• debugger-was-invoked-actual (function).
• (setf debugger-was-invoked-actual) (function).
• debugger-was-invoked-comment (function).
• (setf debugger-was-invoked-comment) (function).
• debugger-was-invoked-expected (function).
• (setf debugger-was-invoked-expected) (function).
• debugger-was-invoked-form (function).
• (setf debugger-was-invoked-form) (function).
• debugger-was-invoked-line (function).
• (setf debugger-was-invoked-line) (function).
• debugger-was-invoked-message (function).
• (setf debugger-was-invoked-message) (function).
• error-was-signaled-actual (function).
• (setf error-was-signaled-actual) (function).
• error-was-signaled-comment (function).
• (setf error-was-signaled-comment) (function).
• error-was-signaled-expected (function).
• (setf error-was-signaled-expected) (function).
• error-was-signaled-form (function).
• (setf error-was-signaled-form) (function).
• error-was-signaled-line (function).
• (setf error-was-signaled-line) (function).
• error-was-signaled-message (function).
• (setf error-was-signaled-message) (function).
• issue-comment (reader).
• (setf issue-comment) (writer).
• issue-of-multiple-values-actual (function).
• (setf issue-of-multiple-values-actual) (function).
• issue-of-multiple-values-comment (function).
• (setf issue-of-multiple-values-comment) (function).
• issue-of-multiple-values-expected (function).
• (setf issue-of-multiple-values-expected) (function).
• issue-of-multiple-values-form (function).
• (setf issue-of-multiple-values-form) (function).
• issue-of-multiple-values-line (function).
• (setf issue-of-multiple-values-line) (function).
• issue-of-multiple-values-test (function).
• (setf issue-of-multiple-values-test) (function).
• jingoh-internal-issue-actual (function).
• (setf jingoh-internal-issue-actual) (function).
• jingoh-internal-issue-comment (function).
• (setf jingoh-internal-issue-comment) (function).
• jingoh-internal-issue-expected (function).
• (setf jingoh-internal-issue-expected) (function).
• jingoh-internal-issue-form (function).
• (setf jingoh-internal-issue-form) (function).
• jingoh-internal-issue-line (function).
• (setf jingoh-internal-issue-line) (function).
• jingoh-internal-issue-message (function).
• (setf jingoh-internal-issue-message) (function).
• jingoh-internal-issue-p (function).
• make-condition-issue (function).
• make-debugger-was-invoked (function).
• make-error-was-signaled (function).
• make-issue (function).
• make-issue-of-multiple-values (function).
• make-jingoh-internal-issue (function).
• make-missing-restarts (function).
• make-test-issue (function).
• make-unexpected-output (function).
• make-unexpected-success (function).
• make-unmatch-condition (function).
• make-unsatisfied-clause (function).
• make-warning-was-signaled (function).
• make-wrong-format (function).
• missing-restarts-actual (function).
• (setf missing-restarts-actual) (function).
• missing-restarts-comment (function).
• (setf missing-restarts-comment) (function).
• missing-restarts-expected (function).
• (setf missing-restarts-expected) (function).
• missing-restarts-form (function).
• (setf missing-restarts-form) (function).
• missing-restarts-line (function).
• (setf missing-restarts-line) (function).
• should-print-vivid-p (function).
• test-issue-actual (function).
• (setf test-issue-actual) (function).
• test-issue-comment (function).
• (setf test-issue-comment) (function).
• test-issue-expected (function).
• (setf test-issue-expected) (function).
• test-issue-form (function).
• (setf test-issue-form) (function).
• test-issue-line (function).
• (setf test-issue-line) (function).
• unexpected-output-actual (function).
• (setf unexpected-output-actual) (function).
• unexpected-output-comment (function).
• (setf unexpected-output-comment) (function).
• unexpected-output-expected (function).
• (setf unexpected-output-expected) (function).
• unexpected-output-form (function).
• (setf unexpected-output-form) (function).
• unexpected-output-line (function).
• (setf unexpected-output-line) (function).
• unexpected-success-actual (function).
• (setf unexpected-success-actual) (function).
• unexpected-success-comment (function).
• (setf unexpected-success-comment) (function).
• unexpected-success-expected (function).
• (setf unexpected-success-expected) (function).
• unexpected-success-form (function).
• (setf unexpected-success-form) (function).
• unexpected-success-line (function).
• (setf unexpected-success-line) (function).
• unmatch-condition-actual (function).
• (setf unmatch-condition-actual) (function).
• unmatch-condition-comment (function).
• (setf unmatch-condition-comment) (function).
• unmatch-condition-expected (function).
• (setf unmatch-condition-expected) (function).
• unmatch-condition-form (function).
• (setf unmatch-condition-form) (function).
• unmatch-condition-line (function).
• (setf unmatch-condition-line) (function).
• unmatch-condition-message (function).
• (setf unmatch-condition-message) (function).
• unsatisfied-clause-actual (function).
• (setf unsatisfied-clause-actual) (function).
• unsatisfied-clause-comment (function).
• (setf unsatisfied-clause-comment) (function).
• unsatisfied-clause-expected (function).
• (setf unsatisfied-clause-expected) (function).
• unsatisfied-clause-form (function).
• (setf unsatisfied-clause-form) (function).
• unsatisfied-clause-line (function).
• (setf unsatisfied-clause-line) (function).
• vprint-issue (function).
• vprint-unsatisfied-clause (function).
• warning-was-signaled-actual (function).
• (setf warning-was-signaled-actual) (function).
• warning-was-signaled-comment (function).
• (setf warning-was-signaled-comment) (function).
• warning-was-signaled-expected (function).
• (setf warning-was-signaled-expected) (function).
• warning-was-signaled-form (function).
• (setf warning-was-signaled-form) (function).
• warning-was-signaled-line (function).
• (setf warning-was-signaled-line) (function).
• warning-was-signaled-message (function).
• (setf warning-was-signaled-message) (function).
• wrong-format-actual (function).
• (setf wrong-format-actual) (function).
• wrong-format-comment (function).
• (setf wrong-format-comment) (function).
• wrong-format-expected (function).
• (setf wrong-format-expected) (function).
• wrong-format-form (function).
• (setf wrong-format-form) (function).
• wrong-format-line (function).
• (setf wrong-format-line) (function).
• wrong-format-test (function).
• (setf wrong-format-test) (function).

---

3.1.14 jingoh.tester/miscellaneous.lisp

Dependency

package.lisp (file).

Source

jingoh.tester.asd.

Parent Component

jingoh.tester (system).

Public Interface

• canonicalize (function).
• encallable (function).
• reserved-keywords (function).
• sexp= (function).
• syntax-error (condition).
• with-integrated-output-stream (macro).

Internals

• copy-cons (function).
• function-designator-p (function).
• ignore-signals (function).
• slots<=obj (function).

---

3.1.15 jingoh.tester/tester.lisp

Dependencies

• miscellaneous.lisp (file).
• report.lisp (file).

Source

jingoh.tester.asd.

Parent Component

jingoh.tester (system).

Public Interface

• & (macro).
• ? (macro).
• args (reader method).
• check (function).
• defspec (macro).
• make-requirement (generic function).
• requirement-form (function).
• the-push-instance-form (function).
• the-standard-handling-form (function).

Internals

• test-form (reader method).
• unsatisfied (condition).

---

3.1.16 jingoh.examiner/examine.lisp

Source

jingoh.examiner.asd.

Parent Component

jingoh.examiner (system).

Packages

jingoh.examiner.

Public Interface

• *break-on-finish* (special variable).
• *issues* (special variable).
• *on-fails* (special variable).
• *verbose* (special variable).
• examine (function).
• print-object (method).
• with-examiner-context (macro).

Internals

• *requirement-form* (special variable).
• break-on-fails (function).
• break-on-fails (condition).
• break-on-finish (function).
• break-on-finish (condition).
• issues (reader method).
• print-dot (function).
• print-progress (function).
• print-requirement (function).
• print-summary (function).

---

3.1.17 jingoh.reader/reader.lisp

Source

jingoh.reader.asd.

Parent Component

jingoh.reader (system).

Packages

jingoh.reader.

Public Interface

• #?reader (function).
• *read-print* (special variable).
• *read-verbose* (special variable).
• enable (macro).
• macro-char-confliction (condition).
• replace-macro-character (function).

Internals

• #+counter (function).
• #?counter (function).
• #?reader-body (function).
• %collect-spec-lines (function).
• *counter* (special variable).
• *dispatch-macro-character* (special variable).
• *dispatch-macro-sub-char* (special variable).
• *line* (special variable).
• *line-pos* (special variable).
• *lines* (special variable).
• *reader-package* (special variable).
• block-comment (function).
• collect-spec-lines (function).
• line-comment (function).
• line-counter (function).
• string-line-counter (function).

---

5.1.1 Special variables

Special Variable: *break-on-finish* ¶

Breaks when finish examine.

Package

jingoh.examiner.

Source

examine.lisp.

Special Variable: *issues* ¶

# \*ISSUES\*

## Description:
Previous issues.

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

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

## Affected By:
EXAMINE

## Notes:
Debug use.

Package

jingoh.examiner.

Source

examine.lisp.

Special Variable: *on-fails* ¶

# \*ON-FAILS\*

## Description:
Specify EXAMINE’s behavior.

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

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

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

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

## Affected By:
none

## Notes:

Package

jingoh.examiner.

Source

examine.lisp.

Special Variable: *org* ¶

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

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

## Affected By:
IN-ORG

## Notes:
# conditions

Package

jingoh.org.

Source

deforg.lisp.

Special Variable: *read-print* ¶

# \*READ-PRINT\*

## Control verbosity of |\#reader|.

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

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

## Affected By:
none

## Notes:

Package

jingoh.reader.

Source

reader.lisp.

Special Variable: *read-verbose* ¶

# \*READ-VERBOSE\*

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

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

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

## Affected By:
none

## Notes:

Package

jingoh.reader.

Source

reader.lisp.

Special Variable: *verbose* ¶

# \*VERBOSE\*

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

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

## Affected By:
EXAMINE

## Notes:

Package

jingoh.examiner.

Source

examine.lisp.

---

5.1.2 Macros

Macro: & (&body body) ¶

# &

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

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

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

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

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

## Affected By:
none

## Side-Effects:
none

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

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

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

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

## Exceptional-Situations:

Package

jingoh.tester.

Source

tester.lisp.

Macro: ? (&body body) ¶

# ?

## Description:
One shot tester.

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

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

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

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

### dispatch-keys.

standard usage.

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

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

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

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

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

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

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

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

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

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

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

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

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

### option keys

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

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

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

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

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

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

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

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

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

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

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

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

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

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

Package

jingoh.tester.

Source

tester.lisp.

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

# COMMON-REQUIREMENTS-ABOUT

## Description:
Declare current subjects of current org.

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

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

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

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

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

## Affected By:
*ORG*

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

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

## Notes:

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

Package

jingoh.org.

Source

deforg.lisp.

Macro: deforg (name) ¶

# DEFORG

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

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

### syntax
(DEFORG name)
=> result

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

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

## Affected By:
none

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

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

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

## Exceptional-Situations:

Package

jingoh.org.

Source

deforg.lisp.

Macro: defspec (&body body) ¶

# DEFSPEC

## Description:
Define specification.

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

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

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

## Affected By:
*org*

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

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

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

tester.lisp.

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

# DO-REQUIREMENTS

## Description:
Iterate forms for each requirements.

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

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

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

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

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

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

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

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

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

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

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

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

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

miscellaneous.lisp.

Macro: enable (&optional char) ¶

# ENABLE

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

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

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

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

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

## Affected By:
‘*readtable*‘

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

## Notes:

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

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

Package

jingoh.reader.

Source

reader.lisp.

Macro: in-org (name) ¶

# IN-ORG

## Description:
Modify current org.

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

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

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

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

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

## Affected By:
Underlying org database.

## Side-Effects:
Modify *ORG*.

## Notes:

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

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

Package

jingoh.org.

Source

deforg.lisp.

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

# REQUIREMENTS-ABOUT

## Description:
Declare current subject of current org.

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

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

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

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

## Affected By:
*ORG*

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

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

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

deforg.lisp.

Macro: setup (name) ¶

Package

jingoh.

Source

package.lisp.

Macro: with-examiner-context (form) ¶

Package

jingoh.examiner.

Source

examine.lisp.

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

Package

jingoh.tester.

Source

miscellaneous.lisp.

---

5.1.3 Ordinary functions

Function: #?reader (stream character number) ¶

# |#?reader|

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

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

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

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

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

## Side-Effects:
consume stream contents.

## Notes:

## Exceptional-Situations:

## Tests.
Can handle read time labeling.

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

Package

jingoh.reader.

Source

reader.lisp.

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

# ADD-NEW-OPTION-KEY

## Description:

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

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

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

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

## Affected By:

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

## Notes:
Do nothing when key is conflicted.

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

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

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

# ADD-REQUIREMENT

## Description:
add requirement into org.

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

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

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

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

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

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

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

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

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

miscellaneous.lisp.

Function: canonicalize (test-form parameters) ¶

# CANONICALIZE

## Description:
Helper for MAKE-REQUIREMENT

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

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

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

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

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:
form is copied.

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

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

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

Package

jingoh.tester.

Source

miscellaneous.lisp.

Function: check (requirement) ¶

# CHECK

## Description:
accept requirement, then check it.

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

### syntax
(CHECK requirement)
=> result

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

tester.lisp.

Function: clear-option-keys () ¶

# CLEAR-OPTION-KEYS

## Description:

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

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

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

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

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

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Reader: condition-issue-message (instance) ¶

# CONDITION-ISSUE-MESSAGE

## Description:
return condition message string.

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

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Target Slot

message.

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

Package

jingoh.tester.

Source

report.lisp.

Target Slot

message.

Function: condition-issue-p (object) ¶

# CONDITION-ISSUE-P

## Description:
Tests arg is condition-issue.

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

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

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

## Arguments and Values:
object := T

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

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

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

## [Predicates]

## Description:
Tests.

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

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

## Arguments and Values:
object := T

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

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Function: delete-option-key (key) ¶

# DELETE-OPTION-KEY

## Description:

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

## Arguments and Values:
key := T

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

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

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

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

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Function: delete-org (org-designator) ¶

# DELETE-ORG

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

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

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

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

## Affected By:
Underlying org database.

## Side-Effects:
Modify underlying org database.

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

## Exceptional-Situations:

Package

jingoh.org.

Source

deforg.lisp.

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

# DELETE-SUBJECT

## Description:
delete subject from org.

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

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

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

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

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

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

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

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

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

## Exceptional-Situations:

#### The guard for allegro.

Package

jingoh.org.

Source

deforg.lisp.

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

# ENCALLABLE

## Description:
tiny helper for writing macro.

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

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

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

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

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

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

miscellaneous.lisp.

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

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

## [Predicates]

## Description:
Tests.

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

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

## Arguments and Values:
object := T

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

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

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

# EXAMINE

## Description:
Examine requirements then print result.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Package

jingoh.examiner.

Source

examine.lisp.

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

# FIND-OPTION-KEY

## Description:

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

## Arguments and Values:
key := T

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

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

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

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

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

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

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

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

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

# FIND-ORG

## Description:
Find org from underlying org database.

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

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

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

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

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

## Affected By:
underlying org database.

## Side-Effects:
none

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

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

## Exceptional-Situations:

Package

jingoh.org.

Source

deforg.lisp.

Reader: issue-actual (instance) ¶

# ISSUE-ACTUAL

## Description:
return actual value

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Target Slot

actual.

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

Package

jingoh.tester.

Source

report.lisp.

Target Slot

actual.

Reader: issue-expected (instance) ¶

# ISSUE-EXPECTED

## Description: return expected value.

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Target Slot

expected.

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

Package

jingoh.tester.

Source

report.lisp.

Target Slot

expected.

Reader: issue-form (instance) ¶

# ISSUE-FORM

## [Accessor] ISSUE-FORM

## Description:
return issue form.

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Target Slot

form.

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

Package

jingoh.tester.

Source

report.lisp.

Target Slot

form.

Reader: issue-line (instance) ¶

# ISSUE-LINE

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

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Target Slot

line.

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

Package

jingoh.tester.

Source

report.lisp.

Target Slot

line.

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

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

## [Predicates]

## Description:
Tests.

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

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

## Arguments and Values:
object := T

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

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Function: issue-p (object) ¶

# ISSUE-P

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

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

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

## Arguments and Values:
object := T

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Function: list-all-option-keys () ¶

# LIST-ALL-OPTION-KEYS

## Description:

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

## Arguments and Values:
result := list

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

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

## Side-Effects:

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

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

# MAKE-ORG

## Description:
Make new org object.

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

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

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

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

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

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

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

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

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

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Function: missing-restarts-p (object) ¶

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

## [Predicates]

## Description:
Tests.

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

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

## Arguments and Values:
object := T

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

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Reader: org-current-subjects (instance) ¶

# ORG-CURRENT-SUBJECTS

## Description:
return current subjects.

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Target Slot

current-subjects.

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

Package

jingoh.org.

Source

org.lisp.

Target Slot

current-subjects.

Reader: org-name (instance) ¶

# ORG-NAME

## Description:
Return org name.

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Target Slot

name.

Reader: org-options (instance) ¶

# ORG-OPTIONS

## Description:
return current options.

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Target Slot

options.

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

Package

jingoh.org.

Source

org.lisp.

Target Slot

options.

Function: org-p (object) ¶

# ORG-P

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

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Reader: org-package (instance) ¶

# ORG-PACKAGE

## Description:
return package which org in.

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Target Slot

package.

Function: org-requirements-count (org) ¶

# ORG-REQUIREMENTS-COUNT

## Description:
Return number of requirements.

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Reader: org-specifications (instance) ¶

# ORG-SPECIFICATIONS

## Description:
return vector which includes specifications.

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

org.lisp.

Target Slot

specifications.

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

Package

jingoh.org.

Source

org.lisp.

Target Slot

specifications.

Function: register-org (name org) ¶

# REGISTER-ORG

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

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

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

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

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

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

## Affected By:
underlying org database.

## Side-Effects:
modify underlying org database.

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

## Notes:

## Exceptional-Situations:

Package

jingoh.org.

Source

deforg.lisp.

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

# REPLACE-MACRO-CHARACTER

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

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

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

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

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

## Affected By:
none

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

## Notes:

## Exceptional-Situations:

Package

jingoh.reader.

Source

reader.lisp.

Function: requirement-form (requirement) ¶

Package

jingoh.tester.

Source

tester.lisp.

Function: reserved-keywords (gf) ¶

# RESERVED-KEYWORDS

## Description:
return dispatch keys.

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

miscellaneous.lisp.

Function: sexp= (sexp1 sexp2) ¶

# SEXP=

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

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

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:
Still alpha quality.

## Exceptional-Situations:

Package

jingoh.tester.

Source

miscellaneous.lisp.

Function: test-issue-p (object) ¶

# TEST-ISSUE-P

## Description:
Tests arg is test-issue.

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

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

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

## Arguments and Values:
object := T

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Reader: test-issue-test (instance) ¶

# TEST-ISSUE-TEST

## Description:
return test function name.

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

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Target Slot

test.

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

Package

jingoh.tester.

Source

report.lisp.

Target Slot

test.

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

# THE-PUSH-INSTANCE-FORM

## Description:
helper for writing make-requirement.

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

tester.lisp.

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

# THE-STANDARD-HANDLING-FORM

## Description:
Helper for writing make-requirement.

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

tester.lisp.

Function: unexpected-output-p (object) ¶

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

## [Predicates]

## Description:
Tests.

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

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

## Arguments and Values:
object := T

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

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Function: unexpected-success-p (object) ¶

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

## [Predicates]

## Description:
Tests.

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

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

## Arguments and Values:
object := T

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

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Function: unmatch-condition-p (object) ¶

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

## [Predicates]

## Description:
Tests.

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

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

## Arguments and Values:
object := T

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

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Reader: unsatisfied-clause-args (instance) ¶

# UNSATISFIED-CLAUSE-ARGS

## Description:
return args.

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

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

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

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

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

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Target Slot

args.

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

Package

jingoh.tester.

Source

report.lisp.

Target Slot

args.

Function: unsatisfied-clause-p (object) ¶

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

## [Predicates]

## Description:
Tests.

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

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

## Arguments and Values:
object := T

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

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

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

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

## [Predicates]

## Description:
Tests.

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

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

## Arguments and Values:
object := T

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

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

Function: wrong-format-p (object) ¶

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

## [Predicates]

## Description:
Tests.

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

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

## Arguments and Values:
object := T

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

## Affected By:
none
Side-Effects:
none

## Notes:

## Exceptional-Situations:

Package

jingoh.tester.

Source

report.lisp.

---