 struct Test {
   let benchInfo: BenchmarkInfo
   let index: Int
-  let run: Bool
 
   var name: String {
     return benchInfo.name

  sumBenchResults.sampleCount = 0

  for t in c.tests {
    if !t.run {
      continue
    }

    let benchIndex = t.index
    let benchName = t.name
    let results = runBench(benchName, t.runFunction, c)

      }
    }

    let benchmarkNameFilter: Set<String>? = {
      if !filters.isEmpty {
        return Set(filters)
      }

      if onlyPrecommit {
        return Set(precommitTests.map { $0.name })
      }

      return nil
    }()

    // t is needed so we don't capture an ivar of a mutable inout self.
    let t = tags
    var filteredTests = allTests.filter {
      benchInfo in
      if !t.isSubset(of: benchInfo.tags) {
        return false
      }

      // If the user did not specified a benchmark name filter and our tags are
      // a subset of the specified tags by the user, return true. We want to run
      // this test.
      guard let benchFilter = benchmarkNameFilter else {
        return true
      }

      // Otherwise, we need to check if our benchInfo's name is in the benchmark
      // name filter list. If it isn't, then we shouldn't process it.
      return benchFilter.contains(benchInfo.name)
    }.map { $0 }.sorted()

    if (filteredTests.isEmpty) {
      return
    }

    tests = zip(1...filteredTests.count, filteredTests).map {
      t -> Test in
      let (ordinal, benchInfo) = t
      return Test(benchInfo: benchInfo, index: ordinal)
    }
  }
}
