X-Git-Url: http://git.kpe.io/?p=xlunit.git;a=blobdiff_plain;f=example.lisp;h=599d3b243fb4ce35a7cb1bdf1d9c5952fba554c1;hp=ce53451183e8bab56b0d730865af147152ed2cf3;hb=HEAD;hpb=c7bc011f355411986f238987a4f97c93f66818dc

diff --git a/example.lisp b/example.lisp
index ce53451..599d3b2 100644
--- a/example.lisp
+++ b/example.lisp
@@ -2,73 +2,50 @@
 ;;;; *************************************************************************
 ;;;; FILE IDENTIFICATION
 ;;;;
-;;;; Name:        example.lisp
-;;;; Purpose:     Example file for XLTest
-;;;; Authors:     Kevin Rosenberg and Craig Brozefsky
+;;;; ID:      $Id$
+;;;; Purpose: Example file for XLUnit
 ;;;;
-;;;; $Id: example.lisp,v 1.2 2003/08/04 09:46:44 kevin Exp $
 ;;;; *************************************************************************
 
-(defpackage #:xltest-example
-  (:use #:cl #:xltest)
+(defpackage #:xlunit-example
+  (:use #:cl #:xlunit)
   (:export #:math-test-suite))
 
-(in-package #:xltest-example)
+(in-package #:xlunit-example)
 
-;;; First we define some basic fixtures that we are going to need to
-;;; perform our tests.  A fixture is a place to hold data we need
+;;; First we define some basic test-cases that we are going to need to
+;;; perform our tests.  A test-case is a place to hold data we need
 ;;; during testing.  Often there are many test cases that use the same
-;;; data.  Each of these test cases is an instance of a test-fixture.
+;;; data.  Each of these test cases is an instance of a test-case.
 
-(defclass math-fixture (test-fixture)
+(defclass math-test-case (test-case)
   ((numbera :accessor numbera)
    (numberb :accessor numberb))
-  (:documentation "Test fixture for math testing"))
+  (:documentation "Test test-case for math testing"))
 
-;;; Then we define a setup method for the fixture.  This method is run
-;;; prior to perfoming any test with an instance of this fixture.  It
+;;; Then we define a set-up method for the test-case.  This method is run
+;;; prior to perfoming any test with an instance of this test-case.  It
 ;;; should perform all initialization needed, and assume that it is starting
 ;;; with a pristine environment, well to a point, use your head here.
 
-(defmethod setup ((fix math-fixture))
-  (setf (numbera fix) 2)
-  (setf (numberb fix) 3))
+(defmethod set-up ((tcase math-test-case))
+  (setf (numbera tcase) 2)
+  (setf (numberb tcase) 3))
 
-;;; Then we define a teardown method, which should return the instance
-;;; to it's original form and reset the environment.  In this case
-;;; there is little for us to do since the fixture is quite static.
-;;; In other cases we may need to clear some database tables, or
-;;; otherwise get rid of state built up while perofmring the test.
-;;; Here we just return T.
 
-(defmethod teardown ((fix math-fixture))
-  t)
-
-;;; Once we hav a fixture we can start defining method on it which
-;;; will perform tests.  These methods should take one argument, an
-;;; instance of the fixture.  The method performs some operation and
-;;; then performs some tests to determine if the proper behavior
-;;; occured.  If there is a failure to behave as excpeted the method
-;;; raises a test-failure object by calling the method FAILURE.  This
-;;; is much like calling ERROR in that it stops processing that
-;;; method.  Each method should only check for one aspect of behavior.
-;;; This way triggering one failure would not result in another
-;;; behavior check from being skipped.  It does not matter what these
-;;; methods return
-
-(defmethod test-addition ((test math-fixture))
+(def-test-method test-addition ((test math-test-case) :run nil)
   (let ((result (+ (numbera test) (numberb test))))
-    (test-assert (= result 5))))
+    (assert-true (= result 5))))
 
-(defmethod test-subtraction ((test math-fixture))
+(def-test-method test-subtraction ((test math-test-case) :run nil)
   (let ((result (- (numberb test) (numbera test))))
     (assert-equal result 1)))
 
 ;;; This method is meant to signal a failure
-(defmethod test-subtraction-2 ((test math-fixture))
+(def-test-method test-subtraction-2 ((test math-test-case) :run nil)
   (let ((result (- (numbera test) (numberb test))))
-    (assert-equal result 1)))
+    (assert-equal result 1 "This is meant to failure")))
 
 ;;;; Finally we can run our test suite and see how it performs.
-(text-testrunner (make-test-suite 'math-fixture))
+(textui-test-run (get-suite math-test-case))