Skip to content

Commit 4b2d6d5

Browse files
oschrenkoschrenk
committed
✅ Move to Testing framework
1 parent 3909632 commit 4b2d6d5

File tree

6 files changed

+95
-102
lines changed

6 files changed

+95
-102
lines changed

‎Tests/CalendarFilterTest.swift‎

Lines changed: 32 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -1,132 +1,132 @@
11
import EventKit
2+
import Testing
23

34
@testable import plan
4-
import XCTest
55

6-
final class CalendarFilterTests: XCTestCase {
7-
func testAlwaysAccept() {
6+
@Suite final class CalendarFilterTests {
7+
@Test func testAlwaysAccept() {
88
let calendar = PlanCalendar.generate()
99
let expected = true
1010
let actual = CalendarFilter.Accept().accept(calendar)
1111

12-
XCTAssertEqual(actual, expected, "The calendar was not accepted")
12+
#expect(actual == expected, "The calendar was not accepted")
1313
}
1414

15-
func testSelectCalendarsMatching() {
15+
@Test func testSelectCalendarsMatching() {
1616
let calendar = PlanCalendar.generate()
1717
let expected = true
1818
let actual = CalendarFilter.Select(uuids: [calendar.id]).accept(calendar)
1919

20-
XCTAssertEqual(actual, expected, "The calendar was not accepted")
20+
#expect(actual == expected, "The calendar was not accepted")
2121
}
2222

23-
func testSelectCalendarsEmptyArray() {
23+
@Test func testSelectCalendarsEmptyArray() {
2424
let calendar = PlanCalendar.generate()
2525
let expected = true
2626
let actual = CalendarFilter.Select(uuids: []).accept(calendar)
2727

28-
XCTAssertEqual(actual, expected, "The calendar was not accepted")
28+
#expect(actual == expected, "The calendar was not accepted")
2929
}
3030

31-
func testIgnoreCalendarsMatching() {
31+
@Test func testIgnoreCalendarsMatching() {
3232
let calendar = PlanCalendar.generate()
3333
let expected = false
3434
let actual = CalendarFilter.Ignore(uuids: [calendar.id]).accept(calendar)
3535

36-
XCTAssertEqual(actual, expected, "The calendar was accepted")
36+
#expect(actual == expected, "The calendar was accepted")
3737
}
3838

39-
func testIgnoreCalendarsEmptyArray() {
39+
@Test func testIgnoreCalendarsEmptyArray() {
4040
let calendar = PlanCalendar.generate()
4141
let expected = true
4242
let actual = CalendarFilter.Ignore(uuids: []).accept(calendar)
4343

44-
XCTAssertEqual(actual, expected, "The calendar was not accepted")
44+
#expect(actual == expected, "The calendar was not accepted")
4545
}
4646

47-
func testIgnoreCalendarSourcesMatching() {
47+
@Test func testIgnoreCalendarSourcesMatching() {
4848
let source = "Personal"
4949
let calendar = PlanCalendar.generate(source: source)
5050
let expected = false
5151
let actual = CalendarFilter.IgnoreSources(sources: [source]).accept(calendar)
5252

53-
XCTAssertEqual(actual, expected, "The calendar was accepted")
53+
#expect(actual == expected, "The calendar was accepted")
5454
}
5555

56-
func testIgnoreCalendarSourcesEmptyArray() {
56+
@Test func testIgnoreCalendarSourcesEmptyArray() {
5757
let calendar = PlanCalendar.generate()
5858
let expected = true
5959
let actual = CalendarFilter.IgnoreSources(sources: []).accept(calendar)
6060

61-
XCTAssertEqual(actual, expected, "The calendar was rejected")
61+
#expect(actual == expected, "The calendar was rejected")
6262
}
6363

64-
func testSelectCalendarSourcesMatching() {
64+
@Test func testSelectCalendarSourcesMatching() {
6565
let source = "Personal"
6666
let calendar = PlanCalendar.generate(source: source)
6767
let expected = true
6868
let actual = CalendarFilter.SelectSources(sources: [source]).accept(calendar)
6969

70-
XCTAssertEqual(actual, expected, "The calendar was rejected")
70+
#expect(actual == expected, "The calendar was rejected")
7171
}
7272

73-
func testSelectCalendarSourcesNotMatching() {
73+
@Test func testSelectCalendarSourcesNotMatching() {
7474
let source = "Personal"
7575
let calendar = PlanCalendar.generate(source: source)
7676
let expected = false
7777
let actual = CalendarFilter.SelectSources(sources: ["not-existing"]).accept(calendar)
7878

79-
XCTAssertEqual(actual, expected, "The calendar was accepted")
79+
#expect(actual == expected, "The calendar was accepted")
8080
}
8181

82-
func testSelectCalendarSourcesEmptyArray() {
82+
@Test func testSelectCalendarSourcesEmptyArray() {
8383
let calendar = PlanCalendar.generate()
8484
let expected = true
8585
let actual = CalendarFilter.SelectSources(sources: []).accept(calendar)
8686

87-
XCTAssertEqual(actual, expected, "The calendar was rejected")
87+
#expect(actual == expected, "The calendar was rejected")
8888
}
8989

90-
func testIgnoreCalendarTypesMatching() {
90+
@Test func testIgnoreCalendarTypesMatching() {
9191
let type = EKCalendarType.birthday
9292
let calendar = PlanCalendar.generate(type: type)
9393
let expected = false
9494
let actual = CalendarFilter.IgnoreTypes(types: [type]).accept(calendar)
9595

96-
XCTAssertEqual(actual, expected, "The calendar was accepted")
96+
#expect(actual == expected, "The calendar was accepted")
9797
}
9898

99-
func testIgnoreCalendarTypesEmptyArray() {
99+
@Test func testIgnoreCalendarTypesEmptyArray() {
100100
let calendar = PlanCalendar.generate()
101101
let expected = true
102102
let actual = CalendarFilter.IgnoreTypes(types: []).accept(calendar)
103103

104-
XCTAssertEqual(actual, expected, "The calendar was rejected")
104+
#expect(actual == expected, "The calendar was rejected")
105105
}
106106

107-
func testSelectCalendarTypesMatching() {
107+
@Test func testSelectCalendarTypesMatching() {
108108
let type = EKCalendarType.birthday
109109
let calendar = PlanCalendar.generate(type: type)
110110
let expected = true
111111
let actual = CalendarFilter.SelectTypes(types: [type]).accept(calendar)
112112

113-
XCTAssertEqual(actual, expected, "The calendar was rejected")
113+
#expect(actual == expected, "The calendar was rejected")
114114
}
115115

116-
func testSelectCalendarTypesNotMatching() {
116+
@Test func testSelectCalendarTypesNotMatching() {
117117
let type = EKCalendarType.calDAV
118118
let calendar = PlanCalendar.generate(type: type)
119119
let expected = false
120120
let actual = CalendarFilter.SelectTypes(types: [EKCalendarType.birthday]).accept(calendar)
121121

122-
XCTAssertEqual(actual, expected, "The calendar was accepted")
122+
#expect(actual == expected, "The calendar was accepted")
123123
}
124124

125-
func testSelectCalendarTypesEmptyArray() {
125+
@Test func testSelectCalendarTypesEmptyArray() {
126126
let calendar = PlanCalendar.generate()
127127
let expected = true
128128
let actual = CalendarFilter.SelectTypes(types: []).accept(calendar)
129129

130-
XCTAssertEqual(actual, expected, "The calendar was rejected")
130+
#expect(actual == expected, "The calendar was rejected")
131131
}
132132
}

‎Tests/EventFilterTest.swift‎

Lines changed: 30 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -1,122 +1,122 @@
11
@testable import plan
2-
import XCTest
2+
import Testing
33

4-
final class EventFilterTests: XCTestCase {
5-
func testAlwaysAccept() {
4+
@Suite final class EventFilterTests {
5+
@Test func testAlwaysAccept() {
66
let event = Event.generate()
77
let expected = true
88
let actual = EventFilter.Accept().accept(event)
99

10-
XCTAssertEqual(actual, expected, "The event was not accepted")
10+
#expect(actual == expected)
1111
}
1212

13-
func testIgnoreTagsNoTags() {
13+
@Test func testIgnoreTagsNoTags() {
1414
let event = Event.generate(tags: ["timeblock"])
1515
let expected = true
1616
let actual = EventFilter.IgnoreTags(tags: []).accept(event)
1717

18-
XCTAssertEqual(actual, expected, "The event was falsely accepted")
18+
#expect(actual == expected)
1919
}
2020

21-
func testIgnoreTagsMatchingTags() {
21+
@Test func testIgnoreTagsMatchingTags() {
2222
let event = Event.generate(tags: ["timeblock"])
2323
let expected = false
2424
let actual = EventFilter.IgnoreTags(tags: ["timeblock"]).accept(event)
2525

26-
XCTAssertEqual(actual, expected, "The event was falsely accepted")
26+
#expect(actual == expected)
2727
}
2828

29-
func testIgnoreTagsNotMatchingTags() {
29+
@Test func testIgnoreTagsNotMatchingTags() {
3030
let event = Event.generate(tags: ["foo"])
3131
let expected = true
3232
let actual = EventFilter.IgnoreTags(tags: ["timeblock"]).accept(event)
3333

34-
XCTAssertEqual(actual, expected, "The event was falsely ignored")
34+
#expect(actual == expected)
3535
}
3636

37-
func testIgnoreAnAllDayEvent() {
37+
@Test func testIgnoreAnAllDayEvent() {
3838
let event = Event.generate(allDay: true)
3939
let expected = false
4040
let actual = EventFilter.IgnoreAllDay().accept(event)
4141

42-
XCTAssertEqual(actual, expected, "The event was falsely accepted")
42+
#expect(actual == expected)
4343
}
4444

45-
func testAcceptAnNonAllDayEvent() {
45+
@Test func testAcceptAnNonAllDayEvent() {
4646
let event = Event.generate(allDay: false)
4747
let expected = true
4848
let actual = EventFilter.IgnoreAllDay().accept(event)
4949

50-
XCTAssertEqual(actual, expected, "The event was falsely ignored")
50+
#expect(actual == expected)
5151
}
5252

53-
func testIgnoringEventMatchingTitle() {
53+
@Test func testIgnoringEventMatchingTitle() {
5454
let event = Event.generate(title: "foo matching")
5555
let expected = false
5656
let actual = EventFilter.IgnorePatternTitle(pattern: "foo").accept(event)
5757

58-
XCTAssertEqual(actual, expected, "The event was falsely accepted")
58+
#expect(actual == expected)
5959
}
6060

61-
func testAcceptingEventNotMatchingTitle() {
61+
@Test func testAcceptingEventNotMatchingTitle() {
6262
let event = Event.generate(title: "foo matching")
6363
let expected = true
6464
let actual = EventFilter.IgnorePatternTitle(pattern: "bar").accept(event)
6565

66-
XCTAssertEqual(actual, expected, "The event was falsely ignored")
66+
#expect(actual == expected)
6767
}
6868

69-
func testAcceptingEventWithAtLeastTwoAttendees() {
69+
@Test func testAcceptingEventWithAtLeastTwoAttendees() {
7070
let event = Event.generate(attendees: ["personA", "personB"])
7171
let expected = true
7272
let actual = EventFilter.MinNumAttendees(count: 2).accept(event)
7373

74-
XCTAssertEqual(actual, expected, "The event was falsely ignored")
74+
#expect(actual == expected)
7575
}
7676

77-
func testAcceptingEventWithTooFewAttendees() {
77+
@Test func testAcceptingEventWithTooFewAttendees() {
7878
let event = Event.generate(attendees: ["personA", "personB"])
7979
let expected = false
8080
let actual = EventFilter.MinNumAttendees(count: 3).accept(event)
8181

82-
XCTAssertEqual(actual, expected, "The event was falsely accepted")
82+
#expect(actual == expected)
8383
}
8484

85-
func testAcceptingEventWithFewAttendees() {
85+
@Test func testAcceptingEventWithFewAttendees() {
8686
let event = Event.generate(attendees: ["personA", "personB"])
8787
let expected = true
8888
let actual = EventFilter.MaxNumAttendees(count: 3).accept(event)
8989

90-
XCTAssertEqual(actual, expected, "The event was falsely ignored")
90+
#expect(actual == expected)
9191
}
9292

93-
func testAcceptingEventWithTooManyAttendees() {
93+
@Test func testAcceptingEventWithTooManyAttendees() {
9494
let event = Event.generate(attendees: ["personA", "personB", "personC"])
9595
let expected = false
9696
let actual = EventFilter.MaxNumAttendees(count: 2).accept(event)
9797

98-
XCTAssertEqual(actual, expected, "The event was falsely accepted")
98+
#expect(actual == expected)
9999
}
100100

101-
func testAcceptCombinedFilter() {
101+
@Test func testAcceptCombinedFilter() {
102102
let event = Event.generate(attendees: ["personA", "personB", "personC"])
103103
let expected = true
104104
let min = EventFilter.MinNumAttendees(count: 2)
105105
let max = EventFilter.MaxNumAttendees(count: 4)
106106

107107
let actual = EventFilter.Combined(filters: [min, max]).accept(event)
108108

109-
XCTAssertEqual(actual, expected, "The event was falsely ignored")
109+
#expect(actual == expected)
110110
}
111111

112-
func testRejectCombinedFilter() {
112+
@Test func testRejectCombinedFilter() {
113113
let event = Event.generate(attendees: ["personA", "personB", "personC"])
114114
let expected = false
115115
let min = EventFilter.MinNumAttendees(count: 4)
116116
let max = EventFilter.MaxNumAttendees(count: 2)
117117

118118
let actual = EventFilter.Combined(filters: [min, max]).accept(event)
119119

120-
XCTAssertEqual(actual, expected, "The event was falsely accepted")
120+
#expect(actual == expected)
121121
}
122122
}

‎Tests/LegendTests.swift‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,29 +1,29 @@
11
@testable import plan
2-
import XCTest
2+
import Testing
33

4-
final class LegendTests: XCTestCase {
5-
func testWithoutEmoji() {
4+
@Suite final class LegendTests {
5+
@Test func testWithoutEmoji() {
66
let input = "Banana"
77
let expected = Legend(description: "Banana", icon: "")
88
let output = input.asLegend()
99

10-
XCTAssertEqual(output, expected, "The emoji was not correctly extracted")
10+
#expect(output == expected)
1111
}
1212

13-
func testLeadingSimpleEmoji() {
13+
@Test func testLeadingSimpleEmoji() {
1414
let input = "🍌 Banana"
1515
let expected = Legend(description: "Banana", icon: "🍌")
1616
let output = input.asLegend()
1717

18-
XCTAssertEqual(output, expected, "The emoji was not correctly extracted")
18+
#expect(output == expected)
1919
}
2020

21-
func testLeadingCombinedEmoji() {
21+
@Test func testLeadingCombinedEmoji() {
2222
// 'Thumbs up' with 'Emoji Modifier Fitzpatrick Type-4':
2323
let input = "👍🏽 Thumb"
2424
let expected = Legend(description: "Thumb", icon: "👍🏽")
2525
let output = input.asLegend()
2626

27-
XCTAssertEqual(output, expected, "The emoji was not correctly extracted")
27+
#expect(output == expected)
2828
}
2929
}

‎Tests/ObjectTests.swift‎

Lines changed: 9 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1,30 +1,22 @@
11
@testable import plan
2-
import XCTest
2+
import Testing
33

4-
final class ObjectTests: XCTestCase {
5-
func testKeyPathOnKeywords() {
4+
@Suite final class ObjectTests {
5+
@Test func testKeyPathOnKeywords() {
66
let event = Event.generate(title: "test")
7-
do {
7+
8+
#expect(throws: Never.self) {
89
let expected = try Object.valueForKeyPath(event, "schedule.start.in") as? Int ?? -1
910
let output = 0
1011

11-
XCTAssertEqual(output, expected, "The fields were not the same")
12-
} catch {
13-
XCTFail("Expected no error, but got \(error)")
12+
#expect(output == expected)
1413
}
1514
}
1615

17-
func testNotComparable() {
16+
@Test func testNotComparable() {
1817
let event = Event.generate(title: "test")
19-
do {
20-
XCTAssertThrowsError(try Object.valueForKeyPath(event, "schedule.start")) { error in
21-
XCTAssertTrue(
22-
error is Object.PathError,
23-
"Unexpected error type: \(type(of: error))"
24-
)
25-
26-
XCTAssertEqual(error as? Object.PathError, .notComparable)
27-
}
18+
#expect(throws: Object.PathError.self) {
19+
try Object.valueForKeyPath(event, "schedule.start")
2820
}
2921
}
3022
}

0 commit comments

Comments
 (0)