mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
dc5915cdb5
* Replace stdlib and test/stdlib 9999 availability. macOS 9999 -> macOS 10.15 iOS 9999 -> iOS 13 tvOS 9999 -> tvOS 13 watchOS 9999 -> watchOS 6 * Restore the pre-10.15 version of public init?(_: NSRange, in: __shared String) We need this to allow master to work on 10.14 systems (in particular, to allow PR testing to work correctly without disabling back-deployment tests).
245 lines
10 KiB
Swift
245 lines
10 KiB
Swift
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// RUN: %target-run-simple-swift
|
|
// REQUIRES: executable_test
|
|
// REQUIRES: objc_interop
|
|
|
|
import Foundation
|
|
|
|
#if FOUNDATION_XCTEST
|
|
import XCTest
|
|
class TestMeasurementSuper : XCTestCase { }
|
|
#else
|
|
import StdlibUnittest
|
|
class TestMeasurementSuper { }
|
|
#endif
|
|
|
|
// We define our own units here so that we can have closer control over checking the behavior of just struct Measurement and not the rest of Foundation
|
|
@available(OSX 10.12, iOS 10.0, watchOS 3.0, tvOS 10.0, *)
|
|
class MyDimensionalUnit : Dimension {
|
|
class var unitA : MyDimensionalUnit {
|
|
return MyDimensionalUnit(symbol: "a", converter: UnitConverterLinear(coefficient: 1))
|
|
}
|
|
class var unitKiloA : MyDimensionalUnit {
|
|
return MyDimensionalUnit(symbol: "ka", converter: UnitConverterLinear(coefficient: 1_000))
|
|
}
|
|
class var unitMegaA : MyDimensionalUnit {
|
|
return MyDimensionalUnit(symbol: "Ma", converter: UnitConverterLinear(coefficient: 1_000_000))
|
|
}
|
|
override class func baseUnit() -> MyDimensionalUnit {
|
|
return MyDimensionalUnit.unitA
|
|
}
|
|
}
|
|
|
|
@available(OSX 10.12, iOS 10.0, watchOS 3.0, tvOS 10.0, *)
|
|
class CustomUnit : Unit {
|
|
override init(symbol: String) {
|
|
super.init(symbol: symbol)
|
|
}
|
|
|
|
required init?(coder aDecoder: NSCoder) {
|
|
super.init(coder: aDecoder)
|
|
}
|
|
|
|
public static let bugs = CustomUnit(symbol: "bug")
|
|
public static let features = CustomUnit(symbol: "feature")
|
|
}
|
|
|
|
@available(OSX 10.12, iOS 10.0, watchOS 3.0, tvOS 10.0, *)
|
|
class TestMeasurement : TestMeasurementSuper {
|
|
|
|
func testBasicConstruction() {
|
|
let m1 = Measurement(value: 3, unit: MyDimensionalUnit.unitA)
|
|
let m2 = Measurement(value: 3, unit: MyDimensionalUnit.unitA)
|
|
|
|
let m3 = m1 + m2
|
|
|
|
expectEqual(6, m3.value)
|
|
expectEqual(m1, m2)
|
|
|
|
let m10 = Measurement(value: 2, unit: CustomUnit.bugs)
|
|
let m11 = Measurement(value: 2, unit: CustomUnit.bugs)
|
|
let m12 = Measurement(value: 3, unit: CustomUnit.bugs)
|
|
|
|
expectEqual(m10, m11)
|
|
expectNotEqual(m10, m12)
|
|
|
|
// This test has 2 + 2 + 3 bugs
|
|
expectEqual((m10 + m11 + m12).value, 7)
|
|
}
|
|
|
|
func testConversion() {
|
|
let m1 = Measurement(value: 1000, unit: MyDimensionalUnit.unitA)
|
|
let kiloM1 = Measurement(value: 1, unit: MyDimensionalUnit.unitKiloA)
|
|
|
|
let result = m1.converted(to: MyDimensionalUnit.unitKiloA)
|
|
expectEqual(kiloM1, result)
|
|
|
|
let sameResult = m1.converted(to: MyDimensionalUnit.unitA)
|
|
expectEqual(sameResult, m1)
|
|
|
|
// This correctly fails to build
|
|
|
|
// let m2 = Measurement(value: 1, unit: CustomUnit.bugs)
|
|
// m2.converted(to: MyDimensionalUnit.unitKiloA)
|
|
}
|
|
|
|
func testOperators() {
|
|
// Which is bigger: 1 ka or 1 Ma?
|
|
let oneKiloA = Measurement(value: 1, unit: MyDimensionalUnit.unitKiloA)
|
|
let oneMegaA = Measurement(value: 1, unit: MyDimensionalUnit.unitMegaA)
|
|
|
|
expectTrue(oneKiloA < oneMegaA)
|
|
expectFalse(oneKiloA > oneMegaA)
|
|
expectTrue(oneKiloA * 2000 > oneMegaA)
|
|
expectTrue(oneMegaA / 1_000_000 < oneKiloA)
|
|
expectTrue(2000 * oneKiloA > oneMegaA)
|
|
expectTrue(2 / oneMegaA > oneMegaA)
|
|
expectEqual(2 / (oneMegaA * 2), oneMegaA)
|
|
expectTrue(oneMegaA <= oneKiloA * 1000)
|
|
expectTrue(oneMegaA - oneKiloA <= oneKiloA * 1000)
|
|
expectTrue(oneMegaA >= oneKiloA * 1000)
|
|
expectTrue(oneMegaA >= ((oneKiloA * 1000) - oneKiloA))
|
|
|
|
// Dynamically different dimensions
|
|
expectEqual(Measurement(value: 1_001_000, unit: MyDimensionalUnit.unitA), oneMegaA + oneKiloA)
|
|
|
|
var bugCount = Measurement(value: 1, unit: CustomUnit.bugs)
|
|
expectEqual(bugCount.value, 1)
|
|
bugCount = bugCount + Measurement(value: 4, unit: CustomUnit.bugs)
|
|
expectEqual(bugCount.value, 5)
|
|
}
|
|
|
|
func testUnits() {
|
|
expectEqual(MyDimensionalUnit.unitA, MyDimensionalUnit.unitA)
|
|
expectTrue(MyDimensionalUnit.unitA == MyDimensionalUnit.unitA)
|
|
}
|
|
|
|
func testMeasurementFormatter() {
|
|
let formatter = MeasurementFormatter()
|
|
let measurement = Measurement(value: 100, unit: UnitLength.kilometers)
|
|
let result = formatter.string(from: measurement)
|
|
|
|
// Just make sure we get a result at all here
|
|
expectFalse(result.isEmpty)
|
|
}
|
|
|
|
func testEquality() {
|
|
let fiveKM = Measurement(value: 5, unit: UnitLength.kilometers)
|
|
let fiveSeconds = Measurement(value: 5, unit: UnitDuration.seconds)
|
|
let fiveThousandM = Measurement(value: 5000, unit: UnitLength.meters)
|
|
|
|
expectTrue(fiveKM == fiveThousandM)
|
|
expectEqual(fiveKM, fiveThousandM)
|
|
expectFalse(fiveKM == fiveSeconds)
|
|
}
|
|
|
|
func testComparison() {
|
|
let fiveKM = Measurement(value: 5, unit: UnitLength.kilometers)
|
|
let fiveThousandM = Measurement(value: 5000, unit: UnitLength.meters)
|
|
let sixKM = Measurement(value: 6, unit: UnitLength.kilometers)
|
|
let sevenThousandM = Measurement(value: 7000, unit: UnitLength.meters)
|
|
|
|
expectTrue(fiveKM < sixKM)
|
|
expectTrue(fiveKM < sevenThousandM)
|
|
expectTrue(fiveKM <= fiveThousandM)
|
|
}
|
|
|
|
func testHashing() {
|
|
guard #available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *) else { return }
|
|
let lengths: [[Measurement<UnitLength>]] = [
|
|
[
|
|
Measurement(value: 5, unit: UnitLength.kilometers),
|
|
Measurement(value: 5000, unit: UnitLength.meters),
|
|
Measurement(value: 5000, unit: UnitLength.meters),
|
|
],
|
|
[
|
|
Measurement(value: 1, unit: UnitLength.kilometers),
|
|
Measurement(value: 1000, unit: UnitLength.meters),
|
|
],
|
|
[
|
|
Measurement(value: 1, unit: UnitLength.meters),
|
|
Measurement(value: 1000, unit: UnitLength.millimeters),
|
|
],
|
|
]
|
|
checkHashableGroups(lengths)
|
|
|
|
let durations: [[Measurement<UnitDuration>]] = [
|
|
[
|
|
Measurement(value: 3600, unit: UnitDuration.seconds),
|
|
Measurement(value: 60, unit: UnitDuration.minutes),
|
|
Measurement(value: 1, unit: UnitDuration.hours),
|
|
],
|
|
[
|
|
Measurement(value: 1800, unit: UnitDuration.seconds),
|
|
Measurement(value: 30, unit: UnitDuration.minutes),
|
|
Measurement(value: 0.5, unit: UnitDuration.hours),
|
|
]
|
|
]
|
|
checkHashableGroups(durations)
|
|
|
|
let custom: [Measurement<CustomUnit>] = [
|
|
Measurement(value: 1, unit: CustomUnit.bugs),
|
|
Measurement(value: 2, unit: CustomUnit.bugs),
|
|
Measurement(value: 3, unit: CustomUnit.bugs),
|
|
Measurement(value: 4, unit: CustomUnit.bugs),
|
|
Measurement(value: 1, unit: CustomUnit.features),
|
|
Measurement(value: 2, unit: CustomUnit.features),
|
|
Measurement(value: 3, unit: CustomUnit.features),
|
|
Measurement(value: 4, unit: CustomUnit.features),
|
|
]
|
|
checkHashable(custom, equalityOracle: { $0 == $1 })
|
|
}
|
|
|
|
func test_AnyHashableContainingMeasurement() {
|
|
let values: [Measurement<UnitLength>] = [
|
|
Measurement(value: 100, unit: UnitLength.meters),
|
|
Measurement(value: 100, unit: UnitLength.kilometers),
|
|
Measurement(value: 100, unit: UnitLength.kilometers),
|
|
]
|
|
let anyHashables = values.map(AnyHashable.init)
|
|
expectEqual(Measurement<UnitLength>.self, type(of: anyHashables[0].base))
|
|
expectEqual(Measurement<UnitLength>.self, type(of: anyHashables[1].base))
|
|
expectEqual(Measurement<UnitLength>.self, type(of: anyHashables[2].base))
|
|
expectNotEqual(anyHashables[0], anyHashables[1])
|
|
expectEqual(anyHashables[1], anyHashables[2])
|
|
}
|
|
|
|
func test_AnyHashableCreatedFromNSMeasurement() {
|
|
let values: [NSMeasurement] = [
|
|
NSMeasurement(doubleValue: 100, unit: UnitLength.meters),
|
|
NSMeasurement(doubleValue: 100, unit: UnitLength.kilometers),
|
|
NSMeasurement(doubleValue: 100, unit: UnitLength.kilometers),
|
|
]
|
|
let anyHashables = values.map(AnyHashable.init)
|
|
expectEqual(Measurement<Unit>.self, type(of: anyHashables[0].base))
|
|
expectEqual(Measurement<Unit>.self, type(of: anyHashables[1].base))
|
|
expectEqual(Measurement<Unit>.self, type(of: anyHashables[2].base))
|
|
expectNotEqual(anyHashables[0], anyHashables[1])
|
|
expectEqual(anyHashables[1], anyHashables[2])
|
|
}
|
|
}
|
|
|
|
#if !FOUNDATION_XCTEST
|
|
if #available(OSX 10.12, iOS 10.0, tvOS 10.0, watchOS 3.0, *) {
|
|
let MeasurementTests = TestSuite("TestMeasurement")
|
|
MeasurementTests.test("testBasicConstruction") { TestMeasurement().testBasicConstruction() }
|
|
MeasurementTests.test("testConversion") { TestMeasurement().testConversion() }
|
|
MeasurementTests.test("testOperators") { TestMeasurement().testOperators() }
|
|
MeasurementTests.test("testUnits") { TestMeasurement().testUnits() }
|
|
MeasurementTests.test("testMeasurementFormatter") { TestMeasurement().testMeasurementFormatter() }
|
|
MeasurementTests.test("testEquality") { TestMeasurement().testEquality() }
|
|
MeasurementTests.test("testComparison") { TestMeasurement().testComparison() }
|
|
MeasurementTests.test("testHashing") { TestMeasurement().testHashing() }
|
|
MeasurementTests.test("test_AnyHashableContainingMeasurement") { TestMeasurement().test_AnyHashableContainingMeasurement() }
|
|
MeasurementTests.test("test_AnyHashableCreatedFromNSMeasurement") { TestMeasurement().test_AnyHashableCreatedFromNSMeasurement() }
|
|
runAllTests()
|
|
}
|
|
#endif
|