Skip to content

Commit 012402a

Browse files
sboothsbooth
authored
Use Testing instead of XCTest (#82)
1 parent 1ed7926 commit 012402a

3 files changed

Lines changed: 152 additions & 145 deletions

File tree

‎Tests/CSQLiteTests/CSQLiteBasicTests.swift‎

Lines changed: 32 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -13,68 +13,70 @@
1313
** Basic tests of CSQLite functionality.
1414
*/
1515

16-
import XCTest
16+
import Testing
1717
@testable import CSQLite
1818

19-
final class CSQLiteBasicTests: XCTestCase {
19+
#if swift(<6.1) || THREADSAFE_0
20+
@MainActor
21+
#endif
22+
@Suite struct CSQLiteBasicTests {
2023
#if swift(<6.1) || OMIT_AUTOINIT
21-
override class func setUp() {
22-
super.setUp()
24+
init() throws {
2325
// It's necessary to call sqlite3_initialize() since SQLITE_OMIT_AUTOINIT is defined
24-
XCTAssertEqual(sqlite3_initialize(), SQLITE_OK)
26+
try #require(sqlite3_initialize() == SQLITE_OK)
2527
}
2628
#endif
2729

28-
func testInsert() {
30+
@Test func insert() {
2931
var db: OpaquePointer?
30-
XCTAssertEqual(sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nil), SQLITE_OK)
32+
#expect(sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nil) == SQLITE_OK)
3133

32-
XCTAssertEqual(sqlite3_exec(db, "create table t1(a,b);", nil, nil, nil), SQLITE_OK)
34+
#expect(sqlite3_exec(db, "create table t1(a,b);", nil, nil, nil) == SQLITE_OK)
3335

3436
var stmt: OpaquePointer?
35-
XCTAssertEqual(sqlite3_prepare_v2(db, "insert into t1(a,b) values (?,?);", -1, &stmt, nil), SQLITE_OK)
37+
#expect(sqlite3_prepare_v2(db, "insert into t1(a,b) values (?,?);", -1, &stmt, nil) == SQLITE_OK)
3638

3739
let rowCount = 42
3840
for i in 0..<rowCount {
39-
XCTAssertEqual(sqlite3_bind_int64(stmt, 1, sqlite3_int64(i*2)), SQLITE_OK)
40-
XCTAssertEqual(sqlite3_bind_int64(stmt, 2, sqlite3_int64(i*2+1)), SQLITE_OK)
41+
#expect(sqlite3_bind_int64(stmt, 1, sqlite3_int64(i*2)) == SQLITE_OK)
42+
#expect(sqlite3_bind_int64(stmt, 2, sqlite3_int64(i*2+1)) == SQLITE_OK)
4143

42-
XCTAssertEqual(sqlite3_step(stmt), SQLITE_DONE)
44+
#expect(sqlite3_step(stmt) == SQLITE_DONE)
4345

44-
XCTAssertEqual(sqlite3_clear_bindings(stmt), SQLITE_OK)
45-
XCTAssertEqual(sqlite3_reset(stmt), SQLITE_OK)
46+
#expect(sqlite3_clear_bindings(stmt) == SQLITE_OK)
47+
#expect(sqlite3_reset(stmt) == SQLITE_OK)
4648
}
4749

48-
XCTAssertEqual(sqlite3_finalize(stmt), SQLITE_OK)
50+
#expect(sqlite3_finalize(stmt) == SQLITE_OK)
4951

50-
XCTAssertEqual(sqlite3_prepare_v2(db, "select count(*) from t1;", -1, &stmt, nil), SQLITE_OK)
51-
XCTAssertEqual(sqlite3_step(stmt), SQLITE_ROW)
52+
#expect(sqlite3_prepare_v2(db, "select count(*) from t1;", -1, &stmt, nil) == SQLITE_OK)
53+
#expect(sqlite3_step(stmt) == SQLITE_ROW)
5254
let count = Int(sqlite3_column_int64(stmt, 0))
53-
XCTAssertEqual(count, rowCount)
55+
#expect(count == rowCount)
5456

55-
XCTAssertEqual(sqlite3_finalize(stmt), SQLITE_OK)
56-
XCTAssertEqual(sqlite3_close(db), SQLITE_OK)
57+
#expect(sqlite3_finalize(stmt) == SQLITE_OK)
58+
#expect(sqlite3_close(db) == SQLITE_OK)
5759
}
5860

59-
func testSelect() {
61+
@Test func select() {
6062
var db: OpaquePointer?
61-
XCTAssertEqual(sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nil), SQLITE_OK)
63+
#expect(sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nil) == SQLITE_OK)
6264

63-
XCTAssertEqual(sqlite3_exec(db, "create table t1(a,b);", nil, nil, nil), SQLITE_OK)
64-
XCTAssertEqual(sqlite3_exec(db, "insert into t1(a,b) values (1,2);", nil, nil, nil), SQLITE_OK)
65+
#expect(sqlite3_exec(db, "create table t1(a,b);", nil, nil, nil) == SQLITE_OK)
66+
#expect(sqlite3_exec(db, "insert into t1(a,b) values (1,2);", nil, nil, nil) == SQLITE_OK)
6567

6668
var stmt: OpaquePointer?
67-
XCTAssertEqual(sqlite3_prepare_v2(db, "select a,b from t1;", -1, &stmt, nil), SQLITE_OK)
69+
#expect(sqlite3_prepare_v2(db, "select a,b from t1;", -1, &stmt, nil) == SQLITE_OK)
6870

6971
var result = sqlite3_step(stmt)
7072
while result == SQLITE_ROW {
71-
XCTAssertEqual(sqlite3_column_int64(stmt, 0), 1)
72-
XCTAssertEqual(sqlite3_column_int64(stmt, 1), 2)
73+
#expect(sqlite3_column_int64(stmt, 0) == 1)
74+
#expect(sqlite3_column_int64(stmt, 1) == 2)
7375
result = sqlite3_step(stmt)
7476
}
75-
XCTAssertEqual(result, SQLITE_DONE)
77+
#expect(result == SQLITE_DONE)
7678

77-
XCTAssertEqual(sqlite3_finalize(stmt), SQLITE_OK)
78-
XCTAssertEqual(sqlite3_close(db), SQLITE_OK)
79+
#expect(sqlite3_finalize(stmt) == SQLITE_OK)
80+
#expect(sqlite3_close(db) == SQLITE_OK)
7981
}
8082
}

‎Tests/CSQLiteTests/CSQLiteExtensionTests.swift‎

Lines changed: 82 additions & 79 deletions
Original file line numberDiff line numberDiff line change
@@ -13,147 +13,150 @@
1313
** Basic tests of CSQLite statically-linked extension functionality.
1414
*/
1515

16-
import XCTest
16+
import Testing
17+
import Foundation
1718
@testable import CSQLite
1819

19-
final class CSQLiteExtensionTests: XCTestCase {
20+
#if swift(<6.1) || THREADSAFE_0
21+
@MainActor
22+
#endif
23+
@Suite struct CSQLiteExtensionTests {
2024
#if swift(<6.1) || OMIT_AUTOINIT
21-
override class func setUp() {
22-
super.setUp()
25+
init() throws {
2326
// It's necessary to call sqlite3_initialize() since SQLITE_OMIT_AUTOINIT is defined
24-
XCTAssertEqual(sqlite3_initialize(), SQLITE_OK)
27+
try #require(sqlite3_initialize() == SQLITE_OK)
2528
}
2629
#endif
2730

28-
func testCarray() {
29-
XCTAssertEqual(csqlite_sqlite3_auto_extension_carray(), SQLITE_OK)
31+
@Test func carray() throws {
32+
try #require(csqlite_sqlite3_auto_extension_carray() == SQLITE_OK)
3033

3134
var db: OpaquePointer?
32-
XCTAssertEqual(sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nil), SQLITE_OK)
35+
#expect(sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nil) == SQLITE_OK)
3336

34-
XCTAssertEqual(sqlite3_exec(db, "create table t1(a);", nil, nil, nil), SQLITE_OK)
35-
XCTAssertEqual(sqlite3_exec(db, "insert into t1(a) values (2),(3),(4),(5);", nil, nil, nil), SQLITE_OK)
37+
#expect(sqlite3_exec(db, "create table t1(a);", nil, nil, nil) == SQLITE_OK)
38+
#expect(sqlite3_exec(db, "insert into t1(a) values (2),(3),(4),(5);", nil, nil, nil) == SQLITE_OK)
3639

3740
var stmt: OpaquePointer?
38-
XCTAssertEqual(sqlite3_prepare_v2(db, "select a from t1 where a in carray(?);", -1, &stmt, nil), SQLITE_OK)
41+
#expect(sqlite3_prepare_v2(db, "select a from t1 where a in carray(?);", -1, &stmt, nil) == SQLITE_OK)
3942
let array: [Int32] = [3,5];
4043
let mem = UnsafeMutableBufferPointer<Int32>.allocate(capacity: array.count)
4144
_ = mem.initialize(from: array)
42-
XCTAssertEqual(sqlite3_carray_bind(stmt, 1, mem.baseAddress, Int32(array.count), CARRAY_INT32, {
45+
#expect(sqlite3_carray_bind(stmt, 1, mem.baseAddress, Int32(array.count), CARRAY_INT32, {
4346
$0?.deallocate()
44-
}), SQLITE_OK)
45-
XCTAssertEqual(sqlite3_step(stmt), SQLITE_ROW)
46-
XCTAssertEqual(sqlite3_column_int(stmt, 0), 3)
47-
XCTAssertEqual(sqlite3_step(stmt), SQLITE_ROW)
48-
XCTAssertEqual(sqlite3_column_int(stmt, 0), 5)
49-
50-
XCTAssertEqual(sqlite3_finalize(stmt), SQLITE_OK)
51-
XCTAssertEqual(sqlite3_close(db), SQLITE_OK)
47+
}) == SQLITE_OK)
48+
#expect(sqlite3_step(stmt) == SQLITE_ROW)
49+
#expect(sqlite3_column_int(stmt, 0) == 3)
50+
#expect(sqlite3_step(stmt) == SQLITE_ROW)
51+
#expect(sqlite3_column_int(stmt, 0) == 5)
52+
53+
#expect(sqlite3_finalize(stmt) == SQLITE_OK)
54+
#expect(sqlite3_close(db) == SQLITE_OK)
5255
}
5356

54-
func testDecimal() {
55-
XCTAssertEqual(csqlite_sqlite3_auto_extension_decimal(), SQLITE_OK)
57+
@Test func decimal() throws {
58+
try #require(csqlite_sqlite3_auto_extension_decimal() == SQLITE_OK)
5659

5760
var db: OpaquePointer?
58-
XCTAssertEqual(sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nil), SQLITE_OK)
61+
#expect(sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nil) == SQLITE_OK)
5962

6063
var stmt: OpaquePointer?
61-
XCTAssertEqual(sqlite3_prepare_v2(db, "select decimal_add('1.67','2.33');", -1, &stmt, nil), SQLITE_OK)
62-
XCTAssertEqual(sqlite3_step(stmt), SQLITE_ROW)
64+
#expect(sqlite3_prepare_v2(db, "select decimal_add('1.67','2.33');", -1, &stmt, nil) == SQLITE_OK)
65+
#expect(sqlite3_step(stmt) == SQLITE_ROW)
6366
let r = String(cString: sqlite3_column_text(stmt, 0))
64-
XCTAssertEqual(r, "4.00")
67+
#expect(r == "4.00")
6568

66-
XCTAssertEqual(sqlite3_finalize(stmt), SQLITE_OK)
67-
XCTAssertEqual(sqlite3_close(db), SQLITE_OK)
69+
#expect(sqlite3_finalize(stmt) == SQLITE_OK)
70+
#expect(sqlite3_close(db) == SQLITE_OK)
6871
}
6972

70-
func testIEEE() {
71-
XCTAssertEqual(csqlite_sqlite3_auto_extension_ieee754(), SQLITE_OK)
73+
@Test func ieee() throws {
74+
try #require(csqlite_sqlite3_auto_extension_ieee754() == SQLITE_OK)
7275

7376
var db: OpaquePointer?
74-
XCTAssertEqual(sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nil), SQLITE_OK)
77+
#expect(sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nil) == SQLITE_OK)
7578

7679
var stmt: OpaquePointer?
77-
XCTAssertEqual(sqlite3_prepare_v2(db, "select ieee754(45.25);", -1, &stmt, nil), SQLITE_OK)
78-
XCTAssertEqual(sqlite3_step(stmt), SQLITE_ROW)
80+
#expect(sqlite3_prepare_v2(db, "select ieee754(45.25);", -1, &stmt, nil) == SQLITE_OK)
81+
#expect(sqlite3_step(stmt) == SQLITE_ROW)
7982
let f = String(cString: sqlite3_column_text(stmt, 0))
80-
XCTAssertEqual(f, "ieee754(181,-2)")
83+
#expect(f == "ieee754(181,-2)")
8184

82-
XCTAssertEqual(sqlite3_finalize(stmt), SQLITE_OK)
83-
XCTAssertEqual(sqlite3_close(db), SQLITE_OK)
85+
#expect(sqlite3_finalize(stmt) == SQLITE_OK)
86+
#expect(sqlite3_close(db) == SQLITE_OK)
8487
}
8588

86-
func testPercentile() {
87-
XCTAssertEqual(csqlite_sqlite3_auto_extension_percentile(), SQLITE_OK)
89+
@Test func percentile() throws {
90+
try #require(csqlite_sqlite3_auto_extension_percentile() == SQLITE_OK)
8891

8992
var db: OpaquePointer?
90-
XCTAssertEqual(sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nil), SQLITE_OK)
93+
#expect(sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nil) == SQLITE_OK)
9194

9295
var stmt: OpaquePointer?
93-
XCTAssertEqual(sqlite3_prepare_v2(db, "select median(33);", -1, &stmt, nil), SQLITE_OK)
94-
XCTAssertEqual(sqlite3_step(stmt), SQLITE_ROW)
95-
XCTAssertEqual(sqlite3_column_int(stmt, 0), 33)
96+
#expect(sqlite3_prepare_v2(db, "select median(33);", -1, &stmt, nil) == SQLITE_OK)
97+
#expect(sqlite3_step(stmt) == SQLITE_ROW)
98+
#expect(sqlite3_column_int(stmt, 0) == 33)
9699

97-
XCTAssertEqual(sqlite3_finalize(stmt), SQLITE_OK)
98-
XCTAssertEqual(sqlite3_close(db), SQLITE_OK)
100+
#expect(sqlite3_finalize(stmt) == SQLITE_OK)
101+
#expect(sqlite3_close(db) == SQLITE_OK)
99102
}
100103

101-
func testSeries() {
102-
XCTAssertEqual(csqlite_sqlite3_auto_extension_series(), SQLITE_OK)
104+
@Test func series() throws {
105+
try #require(csqlite_sqlite3_auto_extension_series() == SQLITE_OK)
103106

104107
var db: OpaquePointer?
105-
XCTAssertEqual(sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nil), SQLITE_OK)
108+
#expect(sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nil) == SQLITE_OK)
106109

107110
var stmt: OpaquePointer?
108-
XCTAssertEqual(sqlite3_prepare_v2(db, "select * from generate_series(10,20,5);", -1, &stmt, nil), SQLITE_OK)
109-
XCTAssertEqual(sqlite3_step(stmt), SQLITE_ROW)
110-
XCTAssertEqual(sqlite3_column_int(stmt, 0), 10)
111-
XCTAssertEqual(sqlite3_step(stmt), SQLITE_ROW)
112-
XCTAssertEqual(sqlite3_column_int(stmt, 0), 15)
113-
XCTAssertEqual(sqlite3_step(stmt), SQLITE_ROW)
114-
XCTAssertEqual(sqlite3_column_int(stmt, 0), 20)
115-
116-
XCTAssertEqual(sqlite3_finalize(stmt), SQLITE_OK)
117-
XCTAssertEqual(sqlite3_close(db), SQLITE_OK)
111+
#expect(sqlite3_prepare_v2(db, "select * from generate_series(10,20,5);", -1, &stmt, nil) == SQLITE_OK)
112+
#expect(sqlite3_step(stmt) == SQLITE_ROW)
113+
#expect(sqlite3_column_int(stmt, 0) == 10)
114+
#expect(sqlite3_step(stmt) == SQLITE_ROW)
115+
#expect(sqlite3_column_int(stmt, 0) == 15)
116+
#expect(sqlite3_step(stmt) == SQLITE_ROW)
117+
#expect(sqlite3_column_int(stmt, 0) == 20)
118+
119+
#expect(sqlite3_finalize(stmt) == SQLITE_OK)
120+
#expect(sqlite3_close(db) == SQLITE_OK)
118121
}
119122

120-
func testSHA3() {
121-
XCTAssertEqual(csqlite_sqlite3_auto_extension_sha3(), SQLITE_OK)
123+
@Test func sha3() throws {
124+
try #require(csqlite_sqlite3_auto_extension_sha3() == SQLITE_OK)
122125

123126
var db: OpaquePointer?
124-
XCTAssertEqual(sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nil), SQLITE_OK)
127+
#expect(sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nil) == SQLITE_OK)
125128

126129
var stmt: OpaquePointer?
127-
XCTAssertEqual(sqlite3_prepare_v2(db, "select lower(hex(sha3('sqlite')));", -1, &stmt, nil), SQLITE_OK)
128-
XCTAssertEqual(sqlite3_step(stmt), SQLITE_ROW)
130+
#expect(sqlite3_prepare_v2(db, "select lower(hex(sha3('sqlite')));", -1, &stmt, nil) == SQLITE_OK)
131+
#expect(sqlite3_step(stmt) == SQLITE_ROW)
129132
let h = String(cString: sqlite3_column_text(stmt, 0))
130-
XCTAssertEqual(h, "963a88636d4c9cc3f011dfc9dc0058e96669d80a89893c68c0bb08a6a8208db3")
133+
#expect(h == "963a88636d4c9cc3f011dfc9dc0058e96669d80a89893c68c0bb08a6a8208db3")
131134

132-
XCTAssertEqual(sqlite3_finalize(stmt), SQLITE_OK)
133-
XCTAssertEqual(sqlite3_close(db), SQLITE_OK)
135+
#expect(sqlite3_finalize(stmt) == SQLITE_OK)
136+
#expect(sqlite3_close(db) == SQLITE_OK)
134137
}
135138

136-
func testUUID() {
137-
XCTAssertEqual(csqlite_sqlite3_auto_extension_uuid(), SQLITE_OK)
139+
@Test func uuid() throws {
140+
try #require(csqlite_sqlite3_auto_extension_uuid() == SQLITE_OK)
138141

139142
var db: OpaquePointer?
140-
XCTAssertEqual(sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nil), SQLITE_OK)
143+
#expect(sqlite3_open_v2(":memory:", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nil) == SQLITE_OK)
141144

142145
var stmt: OpaquePointer?
143-
XCTAssertEqual(sqlite3_prepare_v2(db, "select uuid();", -1, &stmt, nil), SQLITE_OK)
144-
XCTAssertEqual(sqlite3_step(stmt), SQLITE_ROW)
146+
#expect(sqlite3_prepare_v2(db, "select uuid();", -1, &stmt, nil) == SQLITE_OK)
147+
#expect(sqlite3_step(stmt) == SQLITE_ROW)
145148
let u = String(cString: sqlite3_column_text(stmt, 0))
146149
let comps = u.components(separatedBy: "-")
147-
XCTAssertEqual(comps.count, 5)
148-
XCTAssertEqual(comps[0].count, 8)
149-
XCTAssertEqual(comps[1].count, 4)
150-
XCTAssertEqual(comps[2].count, 4)
151-
XCTAssertEqual(comps[3].count, 4)
152-
XCTAssertEqual(comps[4].count, 12)
150+
#expect(comps.count == 5)
151+
#expect(comps[0].count == 8)
152+
#expect(comps[1].count == 4)
153+
#expect(comps[2].count == 4)
154+
#expect(comps[3].count == 4)
155+
#expect(comps[4].count == 12)
153156
let uu = UUID(uuidString: u)
154-
XCTAssertNotNil(uu)
157+
#expect(uu != nil)
155158

156-
XCTAssertEqual(sqlite3_finalize(stmt), SQLITE_OK)
157-
XCTAssertEqual(sqlite3_close(db), SQLITE_OK)
159+
#expect(sqlite3_finalize(stmt) == SQLITE_OK)
160+
#expect(sqlite3_close(db) == SQLITE_OK)
158161
}
159162
}

0 commit comments

Comments
 (0)