 
 tests.test("ForwardCollection") {
   let a0: ContiguousArray = [1, 2, 3, 5, 8, 13, 21]
-  let fc0 = AnyForwardCollection(a0)
+  let fc0 = AnyCollection(a0)
   let a1 = ContiguousArray(fc0)
   expectEqual(a0, a1)
   for e in a0 {

let initialCallCounts = [
  "successor": 0, "predecessor": 0,
  "_successorInPlace": 0, "_predecessorInPlace": 0,
  "advanced(by:)": 0, "distance(to:)": 0
]

var callCounts = initialCallCounts
  
struct InstrumentedIndex<I : RandomAccessIndex> : RandomAccessIndex {
  typealias Distance = I.Distance

  var base: I
  
  init(_ base: I) {
    self.base = base
  }
  
  static func resetCounts() {
    callCounts = initialCallCounts
  }
  
  func successor() -> InstrumentedIndex {
    callCounts["successor"]! += 1
    return InstrumentedIndex(base.successor())
  }
  
  mutating func _successorInPlace() {
    callCounts["_successorInPlace"]! += 1
    base._successorInPlace()
  }
  
  func predecessor() -> InstrumentedIndex {
    callCounts["predecessor"]! += 1
    return InstrumentedIndex(base.predecessor())
  }
  
  mutating func _predecessorInPlace() {
    callCounts["_predecessorInPlace"]! += 1
    base._predecessorInPlace()
  }
  
  func advanced(by distance: Distance) -> InstrumentedIndex {
    callCounts["advanced(by:)"]! += 1
    return InstrumentedIndex(base.advanced(by: distance))
  }
  
  func distance(to other: InstrumentedIndex) -> Distance {
    callCounts["distance(to:)"]! += 1
    return base.distance(to: other.base)
  }
}

tests.test("AnySequence.init(Sequence)") {


tests.test("RandomAccessCollection") {
  let a0: ContiguousArray = [1, 2, 3, 5, 8, 13, 21]
  let fc0 = AnyCollection(a0.lazy.reversed())
  let rc0_ = AnyRandomAccessCollection(fc0)         // upgrade!
  expectNotEmpty(rc0_)
  let rc0 = rc0_!
