mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
e83c117c30
This decreases total testing time by over a minute on my old Mac Pro. It probably has much less effect on systems with fewer cores, but shouldn't be any worse there. Swift SVN r22745
174 lines
4.1 KiB
Swift
174 lines
4.1 KiB
Swift
//===--- Index.swift - tests for Index types and operations ---------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See http://swift.org/LICENSE.txt for license information
|
|
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
// RUN: %target-run-simple-swift | FileCheck %s
|
|
|
|
struct F : ForwardIndexType {
|
|
var x: Int
|
|
|
|
init(_ x: Int) {
|
|
self.x = x
|
|
}
|
|
|
|
func successor() -> F {
|
|
println("F.successor: \(x)")
|
|
return F(x + 1)
|
|
}
|
|
}
|
|
|
|
func ==(a: F, b: F) -> Bool {
|
|
return a.x == b.x
|
|
}
|
|
|
|
struct B : BidirectionalIndexType {
|
|
var x: Int
|
|
|
|
init(_ x: Int) {
|
|
self.x = x
|
|
}
|
|
|
|
func successor() -> B {
|
|
println("B.successor: \(x)")
|
|
return B(x + 1)
|
|
}
|
|
func predecessor() -> B {
|
|
println("B.predecessor: \(x)")
|
|
return B(x - 1)
|
|
}
|
|
}
|
|
|
|
func ==(a: B, b: B) -> Bool {
|
|
return a.x == b.x
|
|
}
|
|
|
|
struct R : RandomAccessIndexType {
|
|
var x: Int
|
|
|
|
init(_ x: Int) {
|
|
self.x = x
|
|
}
|
|
|
|
func successor() -> R {
|
|
println("R.successor: \(x)")
|
|
return R(x + 1)
|
|
}
|
|
func predecessor() -> R {
|
|
println("R.predecessor: \(x)")
|
|
return R(x - 1)
|
|
}
|
|
func distanceTo(rhs: R) -> Int {
|
|
println("R.distanceTo: \(x), \(rhs.x)")
|
|
return rhs.x - x
|
|
}
|
|
func advancedBy(n: Int) -> R {
|
|
println("R.advancedBy: \(x), \(n)")
|
|
return R(x + n)
|
|
}
|
|
}
|
|
|
|
func ==(a: R, b: R) -> Bool {
|
|
return a.x == b.x
|
|
}
|
|
|
|
println("testing...")
|
|
// CHECK: testing...
|
|
|
|
println("<F>")
|
|
// CHECK-NEXT: <F>
|
|
println("[\(distance(F(10), F(10)))]")
|
|
// CHECK-NEXT: [0]
|
|
println("[\(distance(F(10), F(13)))]")
|
|
// CHECK-NEXT: F.successor: 10
|
|
// CHECK-NEXT: F.successor: 11
|
|
// CHECK-NEXT: F.successor: 12
|
|
// CHECK-NEXT: [3]
|
|
println("[\(advance(F(7), 0).x)]")
|
|
// CHECK-NEXT: [7]
|
|
println("[\(advance(F(7), 2).x)]")
|
|
// CHECK-NEXT: F.successor: 7
|
|
// CHECK-NEXT: F.successor: 8
|
|
// CHECK-NEXT: [9]
|
|
println("[\(advance(F(3), 99, F(5)).x)]")
|
|
// CHECK-NEXT: F.successor: 3
|
|
// CHECK-NEXT: F.successor: 4
|
|
// CHECK-NEXT: [5]
|
|
|
|
println("<B>")
|
|
// CHECK-NEXT: <B>
|
|
println("[\(distance(B(10), B(10)))]")
|
|
// CHECK-NEXT: [0]
|
|
println("[\(distance(B(10), B(12)))]")
|
|
// CHECK-NEXT: B.successor: 10
|
|
// CHECK-NEXT: B.successor: 11
|
|
// CHECK-NEXT: [2]
|
|
println("[\(advance(B(7), 2).x)]")
|
|
// CHECK-NEXT: B.successor: 7
|
|
// CHECK-NEXT: B.successor: 8
|
|
// CHECK-NEXT: [9]
|
|
println("[\(advance(B(7), -3).x)]")
|
|
// CHECK-NEXT: B.predecessor: 7
|
|
// CHECK-NEXT: B.predecessor: 6
|
|
// CHECK-NEXT: B.predecessor: 5
|
|
// CHECK-NEXT: [4]
|
|
println("[\(advance(B(13), 0, B(17)).x)]")
|
|
// CHECK-NEXT: [13]
|
|
println("[\(advance(B(13), 99, B(17)).x)]")
|
|
// CHECK-NEXT: B.successor: 13
|
|
// CHECK-NEXT: B.successor: 14
|
|
// CHECK-NEXT: B.successor: 15
|
|
// CHECK-NEXT: B.successor: 16
|
|
// CHECK-NEXT: [17]
|
|
println("[\(advance(B(13), -99, B(11)).x)]")
|
|
// CHECK-NEXT: B.predecessor: 13
|
|
// CHECK-NEXT: B.predecessor: 12
|
|
// CHECK-NEXT: [11]
|
|
|
|
|
|
println("<R>")
|
|
// CHECK-NEXT: <R>
|
|
println("[\(distance(R(10), R(10)))]")
|
|
// CHECK-NEXT: R.distanceTo: 10, 10
|
|
// CHECK-NEXT: [0]
|
|
println("[\(distance(R(10), R(20)))]")
|
|
// CHECK-NEXT: R.distanceTo: 10, 20
|
|
// CHECK-NEXT: [10]
|
|
println("[\(advance(R(7), 2).x)]")
|
|
// CHECK-NEXT: R.advancedBy: 7, 2
|
|
// CHECK-NEXT: [9]
|
|
println("[\(advance(R(13), 99, R(17)).x)]")
|
|
// CHECK-NEXT: R.distanceTo: 13, 17
|
|
// CHECK-NEXT: [17]
|
|
println("[\(advance(R(13), 3, R(17)).x)]")
|
|
// CHECK-NEXT: R.distanceTo: 13, 17
|
|
// CHECK-NEXT: R.advancedBy: 13, 3
|
|
// CHECK-NEXT: [16]
|
|
println("[\(advance(R(13), -99, R(10)).x)]")
|
|
// CHECK-NEXT: R.distanceTo: 13, 10
|
|
// CHECK-NEXT: [10]
|
|
println("[\(advance(R(13), -3, R(0)).x)]")
|
|
// CHECK-NEXT: R.distanceTo: 13, 0
|
|
// CHECK-NEXT: R.advancedBy: 13, -3
|
|
// CHECK-NEXT: [10]
|
|
|
|
// Tests for advancing away from the end bound.
|
|
println("[\(advance(R(13), -99, R(16)).x)]")
|
|
// CHECK-NEXT: R.distanceTo: 13, 16
|
|
// CHECK-NEXT: R.advancedBy: 13, -99
|
|
// CHECK-NEXT: [-86]
|
|
println("[\(advance(R(16), 99, R(13)).x)]")
|
|
// CHECK-NEXT: R.distanceTo: 16, 13
|
|
// CHECK-NEXT: R.advancedBy: 16, 99
|
|
// CHECK-NEXT: [115]
|
|
|
|
println("all done.")
|
|
// CHECK-NEXT: all done.
|
|
|