averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-14 20:36:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

Suppress warnings in benchmark

Browse Source 
warning: heterogeneous collection literal could only be inferred to '[Any]'; add explicit type annotation if this is intentional
This commit is contained in:
Valeriy Van
2023-01-18 21:28:29 +02:00
parent 12719bc896
commit a5b1082ba3
1 changed files with 58 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
benchmark/single-source/SetTests.swift
View File

@@ -139,42 +139,42 @@ public let benchmarks = [
name: "Set.isSubset.Seq.Empty.Int",
runFunction: { n in run_SetIsSubsetSeqInt(setE, arrayAB, true, 5000 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setE, arrayAB]) }),
setUpFunction: { blackHole([setE, arrayAB] as [Any]) }),
BenchmarkInfo(
name: "Set.isSubset.Seq.Int.Empty",
runFunction: { n in run_SetIsSubsetSeqInt(setAB, arrayE, false, 5000 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setAB, arrayE]) }),
setUpFunction: { blackHole([setAB, arrayE] as [Any]) }),
BenchmarkInfo(
name: "Set.isSubset.Seq.Int0",
runFunction: { n in run_SetIsSubsetSeqInt(setAB, arrayCD, false, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setAB, arrayCD]) }),
setUpFunction: { blackHole([setAB, arrayCD] as [Any]) }),
BenchmarkInfo(
name: "Set.isSubset.Seq.Box0",
runFunction: { n in run_SetIsSubsetSeqBox(setOAB, arrayOCD, false, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setOAB, arrayOCD]) }),
setUpFunction: { blackHole([setOAB, arrayOCD] as [Any]) }),
BenchmarkInfo(
name: "Set.isSubset.Seq.Int25",
runFunction: { n in run_SetIsSubsetSeqInt(setB, arrayBC, true, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setB, arrayBC]) }),
setUpFunction: { blackHole([setB, arrayBC] as [Any]) }),
BenchmarkInfo(
name: "Set.isSubset.Seq.Box25",
runFunction: { n in run_SetIsSubsetSeqBox(setOB, arrayOBC, true, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setOB, arrayOBC]) }),
setUpFunction: { blackHole([setOB, arrayOBC] as [Any]) }),
BenchmarkInfo(
name: "Set.isSubset.Seq.Int50",
runFunction: { n in run_SetIsSubsetSeqInt(setY, arrayYZ, true, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setY, arrayYZ]) }),
setUpFunction: { blackHole([setY, arrayYZ] as [Any]) }),
BenchmarkInfo(
name: "Set.isSubset.Seq.Int100",
runFunction: { n in run_SetIsSubsetSeqInt(setP, arrayP, true, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setP, arrayP]) }),
setUpFunction: { blackHole([setP, arrayP] as [Any]) }),
BenchmarkInfo(
name: "Set.isStrictSubset.Empty.Int",
@@ -221,124 +221,124 @@ public let benchmarks = [
name: "Set.isStrictSubset.Seq.Empty.Int",
runFunction: { n in run_SetIsStrictSubsetSeqInt(setE, arrayAB, true, 5000 * n) },
tags: [.validation, .api, .Set, .skip],
setUpFunction: { blackHole([setE, arrayAB]) }),
setUpFunction: { blackHole([setE, arrayAB] as [Any]) }),
BenchmarkInfo(
name: "Set.isStrictSubset.Seq.Int.Empty",
runFunction: { n in run_SetIsStrictSubsetSeqInt(setAB, arrayE, false, 5000 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setAB, arrayE]) }),
setUpFunction: { blackHole([setAB, arrayE] as [Any]) }),
BenchmarkInfo(
name: "Set.isStrictSubset.Seq.Int0",
runFunction: { n in run_SetIsStrictSubsetSeqInt(setAB, arrayCD, false, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setAB, arrayCD]) }),
setUpFunction: { blackHole([setAB, arrayCD] as [Any]) }),
BenchmarkInfo(
name: "Set.isStrictSubset.Seq.Box0",
runFunction: { n in run_SetIsStrictSubsetSeqBox(setOAB, arrayOCD, false, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setOAB, arrayOCD]) }),
setUpFunction: { blackHole([setOAB, arrayOCD] as [Any]) }),
BenchmarkInfo(
name: "Set.isStrictSubset.Seq.Int25",
runFunction: { n in run_SetIsStrictSubsetSeqInt(setB, arrayBC, true, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setB, arrayBC]) }),
setUpFunction: { blackHole([setB, arrayBC] as [Any]) }),
BenchmarkInfo(
name: "Set.isStrictSubset.Seq.Box25",
runFunction: { n in run_SetIsStrictSubsetSeqBox(setOB, arrayOBC, true, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setOB, arrayOBC]) }),
setUpFunction: { blackHole([setOB, arrayOBC] as [Any]) }),
BenchmarkInfo(
name: "Set.isStrictSubset.Seq.Int50",
runFunction: { n in run_SetIsStrictSubsetSeqInt(setY, arrayYZ, true, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setY, arrayYZ]) }),
setUpFunction: { blackHole([setY, arrayYZ] as [Any]) }),
BenchmarkInfo(
name: "Set.isStrictSubset.Seq.Int100",
runFunction: { n in run_SetIsStrictSubsetSeqInt(setP, arrayP, false, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setP, arrayP]) }),
setUpFunction: { blackHole([setP, arrayP] as [Any]) }),
BenchmarkInfo(
name: "Set.isSuperset.Seq.Empty.Int",
runFunction: { n in run_SetIsSupersetSeqInt(setAB, arrayE, true, 5000 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setAB, arrayE]) }),
setUpFunction: { blackHole([setAB, arrayE] as [Any]) }),
BenchmarkInfo(
name: "Set.isSuperset.Seq.Int.Empty",
runFunction: { n in run_SetIsSupersetSeqInt(setE, arrayAB, false, 5000 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setE, arrayAB]) }),
setUpFunction: { blackHole([setE, arrayAB] as [Any]) }),
BenchmarkInfo(
name: "Set.isSuperset.Seq.Int0",
runFunction: { n in run_SetIsSupersetSeqInt(setCD, arrayAB, false, 5000 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setCD, arrayAB]) }),
setUpFunction: { blackHole([setCD, arrayAB] as [Any]) }),
BenchmarkInfo(
name: "Set.isSuperset.Seq.Box0",
runFunction: { n in run_SetIsSupersetSeqBox(setOCD, arrayOAB, false, 5000 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setOCD, arrayOAB]) }),
setUpFunction: { blackHole([setOCD, arrayOAB] as [Any]) }),
BenchmarkInfo(
name: "Set.isSuperset.Seq.Int25",
runFunction: { n in run_SetIsSupersetSeqInt(setB, arrayBC, false, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setB, arrayBC]) }),
setUpFunction: { blackHole([setB, arrayBC] as [Any]) }),
BenchmarkInfo(
name: "Set.isSuperset.Seq.Box25",
runFunction: { n in run_SetIsSupersetSeqBox(setOB, arrayOBC, false, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setOB, arrayOBC]) }),
setUpFunction: { blackHole([setOB, arrayOBC] as [Any]) }),
BenchmarkInfo(
name: "Set.isSuperset.Seq.Int50",
runFunction: { n in run_SetIsSupersetSeqInt(setY, arrayYZ, false, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setY, arrayYZ]) }),
setUpFunction: { blackHole([setY, arrayYZ] as [Any]) }),
BenchmarkInfo(
name: "Set.isSuperset.Seq.Int100",
runFunction: { n in run_SetIsSupersetSeqInt(setP, arrayP, true, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setP, arrayP]) }),
setUpFunction: { blackHole([setP, arrayP] as [Any]) }),
BenchmarkInfo(
name: "Set.isStrictSuperset.Seq.Empty.Int",
runFunction: { n in run_SetIsStrictSupersetSeqInt(setAB, arrayE, true, 5000 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setAB, arrayE]) }),
setUpFunction: { blackHole([setAB, arrayE] as [Any]) }),
BenchmarkInfo(
name: "Set.isStrictSuperset.Seq.Int.Empty",
runFunction: { n in run_SetIsStrictSupersetSeqInt(setE, arrayAB, false, 5000 * n) },
tags: [.validation, .api, .Set, .skip],
setUpFunction: { blackHole([setE, arrayAB]) }),
setUpFunction: { blackHole([setE, arrayAB] as [Any]) }),
BenchmarkInfo(
name: "Set.isStrictSuperset.Seq.Int0",
runFunction: { n in run_SetIsStrictSupersetSeqInt(setCD, arrayAB, false, 500 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setCD, arrayAB]) }),
setUpFunction: { blackHole([setCD, arrayAB] as [Any]) }),
BenchmarkInfo(
name: "Set.isStrictSuperset.Seq.Box0",
runFunction: { n in run_SetIsStrictSupersetSeqBox(setOCD, arrayOAB, false, 500 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setOCD, arrayOAB]) }),
setUpFunction: { blackHole([setOCD, arrayOAB] as [Any]) }),
BenchmarkInfo(
name: "Set.isStrictSuperset.Seq.Int25",
runFunction: { n in run_SetIsStrictSupersetSeqInt(setB, arrayBC, false, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setB, arrayBC]) }),
setUpFunction: { blackHole([setB, arrayBC] as [Any]) }),
BenchmarkInfo(
name: "Set.isStrictSuperset.Seq.Box25",
runFunction: { n in run_SetIsStrictSupersetSeqBox(setOB, arrayOBC, false, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setOB, arrayOBC]) }),
setUpFunction: { blackHole([setOB, arrayOBC] as [Any]) }),
BenchmarkInfo(
name: "Set.isStrictSuperset.Seq.Int50",
runFunction: { n in run_SetIsStrictSupersetSeqInt(setY, arrayYZ, false, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setY, arrayYZ]) }),
setUpFunction: { blackHole([setY, arrayYZ] as [Any]) }),
BenchmarkInfo(
name: "Set.isStrictSuperset.Seq.Int100",
runFunction: { n in run_SetIsStrictSupersetSeqInt(setP, arrayP, false, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setP, arrayP]) }),
setUpFunction: { blackHole([setP, arrayP] as [Any]) }),
BenchmarkInfo(
name: "Set.isDisjoint.Empty.Int",
@@ -405,52 +405,52 @@ public let benchmarks = [
name: "Set.isDisjoint.Seq.Empty.Int",
runFunction: { n in run_SetIsDisjointSeqInt(setE, arrayAB, true, 5000 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setE, arrayAB]) }),
setUpFunction: { blackHole([setE, arrayAB] as [Any]) }),
BenchmarkInfo(
name: "Set.isDisjoint.Seq.Int.Empty",
runFunction: { n in run_SetIsDisjointSeqInt(setAB, arrayE, true, 5000 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setAB, arrayE]) }),
setUpFunction: { blackHole([setAB, arrayE] as [Any]) }),
BenchmarkInfo(
name: "Set.isDisjoint.Seq.Empty.Box",
runFunction: { n in run_SetIsDisjointSeqBox(setOE, arrayOAB, true, 5000 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setOE, arrayOAB]) }),
setUpFunction: { blackHole([setOE, arrayOAB] as [Any]) }),
BenchmarkInfo(
name: "Set.isDisjoint.Seq.Box.Empty",
runFunction: { n in run_SetIsDisjointSeqBox(setOAB, arrayOE, true, 5000 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setOAB, arrayOE]) }),
setUpFunction: { blackHole([setOAB, arrayOE] as [Any]) }),
BenchmarkInfo(
name: "Set.isDisjoint.Seq.Int0",
runFunction: { n in run_SetIsDisjointSeqInt(setAB, arrayCD, true, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setAB, arrayCD]) }),
setUpFunction: { blackHole([setAB, arrayCD] as [Any]) }),
BenchmarkInfo(
name: "Set.isDisjoint.Seq.Box0",
runFunction: { n in run_SetIsDisjointSeqBox(setOAB, arrayOCD, true, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setOAB, arrayOCD]) }),
setUpFunction: { blackHole([setOAB, arrayOCD] as [Any]) }),
BenchmarkInfo(
name: "Set.isDisjoint.Seq.Int25",
runFunction: { n in run_SetIsDisjointSeqInt(setB, arrayAB, false, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setB, arrayAB]) }),
setUpFunction: { blackHole([setB, arrayAB] as [Any]) }),
BenchmarkInfo(
name: "Set.isDisjoint.Seq.Box25",
runFunction: { n in run_SetIsDisjointSeqBox(setOB, arrayOAB, false, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setOB, arrayOAB]) }),
setUpFunction: { blackHole([setOB, arrayOAB] as [Any]) }),
BenchmarkInfo(
name: "Set.isDisjoint.Seq.Int50",
runFunction: { n in run_SetIsDisjointSeqInt(setY, arrayXY, false, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setY, arrayXY]) }),
setUpFunction: { blackHole([setY, arrayXY] as [Any]) }),
BenchmarkInfo(
name: "Set.isDisjoint.Seq.Int100",
runFunction: { n in run_SetIsDisjointSeqInt(setP, arrayP, false, 5000 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setP, arrayP]) }),
setUpFunction: { blackHole([setP, arrayP] as [Any]) }),
BenchmarkInfo(
name: "SetSymmetricDifferenceInt0",
@@ -518,32 +518,32 @@ public let benchmarks = [
name: "Set.intersection.Seq.Int0",
runFunction: { n in run_SetIntersectionSeqInt(setAB, arrayCD, 0, 10 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setAB, arrayCD]) }),
setUpFunction: { blackHole([setAB, arrayCD] as [Any]) }),
BenchmarkInfo(
name: "Set.intersection.Seq.Box0",
runFunction: { n in run_SetIntersectionSeqBox(setOAB, arrayOCD, 0, 10 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setOAB, arrayOCD]) }),
setUpFunction: { blackHole([setOAB, arrayOCD] as [Any]) }),
BenchmarkInfo(
name: "Set.intersection.Seq.Int25",
runFunction: { n in run_SetIntersectionSeqInt(setAB, arrayBC, countB, 10 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setAB, arrayBC]) }),
setUpFunction: { blackHole([setAB, arrayBC] as [Any]) }),
BenchmarkInfo(
name: "Set.intersection.Seq.Box25",
runFunction: { n in run_SetIntersectionSeqBox(setOAB, arrayOBC, countB, 10 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setOAB, arrayOBC]) }),
setUpFunction: { blackHole([setOAB, arrayOBC] as [Any]) }),
BenchmarkInfo(
name: "Set.intersection.Seq.Int50",
runFunction: { n in run_SetIntersectionSeqInt(setXY, arrayYZ, half, 10 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setXY, arrayYZ]) }),
setUpFunction: { blackHole([setXY, arrayYZ] as [Any]) }),
BenchmarkInfo(
name: "Set.intersection.Seq.Int100",
runFunction: { n in run_SetIntersectionSeqInt(setP, arrayP, size, 10 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setP, arrayP]) }),
setUpFunction: { blackHole([setP, arrayP] as [Any]) }),
BenchmarkInfo(
name: "SetUnionInt0",
@@ -631,52 +631,52 @@ public let benchmarks = [
name: "Set.subtracting.Seq.Empty.Int",
runFunction: { n in run_SetSubtractingSeqInt(setE, arrayAB, 0, 5000 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setE, arrayAB]) }),
setUpFunction: { blackHole([setE, arrayAB] as [Any]) }),
BenchmarkInfo(
name: "Set.subtracting.Seq.Int.Empty",
runFunction: { n in run_SetSubtractingSeqInt(setAB, arrayE, countAB, 5000 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setAB, arrayE]) }),
setUpFunction: { blackHole([setAB, arrayE] as [Any]) }),
BenchmarkInfo(
name: "Set.subtracting.Seq.Empty.Box",
runFunction: { n in run_SetSubtractingSeqBox(setOE, arrayOAB, 0, 5000 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setOE, arrayOAB]) }),
setUpFunction: { blackHole([setOE, arrayOAB] as [Any]) }),
BenchmarkInfo(
name: "Set.subtracting.Seq.Box.Empty",
runFunction: { n in run_SetSubtractingSeqBox(setOAB, arrayOE, countAB, 5000 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setOAB, arrayOE]) }),
setUpFunction: { blackHole([setOAB, arrayOE] as [Any]) }),
BenchmarkInfo(
name: "Set.subtracting.Seq.Int0",
runFunction: { n in run_SetSubtractingSeqInt(setAB, arrayCD, countAB, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setAB, arrayCD]) }),
setUpFunction: { blackHole([setAB, arrayCD] as [Any]) }),
BenchmarkInfo(
name: "Set.subtracting.Seq.Box0",
runFunction: { n in run_SetSubtractingSeqBox(setOAB, arrayOCD, countAB, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setOAB, arrayOCD]) }),
setUpFunction: { blackHole([setOAB, arrayOCD] as [Any]) }),
BenchmarkInfo(
name: "Set.subtracting.Seq.Int25",
runFunction: { n in run_SetSubtractingSeqInt(setAB, arrayBC, countA, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setAB, arrayBC]) }),
setUpFunction: { blackHole([setAB, arrayBC] as [Any]) }),
BenchmarkInfo(
name: "Set.subtracting.Seq.Box25",
runFunction: { n in run_SetSubtractingSeqBox(setOAB, arrayOBC, countA, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setOAB, arrayOBC]) }),
setUpFunction: { blackHole([setOAB, arrayOBC] as [Any]) }),
BenchmarkInfo(
name: "Set.subtracting.Seq.Int50",
runFunction: { n in run_SetSubtractingSeqInt(setXY, arrayYZ, half, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setXY, arrayYZ]) }),
setUpFunction: { blackHole([setXY, arrayYZ] as [Any]) }),
BenchmarkInfo(
name: "Set.subtracting.Seq.Int100",
runFunction: { n in run_SetSubtractingSeqInt(setP, arrayP, 0, 50 * n) },
tags: [.validation, .api, .Set],
setUpFunction: { blackHole([setP, arrayP]) }),
setUpFunction: { blackHole([setP, arrayP] as [Any]) }),
BenchmarkInfo(
name: "Set.filter.Int50.16k",