454 lines
23 KiB
Swift
454 lines
23 KiB
Swift
//
|
|
// SwiftDate
|
|
// Parse, validate, manipulate, and display dates, time and timezones in Swift
|
|
//
|
|
// Created by Daniele Margutti
|
|
// - Web: https://www.danielemargutti.com
|
|
// - Twitter: https://twitter.com/danielemargutti
|
|
// - Mail: hello@danielemargutti.com
|
|
//
|
|
// Copyright © 2019 Daniele Margutti. Licensed under MIT License.
|
|
//
|
|
|
|
import SwiftDate
|
|
import XCTest
|
|
|
|
class TestDateInRegion: XCTestCase {
|
|
|
|
let testDate = Date()
|
|
let testRegion = Region(calendar: Calendars.gregorian, zone: Zones.europeRome, locale: Locales.italian)
|
|
|
|
func testDateInRegion_ParseWithLocale() {
|
|
let itRegion = Region(calendar: Calendars.gregorian, zone: Zones.europeRome, locale: Locales.italian)
|
|
let dateIt = "15 Settembre 2001".toDate("dd MMM yyyy", region: itRegion)
|
|
XCTAssertNotNil(dateIt, "Failed to parse with forced locale it")
|
|
|
|
let dateEnStr = "10 July 2005"
|
|
let dateEnFail = dateEnStr.toDate("dd MMM yyyy", region: itRegion)
|
|
XCTAssertNil(dateEnFail, "This date should be not represented")
|
|
|
|
let enRegion = Region(calendar: Calendars.gregorian, zone: Zones.europeRome, locale: Locales.english)
|
|
let dateEnSuccess = dateEnStr.toDate("dd MMM yyyy", region: enRegion)
|
|
XCTAssertNotNil(dateEnSuccess, "Failed to parse with forced locale en")
|
|
}
|
|
|
|
func testDateInRegion_InitWithDateAndRegion() {
|
|
SwiftDate.defaultRegion = testRegion
|
|
|
|
// test with given date in test region
|
|
let dateInTestRegion = DateInRegion(testDate, region: testRegion)
|
|
XCTAssert( (dateInTestRegion.date == testDate), "Failed to create DateInRegion with given date and test region / different date")
|
|
XCTAssert( (dateInTestRegion.region == testRegion), "Failed to create DateInRegion with given date and test region / different region")
|
|
|
|
// test with current date in test region
|
|
let nowInTestRegion = DateInRegion(region: testRegion)
|
|
XCTAssertInTimeIntervalRange(value: (Date().timeIntervalSince1970 - nowInTestRegion.date.timeIntervalSince1970), range: 5, "Failed to create DateInRegion with now date and test region / date is not now")
|
|
XCTAssert( (nowInTestRegion.region == testRegion), "Failed to create DateInRegion with now date and test region / different region")
|
|
|
|
// test with current date in default region
|
|
let nowInDefRegion = DateInRegion()
|
|
XCTAssertInTimeIntervalRange(value: (Date().timeIntervalSince1970 - nowInDefRegion.date.timeIntervalSince1970), range: 5, "Failed to create DateInRegion with now date and default region / date is not now")
|
|
XCTAssert( (nowInDefRegion.region == SwiftDate.defaultRegion), "Failed to create DateInRegion with now date and default region / different region")
|
|
|
|
}
|
|
|
|
func testDateInRegion_InitFromTimeInterval() {
|
|
SwiftDate.defaultRegion = Region(calendar: Calendars.buddhist, zone: Zones.indianCocos, locale: Locales.nepaliIndia)
|
|
|
|
// Init with seconds and default region at UTC timezone
|
|
let secsFromEpoch = DateInRegion(seconds: 10)
|
|
XCTAssert( (secsFromEpoch.date.timeIntervalSince1970 == 10), "Failed to create DateInRegion from epoch time and UTC region / different date")
|
|
XCTAssert( (secsFromEpoch.region.timeZone == Region.UTC.timeZone), "Failed to create DateInRegion from epoch time and UTC region / different region than UTC")
|
|
XCTAssert( (secsFromEpoch.region.locale == Region.UTC.locale), "Failed to create DateInRegion from epoch time and UTC region / no default's region locale")
|
|
XCTAssert( (secsFromEpoch.region.calendar.identifier == Region.UTC.calendar.identifier), "Failed to create DateInRegion from epoch time and UTC region / no default's region calendar")
|
|
|
|
// Init with milliseconds and default region at UTC timezone
|
|
let msecsFromEpoch = DateInRegion(milliseconds: 5000)
|
|
XCTAssert( (msecsFromEpoch.date.timeIntervalSince1970 == 5), "Failed to create DateInRegion from epoch time and UTC region / different date")
|
|
|
|
// Init with second and given region
|
|
let regionBerlin = Region(calendar: Calendars.gregorian, zone: Zones.europeBerlin, locale: Locales.dutch)
|
|
let secsFromEpochInBerlin = DateInRegion(seconds: 56673, region: regionBerlin)
|
|
XCTAssert( (secsFromEpochInBerlin.region == regionBerlin), "Failed to create DateInRegion from epoch time and fixed region / different region")
|
|
XCTAssert( (secsFromEpochInBerlin.date.timeIntervalSince1970 == 56673), "Failed to create DateInRegion from epoch time and fixed region / different date")
|
|
|
|
// Init with milliseconds and given region
|
|
let msecsFromEpochInRegion = DateInRegion(milliseconds: 5000, region: regionBerlin)
|
|
XCTAssert( (msecsFromEpochInRegion.date.timeIntervalSince1970 == 5), "Failed to create DateInRegion from epoch time and fixed region / different date")
|
|
XCTAssert( (msecsFromEpochInRegion.region == regionBerlin), "Failed to create DateInRegion from epoch time and fixed region / different date")
|
|
|
|
// Init with fraction of seconds
|
|
let msecsLessThanSeconds = DateInRegion(milliseconds: 10)
|
|
XCTAssertEqual(round(msecsLessThanSeconds.date.timeIntervalSince1970 * 1000), 10)
|
|
|
|
}
|
|
|
|
func testDateInRegion_InitFromComponents() {
|
|
|
|
let regionRome = Region(calendar: Calendars.gregorian, zone: Zones.europeRome, locale: Locales.italian)
|
|
let regionUTC = Region.UTC
|
|
|
|
var dComponents = DateComponents()
|
|
dComponents.year = 1995
|
|
dComponents.month = 6
|
|
dComponents.day = 15
|
|
dComponents.hour = 16
|
|
dComponents.minute = 30
|
|
dComponents.second = 55
|
|
|
|
guard let dateInRome = DateInRegion(components: dComponents, region: regionRome) else {
|
|
XCTFail("Failed to create DateInRegion from valid components")
|
|
return
|
|
}
|
|
|
|
// Date must be expressed in Rome Time Zone which is UTC+1 for given date (1995/06/15)
|
|
// So we expect the same components of the date components and given hour -1 in absolute date (UTC)
|
|
let validDateTime = ((dateInRome.year == dComponents.year!) &&
|
|
(dateInRome.month == dComponents.month!) &&
|
|
(dateInRome.day == dComponents.day!) &&
|
|
(dateInRome.hour == dComponents.hour!) &&
|
|
(dateInRome.minute == dComponents.minute!) &&
|
|
(dateInRome.second == dComponents.second!))
|
|
XCTAssert(validDateTime, "Failed to create a valid DateInRegion in given region from components. One or more date components differs from original DateComponents")
|
|
XCTAssert( (dateInRome.date.in(region: regionUTC).hour == 14), "DateInRegion absolute date different from expected UTC value (14:30 UTC for given date)")
|
|
}
|
|
|
|
func testDateInRegion_InitFromParams() {
|
|
|
|
// Init with fixed parameters in a given region
|
|
let regionLondon = Region(calendar: Calendars.gregorian, zone: Zones.europeLondon, locale: Locales.englishUnitedKingdom)
|
|
let aDayInLondon = DateInRegion(year: 2001, month: 1, day: 5, hour: 23, minute: 30, second: 0, region: regionLondon)
|
|
let validDateLondon = (aDayInLondon.year == 2001 && aDayInLondon.month == 1 && aDayInLondon.day == 5 && aDayInLondon.hour == 23 && aDayInLondon.minute == 30 && aDayInLondon.second == 0)
|
|
XCTAssert(validDateLondon, "Failed to create a valid DateInRegion from paramters. One or more date components differs from original params")
|
|
|
|
// Init with fixed parameters (and some other missings) in default region
|
|
SwiftDate.defaultRegion = Region(calendar: Calendars.gregorian, zone: Zones.americaNewYork, locale: Locales.englishUnitedStates)
|
|
let aDayInNY = DateInRegion(year: 1995, month: 1, day: 5)
|
|
let validDateNY = (aDayInNY.year == 1995 && aDayInNY.month == 1 && aDayInNY.day == 5 && aDayInNY.hour == 0 && aDayInNY.minute == 0 && aDayInNY.second == 0)
|
|
XCTAssert(validDateNY, "Failed to create a valid DateInRegion from paramters and default region. One or more date components differs from original params")
|
|
XCTAssert( (aDayInNY.region == SwiftDate.defaultRegion), "Failed to create a valid DateInRegion from paramters and default region.")
|
|
|
|
}
|
|
|
|
func testDateInRegion_PastAndFuture() {
|
|
XCTAssert( (DateInRegion.past().date == Date.distantPast), "Failed to create DateInRegion with distant past date")
|
|
XCTAssert( (DateInRegion.future().date == Date.distantFuture), "Failed to create DateInRegion with distant future date")
|
|
}
|
|
|
|
func testDateInRegion_Description() {
|
|
let regionParis = Region(calendar: Calendars.gregorian, zone: Zones.europeParis, locale: Locales.frenchFrance)
|
|
let aDayInParis = DateInRegion(year: 2018, month: 5, day: 1, region: regionParis)
|
|
|
|
let descriptionDayInParis = aDayInParis.description
|
|
let expectedDescription = "{abs_date='2018-04-30T22:00:00Z', rep_date='2018-05-01T00:00:00+02:00', region={calendar='gregorian', timezone='Europe/Paris', locale='fr_FR'}"
|
|
XCTAssert( (descriptionDayInParis == expectedDescription), "Failed to create valid description from DateInRegion")
|
|
}
|
|
|
|
func testDateInRegion_DateComponents() {
|
|
let regionParis = Region(calendar: Calendars.gregorian, zone: Zones.europeParis, locale: Locales.frenchFrance)
|
|
let aDayInParis = DateInRegion(year: 2018, month: 5, day: 1, region: regionParis)
|
|
|
|
// Components of the date are expressed into the context of the region in which the date is created
|
|
let comps = aDayInParis.dateComponents
|
|
let areValidComponents = (comps.day! == 1 && comps.month! == 5 && comps.year! == 2018 && comps.hour! == 0 && comps.minute! == 0 && comps.second! == 0)
|
|
XCTAssert(areValidComponents, "Failed to extract valid components in the context of the region of the DateInRegion instance")
|
|
}
|
|
|
|
func testDateInRegion_Hash() {
|
|
// let regionParis = Region(calendar: Calendars.gregorian, zone: Zones.europeParis, locale: Locales.frenchFrance)
|
|
// let aDayInParis = DateInRegion(year: 2018, month: 5, day: 1, region: regionParis)
|
|
// let sameDayInParis = DateInRegion(year: aDayInParis.year, month: aDayInParis.month, day: aDayInParis.day, region: regionParis)
|
|
//
|
|
// XCTAssert( (aDayInParis.hashValue != sameDayInParis.hashValue), "Failed to extract hash value from different date with same values")
|
|
}
|
|
|
|
func testDateInRegion_InitComponentsCallback() {
|
|
// From components in fixed region
|
|
let regionRome = Region(calendar: Calendars.gregorian, zone: Zones.europeRome, locale: Locales.italian)
|
|
guard let dateInRome = DateInRegion(components: {
|
|
$0.year = 2001
|
|
$0.month = 9
|
|
$0.day = 11
|
|
$0.hour = 12
|
|
$0.minute = 0
|
|
$0.second = 5
|
|
}, region: regionRome) else {
|
|
XCTFail("Failed to create valid date from components callback init")
|
|
return
|
|
}
|
|
XCTValidateDateComponents(date: dateInRome, expec: ExpectedDateComponents {
|
|
$0.year = 2001
|
|
$0.month = 9
|
|
$0.day = 11
|
|
$0.hour = 12
|
|
$0.minute = 0
|
|
$0.second = 5
|
|
})
|
|
|
|
// From components in default region
|
|
let regionNY = Region(calendar: Calendars.gregorian, zone: Zones.americaNewYork, locale: Locales.english)
|
|
SwiftDate.defaultRegion = regionNY
|
|
|
|
guard let dateInNY = DateInRegion(components: {
|
|
$0.year = 2001
|
|
$0.month = 9
|
|
$0.day = 11
|
|
$0.hour = 12
|
|
$0.minute = 0
|
|
$0.second = 5
|
|
}) else {
|
|
XCTFail("Failed to create valid date from components callback init")
|
|
return
|
|
}
|
|
|
|
let inUTC = dateInNY.convertTo(region: Region.UTC)
|
|
XCTValidateDateComponents(date: inUTC, expec: ExpectedDateComponents {
|
|
$0.year = 2001
|
|
$0.month = 9
|
|
$0.day = 11
|
|
$0.hour = 16
|
|
$0.minute = 0
|
|
$0.second = 5
|
|
})
|
|
}
|
|
|
|
func testDateInRegion_ExtractComponents() {
|
|
let regionParis = Region(calendar: Calendars.gregorian, zone: Zones.europeParis, locale: Locales.frenchFrance)
|
|
let dateInParis = DateInRegion(year: 2006, month: 1, day: 1, hour: 0, minute: 45, second: 30, region: regionParis)
|
|
|
|
// Validate in local region
|
|
let componentsOfDate = dateInParis.dateComponents
|
|
XCTAssert((componentsOfDate.year! == 2006), "Failed to extract local timezone date components from date / invalid year")
|
|
XCTAssert((componentsOfDate.month! == 1), "Failed to extract local timezone date components from date / invalid month")
|
|
XCTAssert((componentsOfDate.day! == 1), "Failed to extract local timezone date components from date / invalid day")
|
|
XCTAssert((componentsOfDate.hour! == 0), "Failed to extract local timezone date components from date / invalid hour")
|
|
XCTAssert((componentsOfDate.minute! == 45), "Failed to extract local timezone date components from date / invalid minute")
|
|
XCTAssert((componentsOfDate.second! == 30), "Failed to extract local timezone date components from date / invalid second")
|
|
|
|
// Validate in UTC
|
|
SwiftDate.defaultRegion = Region.UTC
|
|
let componentsInUTC = dateInParis.date.dateComponents // components are expressed in default zone! UTC
|
|
XCTAssert((componentsInUTC.year! == 2005), "Failed to extract local timezone date components from date / invalid year")
|
|
XCTAssert((componentsInUTC.month! == 12), "Failed to extract local timezone date components from date / invalid month")
|
|
XCTAssert((componentsInUTC.day! == 31), "Failed to extract local timezone date components from date / invalid day")
|
|
XCTAssert((componentsInUTC.hour! == 23), "Failed to extract local timezone date components from date / invalid hour")
|
|
XCTAssert((componentsInUTC.minute! == 45), "Failed to extract local timezone date components from date / invalid minute")
|
|
XCTAssert((componentsInUTC.second! == 30), "Failed to extract local timezone date components from date / invalid second")
|
|
}
|
|
|
|
func testDateInRegion_InitStringAutoFormat() {
|
|
let regionParis = Region(calendar: Calendars.gregorian, zone: Zones.europeParis, locale: Locales.frenchFrance)
|
|
|
|
// Init with no format (yyyy-MM-dd'T'HH:mm:ssZZZZZ)
|
|
let expectedResult = ExpectedDateComponents {
|
|
$0.year = 2015
|
|
$0.month = 9
|
|
$0.day = 24
|
|
$0.hour = 13
|
|
$0.minute = 20
|
|
$0.second = 55
|
|
}
|
|
|
|
XCTValidateParse(string: "1:20 48055000", format: nil, region: regionParis, expec: ExpectedDateComponents {
|
|
$0.hour = 13
|
|
$0.minute = 20
|
|
$0.msInDay = 48_056_000
|
|
}) // h:mm A
|
|
XCTValidateParse(string: "après Jésus-Christ-[4]04-jeu.", format: nil, region: regionParis, expec: ExpectedDateComponents {
|
|
$0.day = 27
|
|
$0.era = 1
|
|
}) // GGGG-[W]WW-E
|
|
XCTValidateParse(string: "après Jésus-Christ-[4]04", format: nil, region: regionParis, expec: ExpectedDateComponents {
|
|
$0.era = 1
|
|
}) // GGGG-[W]WW
|
|
XCTValidateParse(string: "2015-09-24T13:20:55+02:00", format: nil, region: regionParis, expec: expectedResult) // yyyy-MM-dd'T'HH:mm:ssZZZZZ
|
|
XCTValidateParse(string: "2015-09-24T13:20:55Z", format: nil, region: regionParis, expec: expectedResult) // yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'
|
|
XCTValidateParse(string: "2015-09-24T13:20:55.000Z", format: nil, region: regionParis, expec: expectedResult) // yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'SSS'Z'
|
|
XCTValidateParse(string: "2015-09-24T13:20:55.000+0200", format: nil, region: regionParis, expec: expectedResult) // yyyy-MM-dd'T'HH:mm:ss.SSSZ
|
|
XCTValidateParse(string: "2015-09-24", format: nil, region: regionParis, expec: ExpectedDateComponents {
|
|
$0.year = 2015
|
|
$0.month = 9
|
|
$0.day = 24
|
|
}) // yyyy-MM-dd
|
|
XCTValidateParse(string: "2015-09-24 13:20:55", format: nil, region: regionParis, expec: expectedResult) // yyyy-MM-dd HH:mm:ss
|
|
XCTValidateParse(string: "1:20:55 48055000", format: nil, region: regionParis, expec: ExpectedDateComponents {
|
|
$0.hour = 13
|
|
$0.minute = 20
|
|
$0.second = 55
|
|
$0.msInDay = 48_056_000
|
|
}) // h:mm:ss A
|
|
XCTValidateParse(string: "09/24/2015", format: nil, region: regionParis, expec: ExpectedDateComponents {
|
|
$0.month = 9
|
|
$0.day = 24
|
|
$0.year = 2015
|
|
$0.hour = 0
|
|
$0.minute = 0
|
|
$0.second = 0
|
|
}) // MM/dd/yyyy
|
|
XCTValidateParse(string: "septembre 24, 2015", format: nil, region: regionParis, expec: ExpectedDateComponents {
|
|
$0.month = 9
|
|
$0.day = 24
|
|
$0.year = 2015
|
|
$0.hour = 0
|
|
$0.minute = 0
|
|
$0.second = 0
|
|
}) // MMMM d, yyyy
|
|
XCTValidateParse(string: "002015-09-24", format: nil, region: regionParis, expec: ExpectedDateComponents {
|
|
$0.month = 9
|
|
$0.day = 24
|
|
$0.year = 2015
|
|
$0.hour = 0
|
|
$0.minute = 0
|
|
$0.second = 0
|
|
}) // yyyyyy-MM-dd
|
|
XCTValidateParse(string: "2015-09-24", format: nil, region: regionParis, expec: ExpectedDateComponents {
|
|
$0.month = 9
|
|
$0.day = 24
|
|
$0.year = 2015
|
|
$0.hour = 0
|
|
$0.minute = 0
|
|
$0.second = 0
|
|
}) // yyyy-MM-dd
|
|
XCTValidateParse(string: "2015-024", format: nil, region: regionParis, expec: ExpectedDateComponents {
|
|
$0.dayOfYear = 24
|
|
$0.year = 2015
|
|
$0.hour = 0
|
|
$0.minute = 0
|
|
$0.second = 0
|
|
}) // yyyy-ddd
|
|
XCTValidateParse(string: "13:20:55.0000", format: nil, region: regionParis, expec: ExpectedDateComponents {
|
|
$0.hour = 13
|
|
$0.minute = 20
|
|
$0.second = 55
|
|
}) // HH:mm:ss.SSSS
|
|
XCTValidateParse(string: "13:20:55", format: nil, region: regionParis, expec: ExpectedDateComponents {
|
|
$0.hour = 13
|
|
$0.minute = 20
|
|
$0.second = 55
|
|
}) // HH:mm:ss
|
|
XCTValidateParse(string: "13:20", format: nil, region: regionParis, expec: ExpectedDateComponents {
|
|
$0.hour = 13
|
|
$0.minute = 20
|
|
}) // HH:mm
|
|
XCTValidateParse(string: "13", format: nil, region: regionParis, expec: ExpectedDateComponents {
|
|
$0.hour = 13
|
|
}) // HH
|
|
|
|
}
|
|
}
|
|
|
|
public struct ExpectedDateComponents {
|
|
var year: Int?
|
|
var day: Int?
|
|
var dayOfYear: Int?
|
|
var month: Int?
|
|
var hour: Int?
|
|
var minute: Int?
|
|
var second: Int?
|
|
var weekOfMonth: Int?
|
|
var msInDay: Int?
|
|
var era: Int?
|
|
var monthDays: Int?
|
|
var weekOfYear: Int?
|
|
var weekdayOrdinal: Int?
|
|
var firstDayOfWeek: Int?
|
|
var lastDayOfWeek: Int?
|
|
var yearForWeekOfYear: Int?
|
|
var quarter: Int?
|
|
var DSTOffset: TimeInterval?
|
|
var nearestHour: Int?
|
|
|
|
var monthNameDefault: String?
|
|
var monthNameDefaultStd: String?
|
|
var monthNameShort: String?
|
|
var monthNameStandaloneShort: String?
|
|
var monthNameVeryShort: String?
|
|
var monthNameStandaloneVeryShort: String?
|
|
|
|
var weekday: Int?
|
|
var weekdayNameDefault: String?
|
|
var weekdayNameDefaultStd: String?
|
|
var weekdayNameShort: String?
|
|
var weekdayNameShortStd: String?
|
|
var weekdayNameVeryShort: String?
|
|
var weekdayNameVeryShortStd: String?
|
|
|
|
var eraNameDefault: String?
|
|
var eraNameDefaultStd: String?
|
|
var eraNameShort: String?
|
|
var eraNameShortStd: String?
|
|
var eraNameVeryShort: String?
|
|
var eraNameVeryShortStd: String?
|
|
|
|
public init(_ configure: ((inout ExpectedDateComponents) -> Void)? = nil) {
|
|
configure?(&self)
|
|
}
|
|
|
|
func validate(_ date: DateInRegion, _ origin: String) -> String? {
|
|
if let year = self.year, year != date.year { return "year" }
|
|
if let day = self.day, day != date.day { return "day" }
|
|
if let month = self.month, month != date.month { return "month" }
|
|
if let minute = self.minute, minute != date.minute {
|
|
return "minute exp='\(self.minute!)' val='\(date.minute)' date='\(date)' origin='\(origin)'"
|
|
}
|
|
if let second = self.second, second != date.second { return "second" }
|
|
if let weekOfMonth = self.weekOfMonth, weekOfMonth != date.weekOfMonth { return "weekOfMonth" }
|
|
if let dayOfYear = self.dayOfYear, dayOfYear != date.dayOfYear { return "dayOfYear" }
|
|
if let era = self.era, era != date.era { return "era" }
|
|
if let msInDay = self.msInDay, msInDay != date.msInDay { return "msInDay" }
|
|
if let monthNameDefault = self.monthNameDefault, monthNameDefault != date.monthName(.`default`) { return "monthName(.`default`)" }
|
|
if let monthNameDefaultStd = self.monthNameDefaultStd, monthNameDefaultStd != date.monthName(.defaultStandalone) { return "monthName(.defaultStandalone)" }
|
|
if let monthNameShort = self.monthNameShort, monthNameShort != date.monthName(.short) { return "monthName(.short)" }
|
|
if let monthNameVeryShort = self.monthNameVeryShort, monthNameVeryShort != date.monthName(.veryShort) { return "monthName(.veryShort)" }
|
|
if let monthNameStandaloneShort = self.monthNameStandaloneShort, monthNameStandaloneShort != date.monthName(.standaloneShort) { return "monthName(.standaloneShort)" }
|
|
if let monthNameStandaloneVeryShort = self.monthNameStandaloneVeryShort, monthNameStandaloneVeryShort != date.weekdayName(.standaloneVeryShort) { return "weekdayName(.veryShortStandalone)" }
|
|
|
|
if let monthDays = self.monthDays, monthDays != date.monthDays { return "monthDays" }
|
|
|
|
if let weekday = self.weekday, weekday != date.weekday { return "weekday" }
|
|
if let weekdayNameDefault = self.weekdayNameDefault, weekdayNameDefault != date.weekdayName(.`default`) { return "weekdayName(.`default`)" }
|
|
if let weekdayNameDefaultStd = self.weekdayNameDefaultStd, weekdayNameDefaultStd != date.weekdayName(.defaultStandalone) { return "weekdayName(.defaultStandalone)" }
|
|
if let weekdayNameShort = self.weekdayNameShort, weekdayNameShort != date.weekdayName(.short) { return "weekdayName(.short)" }
|
|
if let weekdayNameShortStd = self.weekdayNameShortStd, weekdayNameShortStd != date.weekdayName(.standaloneShort) { return "weekdayName(.shortStandalone)" }
|
|
if let weekdayNameVeryShort = self.weekdayNameVeryShort, weekdayNameVeryShort != date.weekdayName(.veryShort) { return "weekdayName(.veryShort)" }
|
|
if let weekdayNameVeryShortStd = self.weekdayNameVeryShortStd, weekdayNameVeryShortStd != date.weekdayName(.standaloneVeryShort) { return "weekdayName(.veryShortStandalone)" }
|
|
|
|
if let weekOfYear = self.weekOfYear, weekOfYear != date.weekOfYear { return "weekOfYear" }
|
|
if let weekdayOrdinal = self.weekdayOrdinal, weekdayOrdinal != date.weekdayOrdinal { return "weekdayOrdinal" }
|
|
if let firstDayOfWeek = self.firstDayOfWeek, firstDayOfWeek != date.firstDayOfWeek { return "firstDayOfWeek" }
|
|
if let lastDayOfWeek = self.lastDayOfWeek, lastDayOfWeek != date.lastDayOfWeek { return "lastDayOfWeek" }
|
|
if let yearForWeekOfYear = self.yearForWeekOfYear, yearForWeekOfYear != date.yearForWeekOfYear { return "yearForWeekOfYear" }
|
|
if let quarter = self.quarter, quarter != date.quarter { return "quarter" }
|
|
|
|
if let eraNameDefault = self.eraNameDefault, eraNameDefault != date.eraName(.`default`) { return "eraName(.`default`)" }
|
|
if let eraNameDefaultStd = self.eraNameDefaultStd, eraNameDefaultStd != date.eraName(.defaultStandalone) { return "eraName(.defaultStandalone)" }
|
|
if let eraNameShort = self.eraNameShort, eraNameShort != date.eraName(.short) { return "eraName(.short)" }
|
|
if let eraNameShortStd = self.eraNameShortStd, eraNameShortStd != date.eraName(.standaloneShort) { return "eraName(.shortStandalone)" }
|
|
if let eraNameVeryShort = self.eraNameVeryShort, eraNameVeryShort != date.eraName(.veryShort) { return "eraName(.veryShort)" }
|
|
if let eraNameVeryShortStd = self.eraNameVeryShortStd, eraNameVeryShortStd != date.eraName(.standaloneVeryShort) { return "eraName(.veryShortStandalone)" }
|
|
|
|
if let DSTOffset = self.DSTOffset, DSTOffset != date.DSTOffset { return "DSTOffset" }
|
|
if let nearestHour = self.nearestHour, nearestHour != date.nearestHour { return "nearestHour" }
|
|
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func XCTValidateParse(string: String, format: String?, region: Region, expec: ExpectedDateComponents) {
|
|
guard let date = DateInRegion(string, format: format, region: region) else {
|
|
XCTFail("Failed to parse date '\(string)' with format: '\(format ?? "<AUTO>")'")
|
|
return
|
|
}
|
|
if let errors = expec.validate(date, string) {
|
|
XCTFail("Failed to validate components of parsed date string '\(string)' with format: '\(format ?? "<AUTO>")'. One or more components differ from expected: \(errors)")
|
|
return
|
|
}
|
|
}
|
|
|
|
func XCTValidateDateComponents(date: DateInRegion, expec: ExpectedDateComponents) {
|
|
if let errors = expec.validate(date, "") {
|
|
XCTFail("Failed to validate components of date '\(date.description)'. One or more components differ from expected: \(errors)")
|
|
return
|
|
}
|
|
}
|