| //===----------------------------------------------------------------------===// |
| // |
| // This source file is part of the Swift.org open source project |
| // |
| // Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors |
| // Licensed under Apache License v2.0 with Runtime Library Exception |
| // |
| // See https://swift.org/LICENSE.txt for license information |
| // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors |
| // |
| //===----------------------------------------------------------------------===// |
| |
| protocol Existential { |
| init() |
| func doIt() -> Bool |
| func reallyDoIt() -> Bool |
| mutating func mutateIt() -> Bool |
| } |
| |
| struct IntValueBuffer0 : Existential { |
| func doIt() -> Bool { |
| return true |
| } |
| func reallyDoIt() -> Bool { |
| return true |
| } |
| mutating func mutateIt() -> Bool { |
| return true |
| } |
| } |
| |
| func next(_ x: inout Int, upto mod: Int) { |
| x = (x + 1) % (mod + 1) |
| } |
| |
| struct IntValueBuffer1 : Existential { |
| var f0: Int = 0 |
| |
| func doIt() -> Bool { |
| return f0 == 0 |
| } |
| func reallyDoIt() -> Bool { |
| return true |
| } |
| mutating func mutateIt() -> Bool { |
| next(&f0, upto: 1) |
| return true |
| } |
| } |
| |
| struct IntValueBuffer2 : Existential { |
| var f0: Int = 0 |
| var f1: Int = 3 |
| |
| func doIt() -> Bool { |
| return f0 == 0 |
| } |
| func reallyDoIt() -> Bool { |
| return f0 == 0 && f1 == 3 |
| } |
| mutating func mutateIt() -> Bool { |
| next(&f0, upto: 1) |
| next(&f1, upto: 3) |
| return true |
| } |
| } |
| |
| struct IntValueBuffer3 : Existential { |
| var f0: Int = 0 |
| var f1: Int = 3 |
| var f2: Int = 7 |
| |
| func doIt() -> Bool { |
| return f0 == 0 |
| } |
| func reallyDoIt() -> Bool { |
| return f0 == 0 && f1 == 3 && f2 == 7 |
| } |
| |
| mutating func mutateIt() -> Bool{ |
| next(&f0, upto: 1) |
| next(&f1, upto: 3) |
| next(&f2, upto: 7) |
| return true |
| } |
| } |
| |
| struct IntValueBuffer4 : Existential { |
| var f0: Int = 0 |
| var f1: Int = 3 |
| var f2: Int = 7 |
| var f3: Int = 13 |
| |
| func doIt() -> Bool { |
| return f0 == 0 |
| } |
| func reallyDoIt() -> Bool { |
| return f0 == 0 && f1 == 3 && f2 == 7 && f3 == 13 |
| } |
| |
| mutating func mutateIt() -> Bool{ |
| next(&f0, upto: 1) |
| next(&f1, upto: 3) |
| next(&f2, upto: 7) |
| next(&f3, upto: 13) |
| return true |
| } |
| } |
| |
| class Klazz { |
| var f0: Int = 0 |
| var f1: Int = 3 |
| |
| func doIt() -> Bool { |
| return f0 == 0 |
| } |
| func reallyDoIt() -> Bool { |
| return f0 == 0 && f1 == 3 |
| } |
| |
| func mutateIt() -> Bool{ |
| next(&f0, upto: 1) |
| next(&f1, upto: 3) |
| return true |
| } |
| } |
| |
| struct ClassValueBuffer1 : Existential { |
| var f0: Klazz = Klazz() |
| |
| func doIt() -> Bool { |
| return f0.doIt() |
| } |
| func reallyDoIt() -> Bool { |
| return f0.reallyDoIt() |
| } |
| |
| mutating func mutateIt() -> Bool{ |
| return f0.mutateIt() |
| } |
| } |
| |
| struct ClassValueBuffer2 : Existential { |
| var f0: Klazz = Klazz() |
| var f1: Klazz = Klazz() |
| |
| func doIt() -> Bool { |
| return f0.doIt() |
| } |
| func reallyDoIt() -> Bool { |
| return f0.reallyDoIt() |
| } |
| |
| mutating func mutateIt() -> Bool{ |
| return f0.mutateIt() |
| } |
| } |
| |
| struct ClassValueBuffer3 : Existential { |
| var f0: Klazz = Klazz() |
| var f1: Klazz = Klazz() |
| var f2: Klazz = Klazz() |
| |
| func doIt() -> Bool { |
| return f0.doIt() |
| } |
| func reallyDoIt() -> Bool { |
| return f0.reallyDoIt() |
| } |
| |
| mutating func mutateIt() -> Bool{ |
| return f0.mutateIt() |
| } |
| } |
| |
| struct ClassValueBuffer4 : Existential { |
| var f0: Klazz = Klazz() |
| var f1: Klazz = Klazz() |
| var f2: Klazz = Klazz() |
| var f3: Int = 0 |
| |
| func doIt() -> Bool { |
| return f0.doIt() |
| } |
| |
| func reallyDoIt() -> Bool { |
| return f0.reallyDoIt() |
| } |
| |
| mutating func mutateIt() -> Bool{ |
| return f0.mutateIt() |
| } |
| } |
| |
| |
| @inline(never) |
| func initExistential<T: Existential>(withType: T.Type) -> Existential { |
| return T() |
| } |
| |
| @inline(never) |
| func initExistentialArray<T: Existential>(withType: T.Type, count c: Int) -> [Existential] { |
| return [T](repeating: T(), count: c) |
| } |
| |
| @inline(never) |
| func passExistentialTwiceOneMethodCall(_ e0: Existential, _ e1: Existential) -> Bool { |
| return e0.doIt() && e1.doIt() |
| } |
| |
| @inline(never) |
| func passExistentialTwiceTwoMethodCalls(_ e0: Existential, _ e1: Existential) -> Bool { |
| return e0.doIt() && e1.doIt() && e0.reallyDoIt() && e1.reallyDoIt() |
| } |
| |
| func runTestOneMethodCall<T: Existential>(withType: T.Type, numberOfTimes N: Int) { |
| let existential = initExistential(withType: T.self) |
| for _ in 0 ..< N { |
| for _ in 0 ..< 5_000_000 { |
| if !existential.doIt() { |
| fatalError("expected true") |
| } |
| } |
| } |
| } |
| |
| func runTestTwoMethodCalls<T: Existential>(withType: T.Type, numberOfTimes N: Int) { |
| let existential = initExistential(withType: T.self) |
| for _ in 0 ..< N { |
| for _ in 0 ..< 5_000_000 { |
| if !existential.doIt() || !existential.reallyDoIt() { |
| fatalError("expected true") |
| } |
| } |
| } |
| } |
| |
| func runTestPassExistentialOneMethodCall<T: Existential>(withType: T.Type, numberOfTimes N: Int) { |
| let existential = initExistential(withType: T.self) |
| let existential2 = initExistential(withType: T.self) |
| for _ in 0 ..< N { |
| for _ in 0 ..< 5_000_000 { |
| if !passExistentialTwiceOneMethodCall(existential, existential2) { |
| fatalError("expected true") |
| } |
| } |
| } |
| } |
| |
| func runTestPassExistentialTwoMethodCalls<T: Existential>(withType: T.Type, numberOfTimes N: Int) { |
| let existential = initExistential(withType: T.self) |
| let existential2 = initExistential(withType: T.self) |
| for _ in 0 ..< N { |
| for _ in 0 ..< 5_000_000 { |
| if !passExistentialTwiceTwoMethodCalls(existential, existential2) { |
| fatalError("expected true") |
| } |
| } |
| } |
| } |
| |
| func runTestMutating<T: Existential>(withType: T.Type, numberOfTimes N: Int) { |
| var existential = initExistential(withType: T.self) |
| for _ in 0 ..< N { |
| for _ in 0 ..< 5_000_000 { |
| if !existential.mutateIt() { |
| fatalError("expected true") |
| } |
| } |
| } |
| } |
| |
| func runTestMutatingAndNonMutating<T: Existential>(withType: T.Type, numberOfTimes N: Int) { |
| var existential = initExistential(withType: T.self) |
| for _ in 0 ..< N { |
| for _ in 0 ..< 5_000_000 { |
| let _ = existential.doIt() |
| if !existential.mutateIt() { |
| fatalError("expected true") |
| } |
| } |
| } |
| } |
| |
| func runTestArrayOneMethodCall<T: Existential>(withType: T.Type, numberOfTimes N: Int) { |
| let existentialArray = initExistentialArray(withType: T.self, count: 128) |
| for _ in 0 ..< N { |
| for _ in 0 ..< 5_000 { |
| for elt in existentialArray { |
| if !elt.doIt() { |
| fatalError("expected true") |
| } |
| } |
| } |
| } |
| } |
| |
| func runTestArrayTwoMethodCalls<T: Existential>(withType: T.Type, numberOfTimes N: Int) { |
| let existentialArray = initExistentialArray(withType: T.self, count: 128) |
| for _ in 0 ..< N { |
| for _ in 0 ..< 5_000 { |
| for elt in existentialArray { |
| if !elt.doIt() || !elt.reallyDoIt() { |
| fatalError("expected true") |
| } |
| } |
| } |
| } |
| } |
| |
| func runTestArrayMutating<T: Existential>(withType: T.Type, numberOfTimes N: Int) { |
| var existentialArray = initExistentialArray(withType: T.self, count: 128) |
| for _ in 0 ..< N { |
| for _ in 0 ..< 5_000 { |
| for i in 0 ..< existentialArray.count { |
| if !existentialArray[i].mutateIt() { |
| fatalError("expected true") |
| } |
| } |
| } |
| } |
| } |
| |
| func runTestArrayShift<T: Existential>(withType: T.Type, numberOfTimes N: Int) { |
| var existentialArray = initExistentialArray(withType: T.self, count: 128) |
| for _ in 0 ..< N { |
| for _ in 0 ..< 5_000 { |
| for i in 0 ..< existentialArray.count-1 { |
| existentialArray.swapAt(i, i+1) |
| } |
| } |
| } |
| } |
| func runTestArrayConditionalShift<T: Existential>(withType: T.Type, numberOfTimes N: Int) { |
| var existentialArray = initExistentialArray(withType: T.self, count: 128) |
| for _ in 0 ..< N { |
| for _ in 0 ..< 5_000 { |
| for i in 0 ..< existentialArray.count-1 { |
| let curr = existentialArray[i] |
| if curr.doIt() { |
| existentialArray[i] = existentialArray[i+1] |
| existentialArray[i+1] = curr |
| } |
| } |
| } |
| } |
| } |
| |
| // TestOneMethodCall. |
| public func run_ExistentialTestOneMethodCall_IntValueBuffer0(_ N: Int) { |
| runTestOneMethodCall(withType: IntValueBuffer0.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestOneMethodCall_IntValueBuffer1(_ N: Int) { |
| runTestOneMethodCall(withType: IntValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestOneMethodCall_IntValueBuffer2(_ N: Int) { |
| runTestOneMethodCall(withType: IntValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestOneMethodCall_IntValueBuffer3(_ N: Int) { |
| runTestOneMethodCall(withType: IntValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestOneMethodCall_IntValueBuffer4(_ N: Int) { |
| runTestOneMethodCall(withType: IntValueBuffer4.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestOneMethodCall_ClassValueBuffer1(_ N: Int) { |
| runTestOneMethodCall(withType: ClassValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestOneMethodCall_ClassValueBuffer2(_ N: Int) { |
| runTestOneMethodCall(withType: ClassValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestOneMethodCall_ClassValueBuffer3(_ N: Int) { |
| runTestOneMethodCall(withType: ClassValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestOneMethodCall_ClassValueBuffer4(_ N: Int) { |
| runTestOneMethodCall(withType: ClassValueBuffer4.self, numberOfTimes: N) |
| } |
| |
| // TestTwoMethodCalls. |
| public func run_ExistentialTestTwoMethodCalls_IntValueBuffer0(_ N: Int) { |
| runTestTwoMethodCalls(withType: IntValueBuffer0.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestTwoMethodCalls_IntValueBuffer1(_ N: Int) { |
| runTestTwoMethodCalls(withType: IntValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestTwoMethodCalls_IntValueBuffer2(_ N: Int) { |
| runTestTwoMethodCalls(withType: IntValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestTwoMethodCalls_IntValueBuffer3(_ N: Int) { |
| runTestTwoMethodCalls(withType: IntValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestTwoMethodCalls_IntValueBuffer4(_ N: Int) { |
| runTestTwoMethodCalls(withType: IntValueBuffer4.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestTwoMethodCalls_ClassValueBuffer1(_ N: Int) { |
| runTestTwoMethodCalls(withType: ClassValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestTwoMethodCalls_ClassValueBuffer2(_ N: Int) { |
| runTestTwoMethodCalls(withType: ClassValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestTwoMethodCalls_ClassValueBuffer3(_ N: Int) { |
| runTestTwoMethodCalls(withType: ClassValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestTwoMethodCalls_ClassValueBuffer4(_ N: Int) { |
| runTestTwoMethodCalls(withType: ClassValueBuffer4.self, numberOfTimes: N) |
| } |
| |
| // TestPassExistentialOneMethodCall. |
| public func run_ExistentialTestPassExistentialOneMethodCall_IntValueBuffer0(_ N: Int) { |
| runTestPassExistentialOneMethodCall(withType: IntValueBuffer0.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestPassExistentialOneMethodCall_IntValueBuffer1(_ N: Int) { |
| runTestPassExistentialOneMethodCall(withType: IntValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestPassExistentialOneMethodCall_IntValueBuffer2(_ N: Int) { |
| runTestPassExistentialOneMethodCall(withType: IntValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestPassExistentialOneMethodCall_IntValueBuffer3(_ N: Int) { |
| runTestPassExistentialOneMethodCall(withType: IntValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestPassExistentialOneMethodCall_IntValueBuffer4(_ N: Int) { |
| runTestPassExistentialOneMethodCall(withType: IntValueBuffer4.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestPassExistentialOneMethodCall_ClassValueBuffer1(_ N: Int) { |
| runTestPassExistentialOneMethodCall(withType: ClassValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestPassExistentialOneMethodCall_ClassValueBuffer2(_ N: Int) { |
| runTestPassExistentialOneMethodCall(withType: ClassValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestPassExistentialOneMethodCall_ClassValueBuffer3(_ N: Int) { |
| runTestPassExistentialOneMethodCall(withType: ClassValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestPassExistentialOneMethodCall_ClassValueBuffer4(_ N: Int) { |
| runTestPassExistentialOneMethodCall(withType: ClassValueBuffer4.self, numberOfTimes: N) |
| } |
| |
| // TestPassExistentialTwoMethodCalls. |
| public func run_ExistentialTestPassExistentialTwoMethodCalls_IntValueBuffer0(_ N: Int) { |
| runTestPassExistentialTwoMethodCalls(withType: IntValueBuffer0.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestPassExistentialTwoMethodCalls_IntValueBuffer1(_ N: Int) { |
| runTestPassExistentialTwoMethodCalls(withType: IntValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestPassExistentialTwoMethodCalls_IntValueBuffer2(_ N: Int) { |
| runTestPassExistentialTwoMethodCalls(withType: IntValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestPassExistentialTwoMethodCalls_IntValueBuffer3(_ N: Int) { |
| runTestPassExistentialTwoMethodCalls(withType: IntValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestPassExistentialTwoMethodCalls_IntValueBuffer4(_ N: Int) { |
| runTestPassExistentialTwoMethodCalls(withType: IntValueBuffer4.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestPassExistentialTwoMethodCalls_ClassValueBuffer1(_ N: Int) { |
| runTestPassExistentialTwoMethodCalls(withType: ClassValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestPassExistentialTwoMethodCalls_ClassValueBuffer2(_ N: Int) { |
| runTestPassExistentialTwoMethodCalls(withType: ClassValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestPassExistentialTwoMethodCalls_ClassValueBuffer3(_ N: Int) { |
| runTestPassExistentialTwoMethodCalls(withType: ClassValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestPassExistentialTwoMethodCalls_ClassValueBuffer4(_ N: Int) { |
| runTestPassExistentialTwoMethodCalls(withType: ClassValueBuffer4.self, numberOfTimes: N) |
| } |
| |
| // TestMutating. |
| public func run_ExistentialTestMutating_IntValueBuffer0(_ N: Int) { |
| runTestMutating(withType: IntValueBuffer0.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestMutating_IntValueBuffer1(_ N: Int) { |
| runTestMutating(withType: IntValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestMutating_IntValueBuffer2(_ N: Int) { |
| runTestMutating(withType: IntValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestMutating_IntValueBuffer3(_ N: Int) { |
| runTestMutating(withType: IntValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestMutating_IntValueBuffer4(_ N: Int) { |
| runTestMutating(withType: IntValueBuffer4.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestMutating_ClassValueBuffer1(_ N: Int) { |
| runTestMutating(withType: ClassValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestMutating_ClassValueBuffer2(_ N: Int) { |
| runTestMutating(withType: ClassValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestMutating_ClassValueBuffer3(_ N: Int) { |
| runTestMutating(withType: ClassValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestMutating_ClassValueBuffer4(_ N: Int) { |
| runTestMutating(withType: ClassValueBuffer4.self, numberOfTimes: N) |
| } |
| |
| // TestMutatingAndNonMutating. |
| public func run_ExistentialTestMutatingAndNonMutating_IntValueBuffer0(_ N: Int) { |
| runTestMutatingAndNonMutating(withType: IntValueBuffer0.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestMutatingAndNonMutating_IntValueBuffer1(_ N: Int) { |
| runTestMutatingAndNonMutating(withType: IntValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestMutatingAndNonMutating_IntValueBuffer2(_ N: Int) { |
| runTestMutatingAndNonMutating(withType: IntValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestMutatingAndNonMutating_IntValueBuffer3(_ N: Int) { |
| runTestMutatingAndNonMutating(withType: IntValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestMutatingAndNonMutating_IntValueBuffer4(_ N: Int) { |
| runTestMutatingAndNonMutating(withType: IntValueBuffer4.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestMutatingAndNonMutating_ClassValueBuffer1(_ N: Int) { |
| runTestMutatingAndNonMutating(withType: ClassValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestMutatingAndNonMutating_ClassValueBuffer2(_ N: Int) { |
| runTestMutatingAndNonMutating(withType: ClassValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestMutatingAndNonMutating_ClassValueBuffer3(_ N: Int) { |
| runTestMutatingAndNonMutating(withType: ClassValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestMutatingAndNonMutating_ClassValueBuffer4(_ N: Int) { |
| runTestMutatingAndNonMutating(withType: ClassValueBuffer4.self, numberOfTimes: N) |
| } |
| |
| // TestArrayOneMethodCall. |
| public func run_ExistentialTestArrayOneMethodCall_IntValueBuffer0(_ N: Int) { |
| runTestArrayOneMethodCall(withType: IntValueBuffer0.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayOneMethodCall_IntValueBuffer1(_ N: Int) { |
| runTestArrayOneMethodCall(withType: IntValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayOneMethodCall_IntValueBuffer2(_ N: Int) { |
| runTestArrayOneMethodCall(withType: IntValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayOneMethodCall_IntValueBuffer3(_ N: Int) { |
| runTestArrayOneMethodCall(withType: IntValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayOneMethodCall_IntValueBuffer4(_ N: Int) { |
| runTestArrayOneMethodCall(withType: IntValueBuffer4.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayOneMethodCall_ClassValueBuffer1(_ N: Int) { |
| runTestArrayOneMethodCall(withType: ClassValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayOneMethodCall_ClassValueBuffer2(_ N: Int) { |
| runTestArrayOneMethodCall(withType: ClassValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayOneMethodCall_ClassValueBuffer3(_ N: Int) { |
| runTestArrayOneMethodCall(withType: ClassValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayOneMethodCall_ClassValueBuffer4(_ N: Int) { |
| runTestArrayOneMethodCall(withType: ClassValueBuffer4.self, numberOfTimes: N) |
| } |
| |
| // TestArrayTwoMethodCalls. |
| public func run_ExistentialTestArrayTwoMethodCalls_IntValueBuffer0(_ N: Int) { |
| runTestArrayTwoMethodCalls(withType: IntValueBuffer0.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayTwoMethodCalls_IntValueBuffer1(_ N: Int) { |
| runTestArrayTwoMethodCalls(withType: IntValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayTwoMethodCalls_IntValueBuffer2(_ N: Int) { |
| runTestArrayTwoMethodCalls(withType: IntValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayTwoMethodCalls_IntValueBuffer3(_ N: Int) { |
| runTestArrayTwoMethodCalls(withType: IntValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayTwoMethodCalls_IntValueBuffer4(_ N: Int) { |
| runTestArrayTwoMethodCalls(withType: IntValueBuffer4.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayTwoMethodCalls_ClassValueBuffer1(_ N: Int) { |
| runTestArrayTwoMethodCalls(withType: ClassValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayTwoMethodCalls_ClassValueBuffer2(_ N: Int) { |
| runTestArrayTwoMethodCalls(withType: ClassValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayTwoMethodCalls_ClassValueBuffer3(_ N: Int) { |
| runTestArrayTwoMethodCalls(withType: ClassValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayTwoMethodCalls_ClassValueBuffer4(_ N: Int) { |
| runTestArrayTwoMethodCalls(withType: ClassValueBuffer4.self, numberOfTimes: N) |
| } |
| |
| // TestArrayMutating. |
| public func run_ExistentialTestArrayMutating_IntValueBuffer0(_ N: Int) { |
| runTestArrayMutating(withType: IntValueBuffer0.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayMutating_IntValueBuffer1(_ N: Int) { |
| runTestArrayMutating(withType: IntValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayMutating_IntValueBuffer2(_ N: Int) { |
| runTestArrayMutating(withType: IntValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayMutating_IntValueBuffer3(_ N: Int) { |
| runTestArrayMutating(withType: IntValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayMutating_IntValueBuffer4(_ N: Int) { |
| runTestArrayMutating(withType: IntValueBuffer4.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayMutating_ClassValueBuffer1(_ N: Int) { |
| runTestArrayMutating(withType: ClassValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayMutating_ClassValueBuffer2(_ N: Int) { |
| runTestArrayMutating(withType: ClassValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayMutating_ClassValueBuffer3(_ N: Int) { |
| runTestArrayMutating(withType: ClassValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayMutating_ClassValueBuffer4(_ N: Int) { |
| runTestArrayMutating(withType: ClassValueBuffer4.self, numberOfTimes: N) |
| } |
| |
| // TestArrayShift. |
| public func run_ExistentialTestArrayShift_IntValueBuffer0(_ N: Int) { |
| runTestArrayShift(withType: IntValueBuffer0.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayShift_IntValueBuffer1(_ N: Int) { |
| runTestArrayShift(withType: IntValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayShift_IntValueBuffer2(_ N: Int) { |
| runTestArrayShift(withType: IntValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayShift_IntValueBuffer3(_ N: Int) { |
| runTestArrayShift(withType: IntValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayShift_IntValueBuffer4(_ N: Int) { |
| runTestArrayShift(withType: IntValueBuffer4.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayShift_ClassValueBuffer1(_ N: Int) { |
| runTestArrayShift(withType: ClassValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayShift_ClassValueBuffer2(_ N: Int) { |
| runTestArrayShift(withType: ClassValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayShift_ClassValueBuffer3(_ N: Int) { |
| runTestArrayShift(withType: ClassValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayShift_ClassValueBuffer4(_ N: Int) { |
| runTestArrayShift(withType: ClassValueBuffer4.self, numberOfTimes: N) |
| } |
| |
| // TestArrayConditionalShift. |
| public func run_ExistentialTestArrayConditionalShift_IntValueBuffer0(_ N: Int) { |
| runTestArrayConditionalShift(withType: IntValueBuffer0.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayConditionalShift_IntValueBuffer1(_ N: Int) { |
| runTestArrayConditionalShift(withType: IntValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayConditionalShift_IntValueBuffer2(_ N: Int) { |
| runTestArrayConditionalShift(withType: IntValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayConditionalShift_IntValueBuffer3(_ N: Int) { |
| runTestArrayConditionalShift(withType: IntValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayConditionalShift_IntValueBuffer4(_ N: Int) { |
| runTestArrayConditionalShift(withType: IntValueBuffer4.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayConditionalShift_ClassValueBuffer1(_ N: Int) { |
| runTestArrayConditionalShift(withType: ClassValueBuffer1.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayConditionalShift_ClassValueBuffer2(_ N: Int) { |
| runTestArrayConditionalShift(withType: ClassValueBuffer2.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayConditionalShift_ClassValueBuffer3(_ N: Int) { |
| runTestArrayConditionalShift(withType: ClassValueBuffer3.self, numberOfTimes: N) |
| } |
| public func run_ExistentialTestArrayConditionalShift_ClassValueBuffer4(_ N: Int) { |
| runTestArrayConditionalShift(withType: ClassValueBuffer4.self, numberOfTimes: N) |
| } |