anchor.diff:  ;;; Tests for function position
   ;;; with seq-type=list test-not=eql key=identity start=0 end=nil from-end=false
   
  +;;; Check that it works with the empty list and :test-not #'eql given
  +;;; and no explicit start given.
  +(define-test |position seq-type=list test-not=eql key=identity start=0 end=nil from-end=false 1b|
  +  (assert-equal nil
  +		(position 1 '() :test-not #'eql)))
  +
  +;;; Check that it works with the empty list and :test-not 'eql given
  +;;; and no explicit start given.
  +(define-test |position seq-type=list test-not=eql key=identity start=0 end=nil from-end=false 1c|
  +  (assert-equal nil
  +		(position 1 '() :test-not 'eql)))
  +
  +;;; Check that it works with the empty list and :test-not #'eql given
  +;;; and an explicit start of 0 given.
  +(define-test |position seq-type=list test-not=eql key=identity start=0 end=nil from-end=false 2b|
  +  (assert-equal nil
  +		(position 1 '() :start 0 :test-not #'eql)))
  +
  +;;; Check that it works with the empty list and :test-not 'eql given
  +;;; and an explicit start of 0 given.
  +(define-test |position seq-type=list test-not=eql key=identity start=0 end=nil from-end=false 2c|
  +  (assert-equal nil
  +		(position 1 '() :start 0 :test-not 'eql)))
  +
  +;;; 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=identity start=0 end=nil from-end=false 3b|
  +  (assert-equal 1
  +		(position *i01* (list *i02* *i1* *i01* *i2*) :test-not #'eql)))
  +
  +;;; 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=identity start=0 end=nil from-end=false 3c|
  +  (assert-equal 1
  +		(position *i01* (list *i02* *i1* *i01* *i2*) :test-not 'eql)))
  +
  +;;; Check that we get nil back if the number is not in the list.
  +;;; A test-not of eql is explicit by passing the function.
  +(define-test |position seq-type=list test-not=eql key=identity start=0 end=nil from-end=false 4b|
  +  (assert-equal nil
  +		(position *i01* (list *i01* *i01* *i01*) :test-not #'eql)))
  +
  +;;; Check that we get nil back if the number is not in the 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=identity start=0 end=nil from-end=false 4c|
  +  (assert-equal nil
  +		(position *i01* (list *i01* *i01* *i01*) :test-not 'eql)))
  +
  +;;; 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=identity start=0 end=nil from-end=false 6b|
  +  (assert-error 'type-error
  +		(position 0 1 :test-not #'eql)))
  +
  +;;; 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=identity start=0 end=nil from-end=false 6c|
  +  (assert-error 'type-error
  +		(position 0 1 :test-not 'eql)))
  +
  +;;; 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=identity start=0 end=nil from-end=false 7b|
  +  (assert-error 'type-error
  +		(position 1 '(1 1 . 1) :test-not #'eql)))
  +
  +;;; 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=identity start=0 end=nil from-end=false 7c|
  +  (assert-error 'type-error
  +		(position 1 '(1 1 . 1) :test-not 'eql)))
  +
   ;;; ************** ADD MORE TESTS HERE
   
   ;;;;;;;;;;
  
positive.code: ;;; Tests for function position
  ;;; with seq-type=list test-not=eq key=other start=0 end=nil from-end=false
  
  ;;; ************** ADD MORE TESTS HERE
  
  ;;;;;;;;;;
  
negative.code: ;;;
  ;;; Tests for function position
  ;;; with seq-type=list test-not=eql key=other start=0 end=nil from-end=false
  
  ;;; Check that it works with the empty list and :test-not #'eql given
  ;;; and no explicit start given.
  (define-test |position seq-type=list test-not=eql key=other start=0 end=nil from-end=false 1b|
    (assert-equal nil
  		(position 1 '()
  			  :test-not #'eql :key #'car)))
  
  ;;; Check that it works with the empty list and :test-not 'eql given
  ;;; and no explicit start given.
  (define-test |position seq-type=list test-not=eql key=other start=0 end=nil from-end=false 1c|
    (assert-equal nil
  		(position 1 '()
  			  :test-not 'eql :key #'car)))
  
  ;;; Check that it works with the empty list and :test-not #'eql given
  ;;; and an explicit start of 0 given.
  (define-test |position seq-type=list test-not=eql key=other start=0 end=nil from-end=false 2b|
    (assert-equal nil
  		(position 1 '()
  			  :start 0 :test-not #'eql :key #'car)))
  
  ;;; Check that it works with the empty list and :test-not 'eql given
  ;;; and an explicit start of 0 given.
  (define-test |position seq-type=list test-not=eql key=other start=0 end=nil from-end=false 2c|
    (assert-equal nil
  		(position 1 '()
  			  :start 0 :test-not 'eql :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=nil from-end=false 3b|
    (assert-equal 1
  		(position *i01* (list (list *i02*) (list *i1*) (list *i01*) (list *i2*))
  			  :test-not #'eql :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=nil from-end=false 3c|
    (assert-equal 1
  		(position *i01* (list (list *i02*) (list *i1*) (list *i01*) (list *i2*))
  			  :test-not 'eql :key #'car)))
  
  ;;; Check that we get nil back if the number is not in the 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=nil from-end=false 4b|
    (assert-equal nil
  		(position *i01* (list (list *i01*) (list *i01*) (list *i01*))
  			  :test-not #'eql :key #'car)))
  
  ;;; Check that we get nil back if the number is not in the 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=nil from-end=false 4c|
    (assert-equal nil
  		(position *i01* (list (list *i01*) (list *i01*) (list *i01*))
  			  :test-not 'eql :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=nil from-end=false 6b|
    (assert-error 'type-error
  		(position 0 1
  			  :test-not #'eql :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=nil from-end=false 6c|
    (assert-error 'type-error
  		(position 0 1
  			  :test-not 'eql :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=nil from-end=false 7b|
    (assert-error 'type-error
  		(position 1 '((1) (1) . 1)
  			  :test-not #'eql :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=nil from-end=false 7c|
    (assert-error 'type-error
  		(position 1 '((1) (1) . 1)
  			  :test-not 'eql :key #'car)))
  
  ;;; ************** ADD MORE TESTS HERE
  
  