anchor.diff:  
   (define-test |position seq-type=list test=eq key=identity start=0 end=nil from-end=false 1b|
     (assert-equal nil
  -		(position *l01* '() :test #'eq)))
  +		(position *l01* '()
  +			  :test #'eq)))
   
   (define-test |position seq-type=list test=eq key=identity start=0 end=nil from-end=false 1c|
     (assert-equal nil
  -		(position *l01* '() :test 'eq)))
  +		(position *l01* '()
  +			  :test 'eq)))
   
   (define-test |position seq-type=list test=eq key=identity start=0 end=nil from-end=false 2b|
     (assert-equal nil
  -		(position *l01* '() :start 0 :test #'eq)))
  +		(position *l01* '()
  +			  :start 0 :test #'eq)))
   
   (define-test |position seq-type=list test=eq key=identity start=0 end=nil from-end=false 2c|
     (assert-equal nil
  -		(position *l01* '() :start 0 :test 'eq)))
  +		(position *l01* '()
  +			  :start 0 :test 'eq)))
   
   (define-test |position seq-type=list test=eq key=identity start=0 end=nil from-end=false 3b|
     (assert-equal 2
  -		(position *l01* (list *l1* *l02* *l01* *l2*) :test #'eq)))
  +		(position *l01* (list *l1* *l02* *l01* *l2*)
  +			  :test #'eq)))
   
   (define-test |position seq-type=list test=eq key=identity start=0 end=nil from-end=false 3c|
     (assert-equal 2
  -		(position *l01* (list *l1* *l02* *l01* *l2*) :test 'eq)))
  +		(position *l01* (list *l1* *l02* *l01* *l2*)
  +			  :test 'eq)))
   
   (define-test |position seq-type=list test=eq key=identity start=0 end=nil from-end=false 4b|
     (assert-equal nil
  -		(position *l01* (list *l1* *l2* *l3*) :test #'eq)))
  +		(position *l01* (list *l1* *l2* *l3*)
  +			  :test #'eq)))
   
   (define-test |position seq-type=list test=eq key=identity start=0 end=nil from-end=false 4c|
     (assert-equal nil
  -		(position *l01* (list *l1* *l2* *l3*) :test 'eq)))
  +		(position *l01* (list *l1* *l2* *l3*)
  +			  :test 'eq)))
   
   (define-test |position seq-type=list test=eq key=identity start=0 end=nil from-end=false 5b|
     (assert-equal nil
  -		(position (list *l1*) (list (list *l1*)) :test #'eq)))
  +		(position (list *l1*) (list (list *l1*))
  +			  :test #'eq)))
   
   (define-test |position seq-type=list test=eq key=identity start=0 end=nil from-end=false 5c|
     (assert-equal nil
  -		(position (list *l1*) (list (list *l1*)) :test 'eq)))
  +		(position (list *l1*) (list (list *l1*))
  +			  :test 'eq)))
   
   (define-test |position seq-type=list test=eq key=identity start=0 end=nil from-end=false 6b|
     (assert-error 'type-error
  -		(position 'a 1 :test #'eq)))
  +		(position 'a 1
  +			  :test #'eq)))
   
   (define-test |position seq-type=list test=eq key=identity start=0 end=nil from-end=false 6c|
     (assert-error 'type-error
  -		(position 'a 1 :test 'eq)))
  +		(position 'a 1
  +			  :test 'eq)))
   
   (define-test |position seq-type=list test=eq key=identity start=0 end=nil from-end=false 7b|
     (assert-error 'type-error
  -		(position 'a '(b b . b) :test #'eq)))
  +		(position 'a '(b b . b)
  +			  :test #'eq)))
   
   (define-test |position seq-type=list test=eq key=identity start=0 end=nil from-end=false 7c|
     (assert-error 'type-error
  -		(position 'a '(b b . b) :test 'eq)))
  +		(position 'a '(b b . b)
  +			  :test 'eq)))
   
   ;;; ************** ADD MORE TESTS HERE
   
  
positive.code: ;;;
  ;;; Tests for function position
  ;;; with seq-type=list test=eq key=identity start=0 end=nil from-end=true
  
  ;;; ************** ADD MORE TESTS HERE
  
  
negative.code: ;;; Tests for function position
  ;;; with seq-type=list test-not=eql key=other start=0 end=other from-end=false
  
  ;;; Check that we find a eql number (but probably not eq) in a list.  
  ;;; A test-not of eql is explicit by passing the function.
  (define-test |position seq-type=list test-not=eql key=other start=0 end=other from-end=false 3b|
    (assert-equal 1
  		(position *i01* (list (list *i02*) (list *i1*) (list *i01*) (list *i2*))
  			  :test-not #'eql :end 2 :key #'car)))
  
  ;;; Check that we find a eql number (but probably not eq) in a list.  
  ;;; A test-not of eql is explicit by passing the name of the function. 
  (define-test |position seq-type=list test-not=eql key=other start=0 end=other from-end=false 3c|
    (assert-equal 1
  		(position *i01* (list (list *i02*) (list *i1*) (list *i01*) (list *i2*))
  			  :test-not 'eql :end 2 :key #'car)))
  
  ;;; Check that we find a eql number (but probably not eq) in a list.  
  ;;; A test-not of eql is explicit by passing the function.
  (define-test |position seq-type=list test-not=eql key=other start=0 end=other from-end=false 3b|
    (assert-equal nil
  		(position *i01* (list (list *i02*) (list *i1*) (list *i01*) (list *i2*))
  			  :test-not #'eql :end 1 :key #'car)))
  
  ;;; Check that we find a eql number (but probably not eq) in a list.  
  ;;; A test-not of eql is explicit by passing the name of the function. 
  (define-test |position seq-type=list test-not=eql key=other start=0 end=other from-end=false 3c|
    (assert-equal nil
  		(position *i01* (list (list *i02*) (list *i1*) (list *i01*) (list *i2*))
  			  :test-not 'eql :end 1 :key #'car)))
  
  ;;; Check that we get a type error when we pass something that is not
  ;;; a sequence.
  (define-test |position seq-type=list test-not=eql key=other start=0 end=other from-end=false 6b|
    (assert-error 'type-error
  		(position 0 1
  			  :test-not #'eql :end 0 :key #'car)))
  
  ;;; Check that we get a type error when we pass something that is not
  ;;; a sequence.
  (define-test |position seq-type=list test-not=eql key=other start=0 end=other from-end=false 6c|
    (assert-error 'type-error
  		(position 0 1
  			  :test-not 'eql :end 0 :key #'car)))
  
  ;;; Check that we get a type error when we pass a dotted list and 
  ;;; the item is not in the sequence.
  (define-test |position seq-type=list test-not=eql key=other start=0 end=other from-end=false 7b|
    (assert-error 'type-error
  		(position 1 '((1) (1) . 1)
  			  :test-not #'eql :end 4 :key #'car)))
  
  ;;; Check that we get a type error when we pass a dotted list and 
  ;;; the item is not in the sequence.
  (define-test |position seq-type=list test-not=eql key=other start=0 end=other from-end=false 7c|
    (assert-error 'type-error
  		(position 1 '((1) (1) . 1)
  			  :test-not 'eql :end 4 :key #'car)))
  
  ;;; Check that we get a type error when we pass a dotted list and 
  ;;; the item is not in the sequence.
  (define-test |position seq-type=list test-not=eql key=other start=0 end=other from-end=false 7b|
    (assert-equal nil
  		(position 1 '((1) (1) . 1)
  			  :test-not #'eql :end 1 :key #'car)))
  
  ;;; Check that we get a type error when we pass a dotted list and 
  ;;; the item is not in the sequence.
  (define-test |position seq-type=list test-not=eql key=other start=0 end=other from-end=false 7c|
    (assert-equal nil
  		(position 1 '((1) (1) . 1)
  			  :test-not 'eql :end 1 :key #'car)))
  
  ;;; ************** ADD MORE TESTS HERE
  
  ;;;;;;;;;;
  