     base: base._prext_lazy._base,
     arbitraryElement: OpaqueValue(0),
     count: Int(expected.count))
+
+  let s = base._prext_lazy
+  let baseType = base.dynamicType
+  let startIndex = CollectionLog.startIndex.expectIncrement(baseType) {
+    s.startIndex
+  }
+  
+  let endIndex = CollectionLog.endIndex.expectIncrement(baseType) {
+    s.endIndex
+  }
+  
+  CollectionLog.subscriptIndex.expectIncrement(baseType) { _ = s[startIndex] }
+  CollectionLog.subscriptRange.expectUnchanged(baseType) {
+    _ = s[startIndex..<endIndex]
+  }
+  CollectionLog.isEmpty.expectIncrement(baseType) { _ = s.isEmpty }
+  CollectionLog.count.expectIncrement(baseType) { _ = s.count }
+  CollectionLog._customIndexOfEquatableElement.expectIncrement(baseType) {
+    _ = s._customIndexOfEquatableElement(OpaqueValue(0))
+  }
+  CollectionLog.first.expectIncrement(baseType) { _ = s.first }
 }
 
 /// Augment `s` with lazy methods such as `map`, `filter`, etc.

  public subscript(position: Base.Index) -> Base.Generator.Element {
    return _base[position]
  }
}

/// Augment `self` with lazy methods such as `map`, `filter`, etc.

    Base.Generator.Element == S.Generator.Element
>(s: S, base: Base, arbitraryElement: S.Generator.Element, count: Int) {
  let baseType = base.dynamicType

  SequenceLog.generate.expectIncrement(baseType) { _ = s.generate() }
  SequenceLog.underestimateCount.expectIncrement(baseType) {
    _ = s.underestimateCount()
  }
  SequenceLog._customContainsEquatableElement.expectIncrement(baseType) {
    _ = s._customContainsEquatableElement(arbitraryElement)
  }
  SequenceLog._copyToNativeArrayBuffer.expectIncrement(baseType) {
    _ = s._copyToNativeArrayBuffer()
  }
  
  SequenceLog._initializeTo.expectIncrement(baseType) { ()->Void in
    let buf = UnsafeMutablePointer<S.Generator.Element>.alloc(count)
  
    let end = s._initializeTo(buf)
    expectTrue(end <= buf + count)
    buf.destroy(end - buf)
    buf.dealloc(count)
  }
}

tests.test("LazySequence/Passthrough") {
