anchor.diff:  ;;; Tests for function position
   ;;; with seq-type=list test-not=eql key=other start=other end=other from-end=true
   
  +(define-test |position seq-type=list test-not=eql key=other start=other end=other from-end=true 1|
  +  (let ((seq (mapcar #'list (reverse (list *i01* *i02* *i1* *i02* *i2* *i01*)))))
  +    (assert-equal 3
  +		  (position *i02* seq
  +			    :test-not #'eql :start 1 :end 4 :from-end t :key #'car))
  +    (assert-equal 3
  +		  (position *i02* seq
  +			    :test-not 'eql :start 1 :end 4 :from-end t :key #'car))
  +    (assert-equal 1
  +		  (position *i02* seq
  +			    :test-not #'eql :start 1 :end 2 :from-end t :key #'car))
  +    (assert-equal 1
  +		  (position *i02* seq
  +			    :test-not 'eql :start 1 :end 2 :from-end t :key #'car))
  +    (assert-equal 3
  +		  (position *i02* seq
  +			    :test-not #'eql :start 3 :end 5 :from-end t :key #'car))
  +    (assert-equal 3
  +		  (position *i02* seq
  +			    :test-not 'eql :start 3 :end 5 :from-end t :key #'car))
  +    (assert-equal nil
  +		  (position *i02* seq
  +			    :test-not #'eql :start 5 :end 6 :from-end t :key #'car))
  +    (assert-equal nil
  +		  (position *i02* seq
  +			    :test-not 'eql :start 5 :end 6 :from-end t :key #'car))
  +    (assert-error 'type-error
  +		  (position *i02* seq
  +			    :test-not #'eql :start 5 :end 7 :from-end t :key #'car))
  +    (assert-error 'type-error
  +		  (position *i02* (append seq 'b)
  +			    :test-not #'eql :start 5 :end 7 :from-end t :key #'car))))
  +
   ;;; ************** ADD MORE TESTS HERE
   
   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
positive.code: ;;; Tests for function position
  ;;; with seq-type=list test-not=eql key=identity start=other end=other from-end=false
  
  ;;; ************** ADD MORE TESTS HERE
  
  ;;;;;;;;;;
  ;;;
  ;;; Tests for function position
  ;;; with seq-type=list test-not=eql key=identity start=other end=other from-end=true
  
  ;;; ************** ADD MORE TESTS HERE
  
  
negative.code: ;;; Tests for function position
  ;;; with seq-type=list test-not=eq key=other start=other end=nil from-end=false
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=false 3b|
    (assert-equal 1
  		(position *l01* (list (list *l01*) (list *l1*) (list *l02*) (list *l2*))
  			  :test-not #'eq :start 1 :key #'car)))
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=false 3c|
    (assert-equal 1
  		(position *l01* (list (list *l01*) (list *l1*) (list *l02*) (list *l2*))
  			  :test-not 'eq :start 1 :key #'car)))
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=false 3b|
    (assert-equal 3
  		(position *l01* (list (list *l01*) (list *l1*) (list *l02*) (list *l2*))
  			  :test-not #'eq :start 2 :key #'car)))
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=false 3c|
    (assert-equal 3
  		(position *l01* (list (list *l01*) (list *l1*) (list *l02*) (list *l2*))
  			  :test-not 'eq :start 2 :key #'car)))
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=false 4b|
    (assert-equal nil
  		(position *l01* (list (list *l01*) (list *l01*) (list *l01*))
  			  :test-not #'eq :start 1 :key #'car)))
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=false 4c|
    (assert-equal nil
  		(position *l01* (list (list *l01*) (list *l01*) (list *l01*))
  			  :test-not 'eq :start 1 :key #'car)))
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=false 5b|
    (assert-equal 1
  		(position (list *l1*) (list (list (list *l1*)) (list (list *l1*)))
  			  :test-not #'eq :start 1 :key #'car)))
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=false 5c|
    (assert-equal 1
  		(position (list *l1*) (list (list (list *l1*)) (list (list *l1*)))
  			  :test-not 'eq :start 1 :key #'car)))
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=false 7b|
    (assert-error 'type-error
  		(position 'b '((b) (b) . b)
  			  :test-not #'eq :start 1 :key #'car)))
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=false 7c|
    (assert-error 'type-error
  		(position 'b '((b) (b) . b)
  			  :test-not 'eq :start 1 :key #'car)))
  
  ;;; ************** ADD MORE TESTS HERE
  
  ;;;;;;;;;;
  ;;;
  ;;; Tests for function position
  ;;; with seq-type=list test-not=eq key=other start=other end=nil from-end=true
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=true 3b|
    (assert-equal 3
  		(position *l01* (list (list *l01*) (list *l1*) (list *l02*) (list *l2*))
  			  :test-not #'eq :start 1 :from-end t :key #'car)))
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=true 3c|
    (assert-equal 3
  		(position *l01* (list (list *l01*) (list *l1*) (list *l02*) (list *l2*))
  			  :test-not 'eq :start 1 :from-end t :key #'car)))
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=true 3b|
    (assert-equal 3
  		(position *l01* (list (list *l01*) (list *l1*) (list *l02*) (list *l2*))
  			  :test-not #'eq :start 2 :from-end t :key #'car)))
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=true 3c|
    (assert-equal 3
  		(position *l01* (list (list *l01*) (list *l1*) (list *l02*) (list *l2*))
  			  :test-not 'eq :start 2 :from-end t :key #'car)))
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=true 4b|
    (assert-equal nil
  		(position *l01* (list (list *l01*) (list *l01*) (list *l01*))
  			  :test-not #'eq :start 1 :from-end t :key #'car)))
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=true 4c|
    (assert-equal nil
  		(position *l01* (list (list *l01*) (list *l01*) (list *l01*))
  			  :test-not 'eq :start 1 :from-end t :key #'car)))
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=true 5b|
    (assert-equal 1
  		(position (list *l1*) (list (list (list *l1*)) (list (list *l1*)))
  			  :test-not #'eq :start 1 :from-end t :key #'car)))
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=true 5c|
    (assert-equal 1
  		(position (list *l1*) (list (list (list *l1*)) (list (list *l1*)))
  			  :test-not 'eq :start 1 :from-end t :key #'car)))
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=true 7b|
    (assert-error 'type-error
  		(position 'b '((b) (b) . b)
  			  :test-not #'eq :start 1 :from-end t :key #'car)))
  
  (define-test |position seq-type=list test-not=eq key=other start=other end=nil from-end=true 7c|
    (assert-error 'type-error
  		(position 'b '((b) (b) . b)
  			  :test-not 'eq :start 1 :from-end t :key #'car)))
  
  ;;; ************** ADD MORE TESTS HERE
  
  