anchor.diff:  
   (test split-event-by-lists
     "Test split-event-by-lists"
  -  (is-true
  -   (every-event-equal
  -    (list (event :foo 1 :bar 1 :baz 3)
  -          (event :foo 1 :bar 2 :baz 4)
  -          (event :foo 1 :bar 1 :baz 5))
  -    (split-event-by-lists (event :foo 1 :bar (list 1 2) :baz (list 3 4 5))))
  -   "split-event-by-lists returns incorrect results")
  -  (is-true
  -   (every-event-equal
  -    (list (event :foo 1 :bar 1 :baz 3)
  -          (event :foo 1 :bar 2 :baz 4)
  -          (event :foo 1 :bar 1 :baz 5))
  -    (split-event-by-lists (event :foo (list 1) :bar (list 1 2) :baz (list 3 4 5))))
  -   "split-event-by-lists returns incorrect results if one of the event values is a list of length 1")
  -  (is-true
  -   (equal (list 999)
  -          (let ((event (event)))
  -            (setf (beat event) 999)
  -            (mapcar #'beat (split-event-by-lists event))))
  -   "split-event-by-lists doesn't carry over the %beat slot for empty events")
  -  (is-true
  -   (equal (list 999 999 999)
  -          (let ((event (event :midinote (list 40 50 60))))
  -            (setf (beat event) 999)
  -            (mapcar #'beat (split-event-by-lists event))))
  -   "split-event-by-lists doesn't carry over the %beat slot for events with lists"))
  +  (is-true (every-event-equal
  +            (list (event :foo 1 :bar 1 :baz 3)
  +                  (event :foo 1 :bar 2 :baz 4)
  +                  (event :foo 1 :bar 1 :baz 5))
  +            (split-event-by-lists (event :foo 1 :bar (list 1 2) :baz (list 3 4 5))))
  +           "split-event-by-lists returns incorrect results")
  +  (is-true (every-event-equal
  +            (list (event :foo 1 :bar 1 :baz 3)
  +                  (event :foo 1 :bar 2 :baz 4)
  +                  (event :foo 1 :bar 1 :baz 5))
  +            (split-event-by-lists (event :foo (list 1) :bar (list 1 2) :baz (list 3 4 5))))
  +           "split-event-by-lists returns incorrect results if one of the event values is a list of length 1")
  +  (is-true (equal (list 999)
  +                  (let ((event (event)))
  +                    (setf (beat event) 999)
  +                    (mapcar #'beat (split-event-by-lists event))))
  +           "split-event-by-lists doesn't carry over the %beat slot for empty events")
  +  (is-true (equal (list 999 999 999)
  +                  (let ((event (event :midinote (list 40 50 60))))
  +                    (setf (beat event) 999)
  +                    (mapcar #'beat (split-event-by-lists event))))
  +           "split-event-by-lists doesn't carry over the %beat slot for events with lists"))
   
   (test combine-events-via-lists
     "Test combine-events-via-lists"
  -  (is-true
  -   (event-equal
  -    (event :foo 1 :bar (list 2 3) :qux 4 :baz 5)
  -    (combine-events-via-lists (event :foo 1 :bar 2 :qux 4) (event :foo 1 :bar 3 :baz 5)))
  -   "combine-events-via-lists returns incorrect results"))
  +  (is-true (event-equal
  +            (event :foo 1 :bar (list 2 3) :qux 4 :baz 5)
  +            (combine-events-via-lists (event :foo 1 :bar 2 :qux 4) (event :foo 1 :bar 3 :baz 5)))
  +           "combine-events-via-lists returns incorrect results"))
   
  
positive.code: 
  (test event-equal
    "Test event-equal"
    (is-true
     (event-equal (event :dur 1) (event :dur 1))
     "event-equal doesn't return true for equivalent events")
    (is-false
     (event-equal (event :dur 1) (event :dur 1 :foo 2))
     "event-equal doesn't return false for events with differing keys")
    (is-true
     (event-equal (list (event :foo 1)) (event :foo 1))
     "event-equal doesn't consider an event to be equal to a list of the same event"))
  
  (test every-event-equal
    "Test every-event-equal"
  
negative.code: 
  (test event
    "Test event functionality"
    (is (= 1
           (event-value (event :dur 0 :sustain 1) :sustain))
        "event returns the wrong sustain when sustain is provided and dur is 0")
    (is (= 0.8
           (event-value (event) :sustain))
        "event returns the wrong default value for sustain")
    (is (= 0.5
           (event-value (event :dur 0 :legato 0.5) :legato))
        "event returns the wrong legato when legato is provided and dur is 0")
    (is (= 0.8
           (event-value (event) :legato))
        "event returns the wrong default value for legato")
    (is (= 1
           (event-value (event) :dur))
        "event returns the wrong default value for dur")
    (is (eql :default
             (event-value (event) :instrument))
        "event returns the wrong default value for instrument")
    (is (= (amp-db 0.125)
           (event-value (event :amp 0.125) :db))
  