;; -*- Mode: Lisp; -*-

;;;; Simple shakedown procedure for JTRE 
;;;; Last edited 1/29/93, by KDF

;;; Copyright (c) 1988-1992, Kenneth D. Forbus, Northwestern University,
;;; and Johan de Kleer, the Xerox Corporation.
;;; All rights reserved.

;;; See the file legal.txt for a paragraph stating scope of permission
;;; and disclaimer of warranty.  The above copyright notice and that
;;; paragraph must be included in any separate copy of this file.

(in-package :cl-user)

(defun shakedown-jtre ()
  (in-jtre (create-jtre "Test One"))
  (dolist (form '((rule ((:intern (foo ?x) :var ?f :test (numberp ?x))
                         (:intern (bar ?y) :var ?g :test (numberp ?y)))
                        (rassert! (mumble ?x ?y) (Test-intern ?f ?g)))
                  (format t "~% :intern rule defined okay.")
                  (rule ((:in (foo ?x) :var ?f
                              :test (not (numberp ?x)))
                         (:in (bar ?y) :var ?g
                              :test (not (numberp ?y))))
                        (rassert! (grumble ?x ?y)
                         (:test-in ?f ?g)))
                  (format t "~% :in rule defined okay.")
                  (referent '(foo 1) t)
                  (cond ((fetch '(foo 1))
                         (format t "~% Referent worked okay."))
                        (t (error "Referent failed.")))
                  (referent '(bar 1) t)
                  (run-rules)
                  (format t "~% No errors during attempted rule execution.")
                  (cond ((fetch '(mumble 1 1))
                         (format t "~%:intern rule fired okay."))
                        (t (error "~% :intern rule failed to fire.")))
                  (referent '(foo a) t)
                  (referent '(bar a) t)
                  (run-rules)
                  (when (some #'(lambda (fact) (in? fact))
                              (fetch '(grumble ?p ?q)))
                        (format t "~%Premature triggering of :in rule."))
                  (uassume! '(foo a) :user)
                  (uassume! '(bar a) :user)
                  (cond ((in? '(grumble a a))
                         (format t "~% :in rule worked okay."))
                        (t (format t "~%:in rule failed to fire.")))
                  (uassume! '(foo 1) :user)
                  (uassume! '(bar 1) :user)
                  (unless (in? '(mumble 1 1))
                          (format t "~% Reference or JTMS failure.")))
                :okay)
          (print (eval form))))