public void SetUp() { SQLite.SQLiteConnectionPool.Shared.Reset(); _connectionString = TestPath.GetTempFileName(); _path = _connectionString; System.IO.File.Delete(_path); }
public IEnumerator UnicodePathsAsync() => UniTask.ToCoroutine(async() => { var path = TestPath.GetTempFileName() + UnicodeText; var db = new SQLiteAsyncConnection(path, true); await db.CreateTableAsync <OrderLine>(); Assert.IsTrue(new FileInfo(path).Length > 0, path); });
private static string GetTempFileName() { #if NETFX_CORE var name = Guid.NewGuid() + ".sqlite"; return(Path.Combine(Windows.Storage.ApplicationData.Current.LocalFolder.Path, name)); #else return(TestPath.GetTempFileName()); #endif }
public void UnicodePaths() { var path = TestPath.GetTempFileName() + UnicodeText; using (var db = new SQLiteConnection(path, true)) { db.CreateTable <OrderLine> (); } Assert.IsTrue(new FileInfo(path).Length > 0, path); }
public void ByteArrays() { //Byte Arrays for comparisson ByteArrayClass[] byteArrays = new ByteArrayClass[] { new ByteArrayClass() { bytes = new byte[] { 1, 2, 3, 4, 250, 252, 253, 254, 255 } }, //Range check new ByteArrayClass() { bytes = new byte[] { 0 } }, //null bytes need to be handled correctly new ByteArrayClass() { bytes = new byte[] { 0, 0 } }, new ByteArrayClass() { bytes = new byte[] { 0, 1, 0 } }, new ByteArrayClass() { bytes = new byte[] { 1, 0, 1 } }, new ByteArrayClass() { bytes = new byte[] { } }, //Empty byte array should stay empty (and not become null) new ByteArrayClass() { bytes = null } //Null should be supported }; SQLiteConnection database = new SQLiteConnection(TestPath.GetTempFileName()); database.CreateTable <ByteArrayClass>(); //Insert all of the ByteArrayClass foreach (ByteArrayClass b in byteArrays) { database.Insert(b); } //Get them back out ByteArrayClass[] fetchedByteArrays = database.Table <ByteArrayClass>().OrderBy(x => x.ID).ToArray(); Assert.AreEqual(fetchedByteArrays.Length, byteArrays.Length); //Check they are the same for (int i = 0; i < byteArrays.Length; i++) { byteArrays[i].AssertEquals(fetchedByteArrays[i]); } }
public void QueryGenericObject() { var path = TestPath.GetTempFileName(); var db = new SQLiteConnection(path, true); db.Execute("create table G(Value integer not null)"); db.Execute("insert into G(Value) values (?)", 42); var r = db.Query <GenericObject> ("select * from G"); Assert.AreEqual(1, r.Count); Assert.AreEqual(42, r[0].Value); }
public void SetPreKeyAction() { var path = TestPath.GetTempFileName(); var key = "SecretKey"; using (var db = new SQLiteConnection(path, true, key, preKeyAction: conn => conn.Execute("PRAGMA cipher_default_use_hmac = OFF;"))) { db.CreateTable <TestTable> (); db.Insert(new TestTable { Value = "Secret Value" }); Assert.AreEqual("0", db.ExecuteScalar <string> ("PRAGMA cipher_default_use_hmac;")); } }
public void SetPostKeyAction() { var path = TestPath.GetTempFileName(); var key = "SecretKey"; using (var db = new SQLiteConnection(new SQLiteConnectionString(path, true, key, postKeyAction: conn => conn.Execute("PRAGMA page_size = 512;")))) { db.CreateTable <TestTable> (); db.Insert(new TestTable { Value = "Secret Value" }); Assert.AreEqual("512", db.ExecuteScalar <string> ("PRAGMA page_size;")); } }
public void Cipher() { var databasePath = TestPath.GetTempFileName(); File.Delete(databasePath); var options = new SQLiteConnectionString(databasePath, true, key: "password"); var encryptedDb = new SQLiteAsyncConnection(options); var options2 = new SQLiteConnectionString(databasePath, true, key: "password", preKeyAction: db => db.Execute("PRAGMA cipher_default_use_hmac = OFF;"), postKeyAction: db => db.Execute("PRAGMA kdf_iter = 128000;")); var encryptedDb2 = new SQLiteAsyncConnection(options2); }
public IEnumerator AsyncWithWalCloses() => UniTask.ToCoroutine(async() => { var path = TestPath.GetTempFileName(); var db = new SQLiteAsyncConnection(path); await db.CreateTableAsync <OrderLine>(); await db.InsertAsync(new OrderLine { }); var lines = await db.Table <OrderLine>().ToListAsync(); Assert.AreEqual(1, lines.Count); await db.CloseAsync(); File.Delete(path); });
public IEnumerator BackupOneTable() => UniTask.ToCoroutine(async() => { var pathSrc = TestPath.GetTempFileName(); var pathDest = TestPath.GetTempFileName(); var db = new SQLiteAsyncConnection(pathSrc); await db.CreateTableAsync <OrderLine>(); await db.InsertAsync(new OrderLine { }); var lines = await db.Table <OrderLine>().ToListAsync(); Assert.AreEqual(1, lines.Count); await db.BackupAsync(pathDest); var destLen = new FileInfo(pathDest).Length; Assert.True(destLen >= 4096); });
public void Issue604_RunInTransactionAsync() { var adb = new SQLiteAsyncConnection(TestPath.GetTempFileName()); adb.CreateTableAsync <TestObj> ().Wait(); var initialCount = adb.Table <TestObj> ().CountAsync().Result; // // Fail a commit // adb.Trace = true; adb.Tracer = m => { //Console.WriteLine (m); if (m.Trim().EndsWith("commit")) { throw SQLiteException.New(SQLite3.Result.Busy, "Make commit fail"); } }; try { adb.RunInTransactionAsync(db => { db.Insert(new TestObj()); }).Wait(); Assert.Fail("Should have thrown"); } catch (AggregateException aex) when(aex.InnerException is SQLiteException ex && ex.Result == SQLite3.Result.Busy) { // Expected } // // Are we stuck? // adb.Tracer = null; adb.RunInTransactionAsync(db => { db.Insert(new TestObj()); }).Wait(); Assert.AreEqual(initialCount + 1, adb.Table <TestObj> ().CountAsync().Result); }
public IEnumerator Asynchronous() => UniTask.ToCoroutine(async() => { await UniTask.Delay(1); // Get an absolute path to the database file var databasePath = TestPath.GetTempFileName(); File.Delete(databasePath); var db = new SQLiteAsyncConnection(databasePath); await db.CreateTableAsync <Stock>(); Console.WriteLine("Table created!"); var stock = new Stock() { Symbol = "AAPL" }; await db.InsertAsync(stock); Console.WriteLine("New sti ID: {0}", stock.Id); var query = db.Table <Stock>().Where(s => s.Symbol.StartsWith("A")); var result = await query.ToListAsync(); foreach (var s in result) { Console.WriteLine("Stock: " + s.Symbol); } Assert.AreEqual(1, result.Count); var count = await db.ExecuteScalarAsync <int>("select count(*) from Stock"); Console.WriteLine(string.Format("Found '{0}' stock items.", count)); Assert.AreEqual(1, count); });
public IEnumerator Issue329_AsyncTransactionFailuresShouldRollback() => UniTask.ToCoroutine(async() => { var adb = new SQLiteAsyncConnection(TestPath.GetTempFileName()); await adb.CreateTableAsync <TestObj>(); var initialCount = await adb.Table <TestObj>().CountAsync(); var rollbacks = 0; // // Fail a commit // adb.Trace = true; adb.Tracer = m => { Console.WriteLine(m); if (m == "Executing: rollback") { rollbacks++; } }; LogAssert.Expect(LogType.Exception, "Exception: User exception"); try { await adb.RunInTransactionAsync(db => { db.Insert(new TestObj()); throw new Exception("User exception"); }); Assert.Fail("Should have thrown"); } catch (AggregateException aex) when(aex.InnerException.Message == "User exception") { // Expected } LogAssert.NoUnexpectedReceived(); Assert.AreEqual(1, rollbacks); });
public void NullableEnum() { SQLiteConnection db = new SQLiteConnection(TestPath.GetTempFileName()); db.CreateTable <NullableEnumClass> (); var withNull = new NullableEnumClass { NullableIntEnum = null, NullableTextEnum = null }; var with1 = new NullableEnumClass { NullableIntEnum = TestIntEnum.One, NullableTextEnum = null }; var with2 = new NullableEnumClass { NullableIntEnum = TestIntEnum.Two, NullableTextEnum = null }; var withNullA = new NullableEnumClass { NullableIntEnum = null, NullableTextEnum = TestTextEnum.Alpha }; var with1B = new NullableEnumClass { NullableIntEnum = TestIntEnum.One, NullableTextEnum = TestTextEnum.Beta }; db.Insert(withNull); db.Insert(with1); db.Insert(with2); db.Insert(withNullA); db.Insert(with1B); var results = db.Table <NullableEnumClass> ().OrderBy(x => x.ID).ToArray(); Assert.AreEqual(5, results.Length); Assert.AreEqual(withNull, results[0]); Assert.AreEqual(with1, results[1]); Assert.AreEqual(with2, results[2]); Assert.AreEqual(withNullA, results[3]); Assert.AreEqual(with1B, results[4]); }
public void NullableInt() { SQLiteConnection db = new SQLiteConnection(TestPath.GetTempFileName()); db.CreateTable <NullableIntClass>(); NullableIntClass withNull = new NullableIntClass() { NullableInt = null }; NullableIntClass with0 = new NullableIntClass() { NullableInt = 0 }; NullableIntClass with1 = new NullableIntClass() { NullableInt = 1 }; NullableIntClass withMinus1 = new NullableIntClass() { NullableInt = -1 }; db.Insert(withNull); db.Insert(with0); db.Insert(with1); db.Insert(withMinus1); NullableIntClass[] results = db.Table <NullableIntClass>().OrderBy(x => x.ID).ToArray(); Assert.AreEqual(4, results.Length); Assert.AreEqual(withNull, results[0]); Assert.AreEqual(with0, results[1]); Assert.AreEqual(with1, results[2]); Assert.AreEqual(withMinus1, results[3]); }
public void AsyncAsTicks() { var db = new SQLiteAsyncConnection(TestPath.GetTempFileName()); TestAsyncDateTimeOffset(db); }
public TestDb(bool storeDateTimeAsTicks = true) : base(TestPath.GetTempFileName(), storeDateTimeAsTicks) { Trace = true; }
public void Setup() { _db = new TestDb(TestPath.GetTempFileName()); }
public void AsyncAsTicks() { var db = new SQLiteConnectionAsync(TestPath.GetTempFileName(), true); TestAsyncDateTime(db); }
public void AsyncAsString() { var db = new SQLiteAsyncConnection(TestPath.GetTempFileName(), false); TestAsyncDateTime(db); }
public void Setup() { _db = new TestDb(TestPath.GetTempFileName()); _db.SetForeignKeysPermissions(true); }
SQLiteConnectionString CustomDateTimeString(string dateTimeFormat) => new SQLiteConnectionString(TestPath.GetTempFileName(), false, dateTimeFormat);
SQLiteConnectionString TimeSpanAsTicks(bool asTicks = true) => new SQLiteConnectionString(TestPath.GetTempFileName(), SQLiteOpenFlags.Create | SQLiteOpenFlags.ReadWrite, true, storeTimeSpanAsTicks: asTicks);
public void Setup() { this.database = new GetTestWithOne2OneRelationshipDb(TestPath.GetTempFileName()); this.database.SetForeignKeysPermissions(true); }
SQLiteConnectionString CustomDateTimeString(string dateTimeFormat) => new SQLiteConnectionString(TestPath.GetTempFileName(), SQLiteOpenFlags.Create | SQLiteOpenFlags.ReadWrite, false, dateTimeStringFormat: dateTimeFormat);
public TestDb(bool storeDateTimeAsTicks = true, object key = null, bool wal = true) : base(new SQLiteConnectionString(TestPath.GetTempFileName(), storeDateTimeAsTicks, key: key)) { Trace = true; if (wal) { EnableWriteAheadLogging(); } }
public IEnumerator AsyncAsString() => UniTask.ToCoroutine(async() => { var db = new SQLiteAsyncConnection(TestPath.GetTempFileName(), false); await TestAsyncDateTime(db); });
public IEnumerator AsyncAsTicks() => UniTask.ToCoroutine(async() => { var db = new SQLiteAsyncConnection(TestPath.GetTempFileName()); await TestAsyncDateTimeOffset(db); });
public TestDb() : base(TestPath.GetTempFileName()) { Trace = true; }