diff --git a/CommandLineTool/main.swift b/CommandLineTool/main.swift index 397d717c..7ec0b8ec 100644 --- a/CommandLineTool/main.swift +++ b/CommandLineTool/main.swift @@ -46,10 +46,21 @@ import Foundation #endif extension String { - var inDefault: String { "\u{001B}[39m\(self)" } - var inRed: String { "\u{001B}[31m\(self)\u{001B}[0m" } - var inGreen: String { "\u{001B}[32m\(self)\u{001B}[0m" } - var inYellow: String { "\u{001B}[33m\(self)\u{001B}[0m" } + var inDefault: String { + "\u{001B}[39m\(self)" + } + + var inRed: String { + "\u{001B}[31m\(self)\u{001B}[0m" + } + + var inGreen: String { + "\u{001B}[32m\(self)\u{001B}[0m" + } + + var inYellow: String { + "\u{001B}[33m\(self)\u{001B}[0m" + } } private struct FileHandleOutputStream: TextOutputStream { diff --git a/LinuxMain.swift b/LinuxMain.swift index 572ba530..f67cf22e 100644 --- a/LinuxMain.swift +++ b/LinuxMain.swift @@ -1,8 +1,7 @@ // Unused, but required for Mint install -import XCTest - import SwiftFormatTests +import XCTest var tests = [XCTestCaseEntry]() diff --git a/Tests/ArgumentsTests.swift b/Tests/ArgumentsTests.swift index 266dff29..3fd08d7b 100644 --- a/Tests/ArgumentsTests.swift +++ b/Tests/ArgumentsTests.swift @@ -660,7 +660,7 @@ final class ArgumentsTests: XCTestCase { let args = ["rules": "braces,fileHeader"] let config = ["rules": "consecutiveSpaces,braces"] let result = try mergeArguments(args, into: config) - let rules = try parseRules(result["rules"]!, ignoreUnknown: false) + let rules = try parseRules(XCTUnwrap(result["rules"]), ignoreUnknown: false) XCTAssertEqual(rules, ["braces", "fileHeader"]) } @@ -668,7 +668,7 @@ final class ArgumentsTests: XCTestCase { let args = ["rules": ""] let config = ["rules": "consecutiveSpaces,braces"] let result = try mergeArguments(args, into: config) - let rules = try parseRules(result["rules"]!, ignoreUnknown: false) + let rules = try parseRules(XCTUnwrap(result["rules"]), ignoreUnknown: false) XCTAssertEqual(Set(rules), Set(["braces", "consecutiveSpaces"])) } @@ -676,7 +676,7 @@ final class ArgumentsTests: XCTestCase { let args = ["enable": "braces,fileHeader"] let config = ["enable": "consecutiveSpaces,braces"] let result = try mergeArguments(args, into: config) - let enabled = try parseRules(result["enable"]!, ignoreUnknown: false) + let enabled = try parseRules(XCTUnwrap(result["enable"]), ignoreUnknown: false) XCTAssertEqual(enabled, ["braces", "consecutiveSpaces", "fileHeader"]) } @@ -684,7 +684,7 @@ final class ArgumentsTests: XCTestCase { let args = ["disable": "braces,fileHeader"] let config = ["disable": "consecutiveSpaces,braces"] let result = try mergeArguments(args, into: config) - let disabled = try parseRules(result["disable"]!, ignoreUnknown: false) + let disabled = try parseRules(XCTUnwrap(result["disable"]), ignoreUnknown: false) XCTAssertEqual(disabled, ["braces", "consecutiveSpaces", "fileHeader"]) } @@ -692,7 +692,7 @@ final class ArgumentsTests: XCTestCase { let args = ["rules": "braces,fileHeader"] let config = ["rules": "consecutiveSpaces", "disable": "braces", "enable": "redundantSelf"] let result = try mergeArguments(args, into: config) - let disabled = try parseRules(result["rules"]!, ignoreUnknown: false) + let disabled = try parseRules(XCTUnwrap(result["rules"]), ignoreUnknown: false) XCTAssertEqual(disabled, ["braces", "fileHeader"]) XCTAssertNil(result["enabled"]) XCTAssertNil(result["disabled"]) @@ -702,11 +702,11 @@ final class ArgumentsTests: XCTestCase { let args = ["enable": "braces"] let config = ["rules": "fileHeader", "disable": "consecutiveSpaces,braces"] let result = try mergeArguments(args, into: config) - let rules = try parseRules(result["rules"]!, ignoreUnknown: false) + let rules = try parseRules(XCTUnwrap(result["rules"]), ignoreUnknown: false) XCTAssertEqual(rules, ["fileHeader"]) - let enabled = try parseRules(result["enable"]!, ignoreUnknown: false) + let enabled = try parseRules(XCTUnwrap(result["enable"]), ignoreUnknown: false) XCTAssertEqual(enabled, ["braces"]) - let disabled = try parseRules(result["disable"]!, ignoreUnknown: false) + let disabled = try parseRules(XCTUnwrap(result["disable"]), ignoreUnknown: false) XCTAssertEqual(disabled, ["consecutiveSpaces"]) } @@ -714,11 +714,11 @@ final class ArgumentsTests: XCTestCase { let args = ["disable": "braces"] let config = ["rules": "braces,fileHeader", "enable": "consecutiveSpaces,braces"] let result = try mergeArguments(args, into: config) - let rules = try parseRules(result["rules"]!, ignoreUnknown: false) + let rules = try parseRules(XCTUnwrap(result["rules"]), ignoreUnknown: false) XCTAssertEqual(rules, ["fileHeader"]) - let enabled = try parseRules(result["enable"]!, ignoreUnknown: false) + let enabled = try parseRules(XCTUnwrap(result["enable"]), ignoreUnknown: false) XCTAssertEqual(enabled, ["consecutiveSpaces"]) - let disabled = try parseRules(result["disable"]!, ignoreUnknown: false) + let disabled = try parseRules(XCTUnwrap(result["disable"]), ignoreUnknown: false) XCTAssertEqual(disabled, ["braces"]) } @@ -726,7 +726,7 @@ final class ArgumentsTests: XCTestCase { let args = ["self-required": "log,assert"] let config = ["self-required": "expect"] let result = try mergeArguments(args, into: config) - let selfRequired = parseCommaDelimitedList(result["self-required"]!) + let selfRequired = try parseCommaDelimitedList(XCTUnwrap(result["self-required"])) XCTAssertEqual(selfRequired, ["log", "assert"]) } @@ -734,7 +734,7 @@ final class ArgumentsTests: XCTestCase { let args = ["acronyms": "url"] let config = ["acronyms": "id,uuid"] let result = try mergeArguments(args, into: config) - let acronyms = parseCommaDelimitedList(result["acronyms"]!) + let acronyms = try parseCommaDelimitedList(XCTUnwrap(result["acronyms"])) XCTAssertEqual(acronyms, ["url"]) } diff --git a/Tests/CodeOrganizationTests.swift b/Tests/CodeOrganizationTests.swift index fcf94753..a462f526 100644 --- a/Tests/CodeOrganizationTests.swift +++ b/Tests/CodeOrganizationTests.swift @@ -14,7 +14,7 @@ final class CodeOrganizationTests: XCTestCase { for ruleFile in allRuleFiles { let fileName = ruleFile.lastPathComponent let titleCaseRuleName = fileName.replacingOccurrences(of: ".swift", with: "") - var ruleName = titleCaseRuleName.first!.lowercased() + titleCaseRuleName.dropFirst() + var ruleName = try XCTUnwrap(titleCaseRuleName.first?.lowercased()) + titleCaseRuleName.dropFirst() if titleCaseRuleName == "URLMacro" { ruleName = "urlMacro" } @@ -25,7 +25,7 @@ final class CodeOrganizationTests: XCTestCase { let extensions = declarations.filter { $0.keyword == "extension" } for extensionDecl in extensions { - let extendedType = extensionDecl.name! + let extendedType = try XCTUnwrap(extensionDecl.name) let extensionVisibility = extensionDecl.visibility() ?? .internal if extendedType == "FormatRule" { @@ -142,7 +142,7 @@ final class CodeOrganizationTests: XCTestCase { } } - func testRuleTestFilesHaveMatchingRule() { + func testRuleTestFilesHaveMatchingRule() throws { let allRuleNames = Set(allRuleFiles.map { ruleFile -> String in let fileName = ruleFile.lastPathComponent let titleCaseRuleName = fileName.replacingOccurrences(of: ".swift", with: "") @@ -157,7 +157,7 @@ final class CodeOrganizationTests: XCTestCase { let testFileName = testFile.lastPathComponent let expectedTestClassName = testFileName.replacingOccurrences(of: ".swift", with: "") let titleCaseRuleName = expectedTestClassName.hasSuffix("Tests") ? String(expectedTestClassName.dropLast(5)) : expectedTestClassName - var ruleName = titleCaseRuleName.first!.lowercased() + titleCaseRuleName.dropFirst() + var ruleName = try XCTUnwrap(titleCaseRuleName.first?.lowercased()) + titleCaseRuleName.dropFirst() if titleCaseRuleName == "URLMacro" { ruleName = "urlMacro" } @@ -183,7 +183,7 @@ final class CodeOrganizationTests: XCTestCase { let expectedTestClassName = testFileName.replacingOccurrences(of: ".swift", with: "") - XCTAssertEqual(testClass.name!, expectedTestClassName, """ + XCTAssertEqual(try XCTUnwrap(testClass.name), expectedTestClassName, """ class \(testClass.name!) and file \(testFileName) should have same name. """) } diff --git a/Tests/DeclarationV2Tests.swift b/Tests/DeclarationV2Tests.swift index a6845bda..a82c727a 100644 --- a/Tests/DeclarationV2Tests.swift +++ b/Tests/DeclarationV2Tests.swift @@ -10,7 +10,7 @@ import XCTest @testable import SwiftFormat final class DeclarationTests: XCTestCase { - func testModifyingDeclarations() { + func testModifyingDeclarations() throws { let input = """ import FooLib @@ -23,9 +23,9 @@ final class DeclarationTests: XCTestCase { let formatter = Formatter(tokenize(input)) let declarations = formatter.parseDeclarations() - let fooType = declarations[1] as! TypeDeclaration - let barProperty = fooType.body[0] as! SimpleDeclaration - let baazProperty = fooType.body[1] as! SimpleDeclaration + let fooType = try XCTUnwrap(declarations[1] as? TypeDeclaration) + let barProperty = try XCTUnwrap(fooType.body[0] as? SimpleDeclaration) + let baazProperty = try XCTUnwrap(fooType.body[1] as? SimpleDeclaration) XCTAssertEqual(barProperty.tokens.string, """ internal var bar: Bar\n diff --git a/Tests/FormatterTests.swift b/Tests/FormatterTests.swift index 6129bb22..3104a87e 100644 --- a/Tests/FormatterTests.swift +++ b/Tests/FormatterTests.swift @@ -640,10 +640,10 @@ final class FormatterTests: XCTestCase { XCTAssertEqual(formatter.changes.first?.line, 2) } - func testTrackChangesInSecondLine() { + func testTrackChangesInSecondLine() throws { let formatter = Formatter(tokenize("foo\nbar\nbaz"), trackChanges: true) let tokens = formatter.tokens - formatter.removeToken(at: formatter.tokens.firstIndex(of: .identifier("bar"))!) + try formatter.removeToken(at: XCTUnwrap(formatter.tokens.firstIndex(of: .identifier("bar")))) XCTAssertNotEqual(formatter.tokens, tokens) XCTAssertEqual(formatter.changes.count, 1) XCTAssertEqual(formatter.changes.first?.line, 2) diff --git a/Tests/MetadataTests.swift b/Tests/MetadataTests.swift index 06dbb466..43ad3da5 100644 --- a/Tests/MetadataTests.swift +++ b/Tests/MetadataTests.swift @@ -67,7 +67,7 @@ final class MetadataTests: XCTestCase { if !rule.options.isEmpty { result += "\n\nOption | Description\n--- | ---" for option in rule.options { - let descriptor = Descriptors.byName[option]! + let descriptor = try XCTUnwrap(Descriptors.byName[option]) guard !descriptor.isDeprecated else { continue } @@ -144,7 +144,7 @@ final class MetadataTests: XCTestCase { guard !line.isEmpty else { continue } // Check diff formatting: first column must be space/+/-, second column must be space - let firstChar = line.first! + let firstChar = try XCTUnwrap(line.first) let secondChar = line.count >= 2 ? line[line.index(line.startIndex, offsetBy: 1)] : " " let isValidDiffLine = (firstChar == " " || firstChar == "+" || firstChar == "-") && diff --git a/Tests/ParsingHelpersTests.swift b/Tests/ParsingHelpersTests.swift index f4158036..a2b4577f 100644 --- a/Tests/ParsingHelpersTests.swift +++ b/Tests/ParsingHelpersTests.swift @@ -1667,7 +1667,7 @@ final class ParsingHelpersTests: XCTestCase { _ = Formatter(tokens).parseDeclarations() } - func testParseDeclarationRangesInType() { + func testParseDeclarationRangesInType() throws { let input = """ class Foo { let bar = "bar" @@ -1683,14 +1683,14 @@ final class ParsingHelpersTests: XCTestCase { XCTAssertEqual(declarations[0].body?.count, 2) - let barDeclarationRange = declarations[0].body![0].range + let barDeclarationRange = try XCTUnwrap(declarations[0].body?[0].range) XCTAssertEqual(barDeclarationRange, 6 ... 16) XCTAssertEqual( formatter.tokens[barDeclarationRange].string, " let bar = \"bar\"\n" ) - let baazDeclarationRange = declarations[0].body![1].range + let baazDeclarationRange = try XCTUnwrap(declarations[0].body?[1].range) XCTAssertEqual(baazDeclarationRange, 17 ... 27) XCTAssertEqual( formatter.tokens[baazDeclarationRange].string, @@ -1698,7 +1698,7 @@ final class ParsingHelpersTests: XCTestCase { ) } - func testParseDeclarationRangesInConditionalCompilation() { + func testParseDeclarationRangesInConditionalCompilation() throws { let input = """ #if DEBUG let bar = "bar" @@ -1715,14 +1715,14 @@ final class ParsingHelpersTests: XCTestCase { XCTAssertEqual(declarations[0].body?.count, 2) - let barDeclarationRange = declarations[0].body![0].range + let barDeclarationRange = try XCTUnwrap(declarations[0].body?[0].range) XCTAssertEqual(barDeclarationRange, 4 ... 13) XCTAssertEqual( formatter.tokens[barDeclarationRange].string, "let bar = \"bar\"\n" ) - let baazDeclarationRange = declarations[0].body![1].range + let baazDeclarationRange = try XCTUnwrap(declarations[0].body?[1].range) XCTAssertEqual(baazDeclarationRange, 14 ... 23) XCTAssertEqual( formatter.tokens[baazDeclarationRange].string, @@ -2879,7 +2879,7 @@ final class ParsingHelpersTests: XCTestCase { ) } - func testParseFunctionDeclarationWithEffects() { + func testParseFunctionDeclarationWithEffects() throws { let input = """ struct FooBar { @@ -2891,26 +2891,26 @@ final class ParsingHelpersTests: XCTestCase { """ let formatter = Formatter(tokenize(input)) - let function = formatter.parseFunctionDeclaration(keywordIndex: 8)! + let function = try XCTUnwrap(formatter.parseFunctionDeclaration(keywordIndex: 8)) XCTAssertEqual(function.keywordIndex, 8) XCTAssertEqual(function.name, "foo") XCTAssertEqual(function.genericParameterRange, nil) XCTAssertEqual(formatter.tokens[function.argumentsRange].string, "(bar: Bar, baaz: Baaz)") XCTAssertEqual(function.arguments.count, 2) - XCTAssertEqual(formatter.tokens[function.effectsRange!].string, "async throws(GenericError)") + XCTAssertEqual(try formatter.tokens[XCTUnwrap(function.effectsRange)].string, "async throws(GenericError)") XCTAssertEqual(function.effects, ["async", "throws(GenericError)"]) XCTAssertEqual(function.returnOperatorIndex, 34) - XCTAssertEqual(formatter.tokens[function.returnType!.range].string, "Foo") + XCTAssertEqual(try formatter.tokens[XCTUnwrap(function.returnType?.range)].string, "Foo") XCTAssertEqual(function.whereClauseRange, nil) - XCTAssertEqual(formatter.tokens[function.bodyRange!].string, """ + XCTAssertEqual(try formatter.tokens[XCTUnwrap(function.bodyRange)].string, """ { Foo(bar: bar, baaz: baaz) } """) } - func testParseFunctionDeclarationWithGeneric() { + func testParseFunctionDeclarationWithGeneric() throws { let input = """ public func genericFoo(bar: Bar) rethrows where Baaz.Quux == Foo { print(bar) @@ -2921,24 +2921,24 @@ final class ParsingHelpersTests: XCTestCase { let formatter = Formatter(tokenize(input)) - let function = formatter.parseFunctionDeclaration(keywordIndex: 2)! + let function = try XCTUnwrap(formatter.parseFunctionDeclaration(keywordIndex: 2)) XCTAssertEqual(function.keywordIndex, 2) XCTAssertEqual(function.name, "genericFoo") - XCTAssertEqual(formatter.tokens[function.genericParameterRange!].string, "") + XCTAssertEqual(try formatter.tokens[XCTUnwrap(function.genericParameterRange)].string, "") XCTAssertEqual(formatter.tokens[function.argumentsRange].string, "(bar: Bar)") XCTAssertEqual(function.arguments.count, 1) - XCTAssertEqual(formatter.tokens[function.effectsRange!].string, "rethrows") + XCTAssertEqual(try formatter.tokens[XCTUnwrap(function.effectsRange)].string, "rethrows") XCTAssertEqual(function.effects, ["rethrows"]) XCTAssertEqual(function.returnOperatorIndex, nil) XCTAssertEqual(function.returnType?.range, nil) - XCTAssertEqual(formatter.tokens[function.whereClauseRange!].string, "where Baaz.Quux == Foo ") - XCTAssertEqual(formatter.tokens[function.bodyRange!].string, """ + XCTAssertEqual(try formatter.tokens[XCTUnwrap(function.whereClauseRange)].string, "where Baaz.Quux == Foo ") + XCTAssertEqual(try formatter.tokens[XCTUnwrap(function.bodyRange)].string, """ { print(bar) } """) - let secondFunction = formatter.parseFunctionDeclaration(keywordIndex: 41)! + let secondFunction = try XCTUnwrap(formatter.parseFunctionDeclaration(keywordIndex: 41)) XCTAssertEqual(secondFunction.keywordIndex, 41) XCTAssertEqual(secondFunction.name, "bar") XCTAssertEqual(secondFunction.genericParameterRange, nil) @@ -2949,10 +2949,10 @@ final class ParsingHelpersTests: XCTestCase { XCTAssertEqual(secondFunction.returnOperatorIndex, nil) XCTAssertEqual(secondFunction.returnType?.range, nil) XCTAssertEqual(secondFunction.whereClauseRange, nil) - XCTAssertEqual(formatter.tokens[secondFunction.bodyRange!].string, #"{ print("bar") }"#) + XCTAssertEqual(try formatter.tokens[XCTUnwrap(secondFunction.bodyRange)].string, #"{ print("bar") }"#) } - func testParseProtocolFunctionRequirements() { + func testParseProtocolFunctionRequirements() throws { let input = """ protocol FooBarProtocol { func foo(bar: Bar, baaz: Baaz) async throws -> Module.Foo where Bar == Baaz.Quux @@ -2963,26 +2963,26 @@ final class ParsingHelpersTests: XCTestCase { let formatter = Formatter(tokenize(input)) - let function = formatter.parseFunctionDeclaration(keywordIndex: 7)! + let function = try XCTUnwrap(formatter.parseFunctionDeclaration(keywordIndex: 7)) XCTAssertEqual(function.keywordIndex, 7) XCTAssertEqual(function.name, "foo") XCTAssertEqual(function.genericParameterRange, nil) XCTAssertEqual(formatter.tokens[function.argumentsRange].string, "(bar: Bar, baaz: Baaz)") XCTAssertEqual(function.arguments.count, 2) - XCTAssertEqual(formatter.tokens[function.effectsRange!].string, "async throws") + XCTAssertEqual(try formatter.tokens[XCTUnwrap(function.effectsRange)].string, "async throws") XCTAssertEqual(function.effects, ["async", "throws"]) XCTAssertEqual(function.returnOperatorIndex, 27) - XCTAssertEqual(formatter.tokens[function.returnType!.range].string, "Module.Foo") - XCTAssertEqual(formatter.tokens[function.whereClauseRange!].string, "where Bar == Baaz.Quux") + XCTAssertEqual(try formatter.tokens[XCTUnwrap(function.returnType?.range)].string, "Module.Foo") + XCTAssertEqual(try formatter.tokens[XCTUnwrap(function.whereClauseRange)].string, "where Bar == Baaz.Quux") XCTAssertEqual(function.bodyRange, nil) - let secondFunction = formatter.parseFunctionDeclaration(keywordIndex: 51)! + let secondFunction = try XCTUnwrap(formatter.parseFunctionDeclaration(keywordIndex: 51)) XCTAssertEqual(secondFunction.keywordIndex, 51) XCTAssertEqual(secondFunction.name, nil) - XCTAssertEqual(formatter.tokens[secondFunction.genericParameterRange!].string, "") + XCTAssertEqual(try formatter.tokens[XCTUnwrap(secondFunction.genericParameterRange)].string, "") XCTAssertEqual(formatter.tokens[secondFunction.argumentsRange].string, "(_ bar: Bar)") XCTAssertEqual(secondFunction.arguments.count, 1) - XCTAssertEqual(formatter.tokens[secondFunction.effectsRange!].string, "throws") + XCTAssertEqual(try formatter.tokens[XCTUnwrap(secondFunction.effectsRange)].string, "throws") XCTAssertEqual(secondFunction.effects, ["throws"]) XCTAssertEqual(secondFunction.returnOperatorIndex, nil) XCTAssertEqual(secondFunction.returnType?.range, nil) @@ -2990,7 +2990,7 @@ final class ParsingHelpersTests: XCTestCase { XCTAssertEqual(secondFunction.bodyRange, nil) } - func testParseFailableInit() { + func testParseFailableInit() throws { let input = """ init() {} init?() { return nil } @@ -2998,7 +2998,7 @@ final class ParsingHelpersTests: XCTestCase { let formatter = Formatter(tokenize(input)) - let firstInit = formatter.parseFunctionDeclaration(keywordIndex: 0)! + let firstInit = try XCTUnwrap(formatter.parseFunctionDeclaration(keywordIndex: 0)) XCTAssertEqual(firstInit.keywordIndex, 0) XCTAssertEqual(firstInit.name, nil) XCTAssertEqual(formatter.tokens[firstInit.argumentsRange].string, "()") @@ -3006,9 +3006,9 @@ final class ParsingHelpersTests: XCTestCase { XCTAssertEqual(firstInit.effects, []) XCTAssertEqual(firstInit.returnOperatorIndex, nil) XCTAssertEqual(firstInit.whereClauseRange, nil) - XCTAssertEqual(formatter.tokens[firstInit.bodyRange!].string, "{}") + XCTAssertEqual(try formatter.tokens[XCTUnwrap(firstInit.bodyRange)].string, "{}") - let secondInit = formatter.parseFunctionDeclaration(keywordIndex: 7)! + let secondInit = try XCTUnwrap(formatter.parseFunctionDeclaration(keywordIndex: 7)) XCTAssertEqual(secondInit.keywordIndex, 7) XCTAssertEqual(secondInit.name, nil) XCTAssertEqual(formatter.tokens[secondInit.argumentsRange].string, "()") @@ -3016,7 +3016,7 @@ final class ParsingHelpersTests: XCTestCase { XCTAssertEqual(secondInit.effects, []) XCTAssertEqual(secondInit.returnOperatorIndex, nil) XCTAssertEqual(secondInit.whereClauseRange, nil) - XCTAssertEqual(formatter.tokens[secondInit.bodyRange!].string, "{ return nil }") + XCTAssertEqual(try formatter.tokens[XCTUnwrap(secondInit.bodyRange)].string, "{ return nil }") } func testParseMarkdownFile() throws { diff --git a/Tests/Rules/FileHeaderTests.swift b/Tests/Rules/FileHeaderTests.swift index dcc16a4b..781db84a 100644 --- a/Tests/Rules/FileHeaderTests.swift +++ b/Tests/Rules/FileHeaderTests.swift @@ -677,9 +677,9 @@ final class FileHeaderTests: XCTestCase { ]) } - func testFileHeaderDateTimeZoneAbbreviations() { + func testFileHeaderDateTimeZoneAbbreviations() throws { // GMT+0530 - testTimeZone(timeZone: FormatTimeZone(rawValue: "IST")!, tests: [ + try testTimeZone(timeZone: XCTUnwrap(FormatTimeZone(rawValue: "IST")), tests: [ "15:00Z": "20:30", "16:00+1": "20:30", "01:00+10": "20:30", @@ -687,9 +687,9 @@ final class FileHeaderTests: XCTestCase { ]) } - func testFileHeaderDateTimeZoneIdentifiers() { + func testFileHeaderDateTimeZoneIdentifiers() throws { // GMT+0845 - testTimeZone(timeZone: FormatTimeZone(rawValue: "Australia/Eucla")!, tests: [ + try testTimeZone(timeZone: XCTUnwrap(FormatTimeZone(rawValue: "Australia/Eucla")), tests: [ "15:00Z": "23:45", "16:00+1": "23:45", "01:00+10": "23:45",