mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
211 lines
9.2 KiB
Swift
211 lines
9.2 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 TestDateIntervalSuper : XCTestCase { }
|
|
#else
|
|
import StdlibUnittest
|
|
class TestDateIntervalSuper { }
|
|
#endif
|
|
|
|
class TestDateInterval : TestDateIntervalSuper {
|
|
func dateWithString(_ str: String) -> Date {
|
|
let formatter = DateFormatter()
|
|
formatter.calendar = Calendar(identifier: .gregorian)
|
|
formatter.locale = Locale(identifier: "en_US")
|
|
formatter.dateFormat = "yyyy-MM-dd HH:mm:ss Z"
|
|
return formatter.date(from: str)! as Date
|
|
}
|
|
|
|
func test_compareDateIntervals() {
|
|
if #available(iOS 10.10, OSX 10.12, tvOS 10.0, watchOS 3.0, *) {
|
|
let start = dateWithString("2010-05-17 14:49:47 -0700")
|
|
let duration: TimeInterval = 10000000.0
|
|
let testInterval1 = DateInterval(start: start, duration: duration)
|
|
let testInterval2 = DateInterval(start: start, duration: duration)
|
|
expectEqual(testInterval1, testInterval2)
|
|
expectEqual(testInterval2, testInterval1)
|
|
expectEqual(testInterval1.compare(testInterval2), ComparisonResult.orderedSame)
|
|
|
|
let testInterval3 = DateInterval(start: start, duration: 10000000000.0)
|
|
expectTrue(testInterval1 < testInterval3)
|
|
expectTrue(testInterval3 > testInterval1)
|
|
|
|
let earlierStart = dateWithString("2009-05-17 14:49:47 -0700")
|
|
let testInterval4 = DateInterval(start: earlierStart, duration: duration)
|
|
|
|
expectTrue(testInterval4 < testInterval1)
|
|
expectTrue(testInterval1 > testInterval4)
|
|
}
|
|
}
|
|
|
|
func test_isEqualToDateInterval() {
|
|
if #available(iOS 10.10, OSX 10.12, tvOS 10.0, watchOS 3.0, *) {
|
|
let start = dateWithString("2010-05-17 14:49:47 -0700")
|
|
let duration = 10000000.0
|
|
let testInterval1 = DateInterval(start: start, duration: duration)
|
|
let testInterval2 = DateInterval(start: start, duration: duration)
|
|
|
|
expectEqual(testInterval1, testInterval2)
|
|
|
|
let testInterval3 = DateInterval(start: start, duration: 100.0)
|
|
expectNotEqual(testInterval1, testInterval3)
|
|
}
|
|
}
|
|
|
|
func test_hashing() {
|
|
guard #available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *) else { return }
|
|
|
|
let start1a = dateWithString("2019-04-04 17:09:23 -0700")
|
|
let start1b = dateWithString("2019-04-04 17:09:23 -0700")
|
|
let start2a = Date(timeIntervalSinceReferenceDate: start1a.timeIntervalSinceReferenceDate.nextUp)
|
|
let start2b = Date(timeIntervalSinceReferenceDate: start1a.timeIntervalSinceReferenceDate.nextUp)
|
|
let duration1 = 1800.0
|
|
let duration2 = duration1.nextUp
|
|
let intervals: [[DateInterval]] = [
|
|
[
|
|
DateInterval(start: start1a, duration: duration1),
|
|
DateInterval(start: start1b, duration: duration1),
|
|
],
|
|
[
|
|
DateInterval(start: start1a, duration: duration2),
|
|
DateInterval(start: start1b, duration: duration2),
|
|
],
|
|
[
|
|
DateInterval(start: start2a, duration: duration1),
|
|
DateInterval(start: start2b, duration: duration1),
|
|
],
|
|
[
|
|
DateInterval(start: start2a, duration: duration2),
|
|
DateInterval(start: start2b, duration: duration2),
|
|
],
|
|
]
|
|
checkHashableGroups(intervals)
|
|
}
|
|
|
|
func test_checkIntersection() {
|
|
if #available(iOS 10.10, OSX 10.12, tvOS 10.0, watchOS 3.0, *) {
|
|
let start1 = dateWithString("2010-05-17 14:49:47 -0700")
|
|
let end1 = dateWithString("2010-08-17 14:49:47 -0700")
|
|
|
|
let testInterval1 = DateInterval(start: start1, end: end1)
|
|
|
|
let start2 = dateWithString("2010-02-17 14:49:47 -0700")
|
|
let end2 = dateWithString("2010-07-17 14:49:47 -0700")
|
|
|
|
let testInterval2 = DateInterval(start: start2, end: end2)
|
|
|
|
expectTrue(testInterval1.intersects(testInterval2))
|
|
|
|
let start3 = dateWithString("2010-10-17 14:49:47 -0700")
|
|
let end3 = dateWithString("2010-11-17 14:49:47 -0700")
|
|
|
|
let testInterval3 = DateInterval(start: start3, end: end3)
|
|
|
|
expectFalse(testInterval1.intersects(testInterval3))
|
|
}
|
|
}
|
|
|
|
func test_validIntersections() {
|
|
if #available(iOS 10.10, OSX 10.12, tvOS 10.0, watchOS 3.0, *) {
|
|
let start1 = dateWithString("2010-05-17 14:49:47 -0700")
|
|
let end1 = dateWithString("2010-08-17 14:49:47 -0700")
|
|
|
|
let testInterval1 = DateInterval(start: start1, end: end1)
|
|
|
|
let start2 = dateWithString("2010-02-17 14:49:47 -0700")
|
|
let end2 = dateWithString("2010-07-17 14:49:47 -0700")
|
|
|
|
let testInterval2 = DateInterval(start: start2, end: end2)
|
|
|
|
let start3 = dateWithString("2010-05-17 14:49:47 -0700")
|
|
let end3 = dateWithString("2010-07-17 14:49:47 -0700")
|
|
|
|
let testInterval3 = DateInterval(start: start3, end: end3)
|
|
|
|
let intersection1 = testInterval2.intersection(with: testInterval1)
|
|
expectNotNil(intersection1)
|
|
expectEqual(testInterval3, intersection1)
|
|
|
|
let intersection2 = testInterval1.intersection(with: testInterval2)
|
|
expectNotNil(intersection2)
|
|
expectEqual(intersection1, intersection2)
|
|
}
|
|
}
|
|
|
|
func test_containsDate() {
|
|
if #available(iOS 10.10, OSX 10.12, tvOS 10.0, watchOS 3.0, *) {
|
|
let start = dateWithString("2010-05-17 14:49:47 -0700")
|
|
let duration = 10000000.0
|
|
|
|
let testInterval = DateInterval(start: start, duration: duration)
|
|
let containedDate = dateWithString("2010-05-17 20:49:47 -0700")
|
|
|
|
expectTrue(testInterval.contains(containedDate))
|
|
|
|
let earlierStart = dateWithString("2009-05-17 14:49:47 -0700")
|
|
expectFalse(testInterval.contains(earlierStart))
|
|
}
|
|
}
|
|
|
|
func test_AnyHashableContainingDateInterval() {
|
|
if #available(iOS 10.10, OSX 10.12, tvOS 10.0, watchOS 3.0, *) {
|
|
let start = dateWithString("2010-05-17 14:49:47 -0700")
|
|
let duration = 10000000.0
|
|
let values: [DateInterval] = [
|
|
DateInterval(start: start, duration: duration),
|
|
DateInterval(start: start, duration: duration / 2),
|
|
DateInterval(start: start, duration: duration / 2),
|
|
]
|
|
let anyHashables = values.map(AnyHashable.init)
|
|
expectEqual(DateInterval.self, type(of: anyHashables[0].base))
|
|
expectEqual(DateInterval.self, type(of: anyHashables[1].base))
|
|
expectEqual(DateInterval.self, type(of: anyHashables[2].base))
|
|
expectNotEqual(anyHashables[0], anyHashables[1])
|
|
expectEqual(anyHashables[1], anyHashables[2])
|
|
}
|
|
}
|
|
|
|
func test_AnyHashableCreatedFromNSDateInterval() {
|
|
if #available(iOS 10.10, OSX 10.12, tvOS 10.0, watchOS 3.0, *) {
|
|
let start = dateWithString("2010-05-17 14:49:47 -0700")
|
|
let duration = 10000000.0
|
|
let values: [NSDateInterval] = [
|
|
NSDateInterval(start: start, duration: duration),
|
|
NSDateInterval(start: start, duration: duration / 2),
|
|
NSDateInterval(start: start, duration: duration / 2),
|
|
]
|
|
let anyHashables = values.map(AnyHashable.init)
|
|
expectEqual(DateInterval.self, type(of: anyHashables[0].base))
|
|
expectEqual(DateInterval.self, type(of: anyHashables[1].base))
|
|
expectEqual(DateInterval.self, type(of: anyHashables[2].base))
|
|
expectNotEqual(anyHashables[0], anyHashables[1])
|
|
expectEqual(anyHashables[1], anyHashables[2])
|
|
}
|
|
}
|
|
}
|
|
|
|
#if !FOUNDATION_XCTEST
|
|
var DateIntervalTests = TestSuite("TestDateInterval")
|
|
DateIntervalTests.test("test_compareDateIntervals") { TestDateInterval().test_compareDateIntervals() }
|
|
DateIntervalTests.test("test_isEqualToDateInterval") { TestDateInterval().test_isEqualToDateInterval() }
|
|
DateIntervalTests.test("test_hashing") { TestDateInterval().test_hashing() }
|
|
DateIntervalTests.test("test_checkIntersection") { TestDateInterval().test_checkIntersection() }
|
|
DateIntervalTests.test("test_validIntersections") { TestDateInterval().test_validIntersections() }
|
|
DateIntervalTests.test("test_AnyHashableContainingDateInterval") { TestDateInterval().test_AnyHashableContainingDateInterval() }
|
|
DateIntervalTests.test("test_AnyHashableCreatedFromNSDateInterval") { TestDateInterval().test_AnyHashableCreatedFromNSDateInterval() }
|
|
runAllTests()
|
|
#endif
|