Skip to content

Commit ab8918e

Browse files
bordoleybordoley
committed
initial port to xunit for tests.
1 parent f827bb2 commit ab8918e

21 files changed

Lines changed: 705 additions & 710 deletions

‎SQLitePCL.pretty.tests/AsyncTests/AsyncBlobStreamTests.cs‎

Lines changed: 18 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@ You may obtain a copy of the License at
1414
limitations under the License.
1515
*/
1616

17-
using NUnit.Framework;
17+
using Xunit;
1818
using System;
1919
using System.IO;
2020
using System.Reactive.Linq;
@@ -23,10 +23,9 @@ limitations under the License.
2323

2424
namespace SQLitePCL.pretty.tests
2525
{
26-
[TestFixture]
2726
public class AsyncBlobStreamTests
2827
{
29-
[Test]
28+
[Fact]
3029
public async Task TestDispose()
3130
{
3231
using (var db = SQLite3.OpenInMemory().AsAsyncDatabaseConnection())
@@ -51,7 +50,7 @@ await db.Query("SELECT rowid, x FROM foo")
5150
}
5251
}
5352

54-
[Test]
53+
[Fact]
5554
public async Task TestRead()
5655
{
5756
using (var db = SQLite3.OpenInMemory().AsAsyncDatabaseConnection())
@@ -78,7 +77,7 @@ public async Task TestRead()
7877
{
7978
byte[] bite = new byte[1];
8079
await stream.ReadAsync(bite, 0, 1);
81-
Assert.AreEqual(bytes[i], bite[0]);
80+
Assert.Equal(bytes[i], bite[0]);
8281
}
8382

8483
// Since this is a read only stream, this is a good chance to test that writing fails
@@ -87,7 +86,7 @@ public async Task TestRead()
8786
}
8887
}
8988

90-
[Test]
89+
[Fact]
9190
public async Task TestWrite()
9291
{
9392
using (var db = SQLite3.OpenInMemory().AsAsyncDatabaseConnection())
@@ -118,7 +117,7 @@ await db.Query("SELECT rowid, x FROM foo")
118117
{
119118
byte[] bite = new byte[1];
120119
await stream.ReadAsync(bite, 0, 1);
121-
Assert.AreEqual(bytes[i], bite[0]);
120+
Assert.Equal(bytes[i], bite[0]);
122121
}
123122

124123
// Test writing after the end of the stream
@@ -130,13 +129,13 @@ await db.Query("SELECT rowid, x FROM foo")
130129
{
131130
byte[] bite = new byte[1];
132131
await stream.ReadAsync(bite, 0, 1);
133-
Assert.AreEqual(bytes[i], bite[0]);
132+
Assert.Equal(bytes[i], bite[0]);
134133
}
135134
}
136135
}
137136
}
138137

139-
[Test]
138+
[Fact]
140139
public async Task TestSeek()
141140
{
142141
using (var db = SQLite3.OpenInMemory().AsAsyncDatabaseConnection())
@@ -151,28 +150,30 @@ await db.Query("SELECT rowid, x FROM foo")
151150
{
152151
Assert.True(blob.CanSeek);
153152
Assert.Throws<NotSupportedException>(() => blob.SetLength(10));
154-
Assert.DoesNotThrow(() => { blob.Position = 100; });
153+
154+
// Assert does not throw
155+
blob.Position = 100;
155156

156157
// Test input validation
157158
blob.Position = 5;
158159
Assert.Throws<IOException>(() => blob.Seek(-10, SeekOrigin.Begin));
159-
Assert.AreEqual(blob.Position, 5);
160+
Assert.Equal(blob.Position, 5);
160161
Assert.Throws<IOException>(() => blob.Seek(-10, SeekOrigin.Current));
161-
Assert.AreEqual(blob.Position, 5);
162+
Assert.Equal(blob.Position, 5);
162163
Assert.Throws<IOException>(() => blob.Seek(-100, SeekOrigin.End));
163-
Assert.AreEqual(blob.Position, 5);
164+
Assert.Equal(blob.Position, 5);
164165
Assert.Throws<ArgumentException>(() => blob.Seek(-100, (SeekOrigin)10));
165-
Assert.AreEqual(blob.Position, 5);
166+
Assert.Equal(blob.Position, 5);
166167

167168
blob.Seek(0, SeekOrigin.Begin);
168-
Assert.AreEqual(blob.Position, 0);
169+
Assert.Equal(blob.Position, 0);
169170

170171
blob.Seek(0, SeekOrigin.End);
171-
Assert.AreEqual(blob.Position, blob.Length);
172+
Assert.Equal(blob.Position, blob.Length);
172173

173174
blob.Position = 5;
174175
blob.Seek(2, SeekOrigin.Current);
175-
Assert.AreEqual(blob.Position, 7);
176+
Assert.Equal(blob.Position, 7);
176177
}
177178
}
178179
}

‎SQLitePCL.pretty.tests/AsyncTests/AsyncDatabaseConnectionTests.cs‎

Lines changed: 49 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@ You may obtain a copy of the License at
1414
limitations under the License.
1515
*/
1616

17-
using NUnit.Framework;
17+
using Xunit;
1818
using System;
1919
using System.Collections.Generic;
2020
using System.Linq;
@@ -26,34 +26,33 @@ limitations under the License.
2626

2727
namespace SQLitePCL.pretty.tests
2828
{
29-
[TestFixture]
3029
public class AsyncDatabaseConnectionTests
3130
{
32-
[Test]
31+
[Fact]
3332
public async Task TestProfileEvent()
3433
{
3534
using (var db = SQLite3.OpenInMemory().AsAsyncDatabaseConnection())
3635
{
3736
var statement = "CREATE TABLE foo (x int);";
3837
db.Profile.Subscribe(e =>
3938
{
40-
Assert.AreEqual(statement, e.Statement);
41-
Assert.Less(TimeSpan.MinValue, e.ExecutionTime);
39+
Assert.Equal(statement, e.Statement);
40+
Assert.True(TimeSpan.MinValue < e.ExecutionTime);
4241
});
4342

4443
await db.ExecuteAsync(statement);
4544
}
4645
}
4746

48-
[Test]
47+
[Fact]
4948
public async Task TestTraceEvent()
5049
{
5150
using (var db = SQLite3.OpenInMemory().AsAsyncDatabaseConnection())
5251
{
5352
var statement = "CREATE TABLE foo (x int);";
5453
db.Trace.Subscribe(e =>
5554
{
56-
Assert.AreEqual(statement, e.Statement);
55+
Assert.Equal(statement, e.Statement);
5756
});
5857

5958
await db.ExecuteAsync(statement);
@@ -63,7 +62,7 @@ public async Task TestTraceEvent()
6362
}
6463
}
6564

66-
[Test]
65+
[Fact]
6766
public async Task TestUpdateEvent()
6867
{
6968
using (var db = SQLite3.OpenInMemory().AsAsyncDatabaseConnection())
@@ -73,10 +72,10 @@ public async Task TestUpdateEvent()
7372

7473
db.Update.Subscribe(e =>
7574
{
76-
Assert.AreEqual(currentAction, e.Action);
77-
Assert.AreEqual("main", e.Database);
78-
Assert.AreEqual("foo", e.Table);
79-
Assert.AreEqual(rowid, e.RowId);
75+
Assert.Equal(currentAction, e.Action);
76+
Assert.Equal("main", e.Database);
77+
Assert.Equal("foo", e.Table);
78+
Assert.Equal(rowid, e.RowId);
8079
});
8180

8281
currentAction = ActionCode.CreateTable;
@@ -97,7 +96,7 @@ public async Task TestUpdateEvent()
9796
}
9897
}
9998

100-
[Test]
99+
[Fact]
101100
public async Task TestUse()
102101
{
103102
using (var adb = SQLite3.OpenInMemory().AsAsyncDatabaseConnection())
@@ -106,15 +105,15 @@ await adb.Use(db => Enumerable.Range(0, 1000))
106105
.Scan(Tuple.Create(-1, -1), (x, y) => Tuple.Create(x.Item1 + 1, y))
107106
.Do(result =>
108107
{
109-
Assert.AreEqual(result.Item2, result.Item1);
108+
Assert.Equal(result.Item2, result.Item1);
110109
});
111110

112111
int expected = 10;
113112
var t = await adb.Use(db =>
114113
{
115114
return db.Query("Select ?", expected).SelectScalarInt().First();
116115
});
117-
Assert.AreEqual(t, expected);
116+
Assert.Equal(t, expected);
118117

119118
var anotherUse = adb.Use(db => Enumerable.Range(0, 1000));
120119

@@ -125,11 +124,11 @@ await adb.Use(db => Enumerable.Range(0, 1000))
125124

126125
Assert.Throws<ObjectDisposedException>(() => adb.Use(db => Enumerable.Range(0, 1000)));
127126
Assert.Throws<ObjectDisposedException>(() => anotherUse.Subscribe());
128-
Assert.Throws<ObjectDisposedException>(() => adb.Use(db => { }));
127+
Assert.ThrowsAsync<ObjectDisposedException>(async () => await adb.Use(db => { }));
129128
}
130129
}
131130

132-
[Test]
131+
[Fact]
133132
public async Task TestIDatabaseConnectionStatements()
134133
{
135134
using (var adb = SQLite3.OpenInMemory().AsAsyncDatabaseConnection())
@@ -159,12 +158,12 @@ await adb.Use(db =>
159158
Assert.True(stmts.Contains(stmt));
160159
}
161160

162-
Assert.AreEqual(count, stmts.Count);
161+
Assert.Equal(count, stmts.Count);
163162
});
164163
}
165164
}
166165

167-
[Test]
166+
[Fact]
168167
public async Task TestIDatabaseConnectionEvents()
169168
{
170169
using (var adb = SQLite3.OpenInMemory().AsAsyncDatabaseConnection())
@@ -234,7 +233,7 @@ await adb.Use(db =>
234233
}
235234
}
236235

237-
[Test]
236+
[Fact]
238237
public async Task TestIDatabaseConnectionDispose()
239238
{
240239
using (var adb = SQLite3.OpenInMemory().AsAsyncDatabaseConnection())
@@ -243,19 +242,20 @@ public async Task TestIDatabaseConnectionDispose()
243242

244243
await adb.Use(db =>
245244
{
246-
Assert.DoesNotThrow(() => { var x = db.IsAutoCommit; });
247-
Assert.DoesNotThrow(() => { var x = db.IsReadOnly; });
248-
Assert.DoesNotThrow(() => { var x = db.Changes; });
249-
Assert.DoesNotThrow(() => { var x = db.TotalChanges; });
250-
Assert.DoesNotThrow(() => { var x = db.LastInsertedRowId; });
251-
Assert.DoesNotThrow(() => { var x = db.Statements; });
252-
Assert.DoesNotThrow(() => { var x = db.IsDatabaseReadOnly("main"); });
253-
Assert.DoesNotThrow(() => { using (var stmt = db.PrepareStatement("SELECT x FROM foo;")) { } });
245+
// Assert these don't throw
246+
{ var x = db.IsAutoCommit; }
247+
{ var x = db.IsReadOnly; }
248+
{ var x = db.Changes; }
249+
{ var x = db.TotalChanges; }
250+
{ var x = db.LastInsertedRowId; };
251+
{ var x = db.Statements; };
252+
{ var x = db.IsDatabaseReadOnly("main"); };
253+
{ using (var stmt = db.PrepareStatement("SELECT x FROM foo;")) { } };
254254

255255
int current;
256256
int highwater;
257-
Assert.DoesNotThrow(() => { db.Status(DatabaseConnectionStatusCode.CacheMiss, out current, out highwater, false); });
258-
Assert.DoesNotThrow(() => { db.WalCheckPoint("main"); });
257+
{ db.Status(DatabaseConnectionStatusCode.CacheMiss, out current, out highwater, false); };
258+
{ db.WalCheckPoint("main"); };
259259

260260
db.Dispose();
261261

@@ -276,7 +276,7 @@ await adb.Use(db =>
276276
await adb.Use(db =>
277277
{
278278
// Assert that the database is not disposed, despite the previous user disposing it's instance.
279-
Assert.DoesNotThrow(() => { var x = db.IsAutoCommit; });
279+
{ var x = db.IsAutoCommit; };
280280
});
281281

282282
// Test that subscribe doesn't throw after Dispose() is called.
@@ -285,27 +285,27 @@ await adb.Use(db =>
285285
await disposedObservable.Materialize()
286286
.Do(x =>
287287
{
288-
Assert.AreEqual(x.Kind, NotificationKind.OnError);
289-
Assert.IsInstanceOf<ObjectDisposedException>(x.Exception);
288+
Assert.Equal(x.Kind, NotificationKind.OnError);
289+
Assert.IsAssignableFrom<ObjectDisposedException>(x.Exception);
290290
});
291291
}
292292
}
293293

294-
[Test]
294+
[Fact]
295295
public void TestUseCancelled()
296296
{
297297
using (var adb = SQLite3.OpenInMemory().AsAsyncDatabaseConnection())
298298
{
299299
var cts = new CancellationTokenSource();
300300
cts.Cancel();
301-
Assert.That(async () => await adb.Use((db, ct) => { }, cts.Token), Throws.TypeOf<TaskCanceledException>());
301+
Assert.ThrowsAsync<TaskCanceledException>(async () => await adb.Use((db, ct) => { }, cts.Token));
302302

303303
cts = new CancellationTokenSource();
304-
Assert.That(async () => await adb.Use((db, ct) => { cts.Cancel(); }, cts.Token), Throws.TypeOf<TaskCanceledException>());
304+
Assert.ThrowsAsync<TaskCanceledException>(async () => await adb.Use((db, ct) => { cts.Cancel(); }, cts.Token));
305305
}
306306
}
307307

308-
[Test]
308+
[Fact]
309309
public async Task TestPrepareAllAsync()
310310
{
311311
using (var adb = SQLite3.OpenInMemory().AsAsyncDatabaseConnection())
@@ -316,19 +316,19 @@ await adb.PrepareAllAsync(
316316
"SELECT * FROM foo;" +
317317
"SELECT x FROM foo;" +
318318
"SELECT rowid, x FROM foo;");
319-
Assert.AreEqual(stmts.Count, 3);
319+
Assert.Equal(stmts.Count, 3);
320320

321321
var stmt0 = await stmts[0].Use<string>(stmt => stmt.SQL);
322322
var stmt1 = await stmts[1].Use<string>(stmt => stmt.SQL);
323323
var stmt2 = await stmts[2].Use<string>(stmt => stmt.SQL);
324324

325-
Assert.AreEqual(stmt0, "SELECT * FROM foo;");
326-
Assert.AreEqual(stmt1, "SELECT x FROM foo;");
327-
Assert.AreEqual(stmt2, "SELECT rowid, x FROM foo;");
325+
Assert.Equal(stmt0, "SELECT * FROM foo;");
326+
Assert.Equal(stmt1, "SELECT x FROM foo;");
327+
Assert.Equal(stmt2, "SELECT rowid, x FROM foo;");
328328
}
329329
}
330330

331-
[Test]
331+
[Fact]
332332
public async Task TestQuery()
333333
{
334334
using (var adb = SQLite3.OpenInMemory().AsAsyncDatabaseConnection())
@@ -342,25 +342,25 @@ await adb.Query("Select ?, ?, ?", _0, _1, _2)
342342
.Select(row => Tuple.Create(row[0].ToString(), row[1].ToInt(), row[2].ToInt()))
343343
.FirstAsync();
344344

345-
Assert.AreEqual(result.Item1, _0);
346-
Assert.AreEqual(result.Item2, _1);
347-
Assert.AreEqual(result.Item3 != 0, _2);
345+
Assert.Equal(result.Item1, _0);
346+
Assert.Equal(result.Item2, _1);
347+
Assert.Equal(result.Item3 != 0, _2);
348348
}
349349
}
350350

351-
[Test]
351+
[Fact]
352352
public void TestStatementCancellation()
353353
{
354354
using (var adb = SQLite3.OpenInMemory().AsAsyncDatabaseConnection(TaskPoolScheduler.Default, 1))
355355
{
356356
var cts = new CancellationTokenSource();
357-
Assert.That(async () =>
357+
Assert.ThrowsAsync<TaskCanceledException>(async () =>
358358
await adb.Use((db, ct) =>
359359
{
360360
cts.Cancel();
361361
db.Execute("Select 1;");
362-
Assert.Fail();
363-
}, cts.Token), Throws.TypeOf<TaskCanceledException>());
362+
Assert.True(false, "Expected exception to be thrown.");
363+
}, cts.Token));
364364
}
365365
}
366366
}

0 commit comments

Comments
 (0)