public void GetText_MultipleRowsExactMatch()
{
SqlLiteDatabase db = CreateTestDatabase(String.Format("{0}", dbConstants.GUID));
_w.output("database made");
db.InsertData(dbConstants.table_name, new string[3] {
dbConstants.STATUS, dbConstants.XML, dbConstants.GUID
}, new object[3] {
"boo status", "boo xml", "GUID_A"
});
db.InsertData(dbConstants.table_name, new string[3] {
dbConstants.STATUS, dbConstants.XML, dbConstants.GUID
}, new object[3] {
"boo status", "boo xml", "GUID_B"
});
db.InsertData(dbConstants.table_name, new string[3] {
dbConstants.STATUS, dbConstants.XML, dbConstants.GUID
}, new object[3] {
"boo status", "boo xml", "GUID_C"
});
db.InsertData(dbConstants.table_name, new string[3] {
dbConstants.STATUS, dbConstants.XML, dbConstants.GUID
}, new object[3] {
"boo status2", "boo xml", "GUID_D"
});
System.Collections.Generic.List <object[]> list = db.GetValues(dbConstants.table_name, new string[1] {
dbConstants.GUID
}, dbConstants.STATUS, "boo status");
_w.output(list.Count);
Assert.AreEqual(3, list.Count);
db.Dispose();
}
public void TestResultObject()
{
var db = new SqlLiteDatabase("Data Source=:memory:");
db.Process((conn, tran) =>
{
CreateTableForTest(conn);
InsertDataForTest(conn, tran);
SqlLiteDatabase.Query(
"select TEST_COL1,TEST_COL2 from TEST_TABLE",
conn,
tran,
(result) =>
{
result.Next();
var resultObject =
result.ResultObject(
(original) => new SampleObject {
Val1 = original.TEST_COL1,
Val2 = original.TEST_COL2
}
);
Assert.AreEqual(resultObject.Val1, "testValue");
Assert.AreEqual(resultObject.Val2, 123);
});
});
}
public void RowDoesNotExistOnUpdate()
{
SqlLiteDatabase db = CreateTestDatabase(String.Format("{0}", dbConstants.GUID));
db.InsertData(dbConstants.table_name, new string[3] {
dbConstants.STATUS, dbConstants.XML, dbConstants.GUID
}, new object[3] {
"boo status", "boo xml", "GUID_A"
});
// we fail to update
Assert.AreEqual(false, db.UpdateSpecificColumnData(dbConstants.table_name, new string[1] {
dbConstants.STATUS
},
new object[1] {
"snakes!"
}, dbConstants.GUID, "GUID_B"));
// there is a problem with updating specific column data AND not having the right GUID. Crashes rest of unit tests
Assert.AreEqual("boo status", db.GetValues(dbConstants.table_name, new string[1] {
dbConstants.STATUS
}, dbConstants.GUID, "GUID_A")[0][0].ToString());
db.Dispose();
}
public void TestLoadAsync()
{
var db = new SqlLiteDatabase("Data Source=:memory:");
db.Process((conn, tran) =>
{
CreateTableForTest(conn);
InsertDataForTest(conn, tran);
InsertDataForTest(conn, tran);
dynamic[] result =
SqlLiteDatabase
.SqlResult
.LoadSqlResultAsync(
"select TEST_COL1,TEST_COL2 from TEST_TABLE",
conn,
tran)
.Result;
Assert.AreEqual(result[0].TEST_COL1, "testValue");
Assert.AreEqual(result[0].TEST_COL2, 123);
Assert.AreEqual(result.Length, 2);
});
}
public void TestTransaction()
{
SqlLiteDatabase db = new SqlLiteDatabase("Data Source=:memory:");
db.Process((connection) => {
CreateTableForTest(connection);
SqlLiteDatabase.Transaction(connection,
(conn, tran) => {
InsertDataForTest(conn, tran);
tran.Rollback();
}
);
SqlLiteDatabase.Transaction(connection,
(conn, tran) =>
{
AssertDataCount(0, conn, tran);
InsertDataForTest(conn, tran);
AssertDataCount(1, conn, tran);
tran.Commit();
}
);
SqlLiteDatabase.Transaction(connection,
(conn, tran) =>
{
AssertDataCount(1, conn, tran);
}
);
});
}
public void TestTransactionAsync()
{
SqlLiteDatabase db = new SqlLiteDatabase("Data Source=:memory:");
db.Process(async(connection) => {
CreateTableForTest(connection);
await SqlLiteDatabase.TransactionAsync(connection,
async(conn, tran) => {
await Task.Delay(1);
InsertDataForTest(conn, tran);
tran.Rollback();
}
);
await SqlLiteDatabase.TransactionAsync(connection,
async(conn, tran) =>
{
await Task.Delay(1);
AssertDataCount(0, conn, tran);
InsertDataForTest(conn, tran);
AssertDataCount(1, conn, tran);
tran.Commit();
}
);
await SqlLiteDatabase.TransactionAsync(connection,
async(conn, tran) =>
{
await Task.Delay(1);
AssertDataCount(1, conn, tran);
}
);
});
}
public void GetPrice_PriceExists_ReturnsPrice()
{
var price = 3.50M;
var dateTime = Math.Round((DateTime.Today.ToUniversalTime() - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds);
var dataReader = Substitute.For <IDataReader>();
dataReader.Read().Returns(true);
dataReader.GetInt32(0).Returns(0);
dataReader.GetString(1).Returns("Product1");
dataReader.GetString(2).Returns("Site1");
dataReader.GetString(3).Returns("http://www.example.com/product1.html");
dataReader.GetString(4).Returns(@"\\*\span[1]");
dataReader.GetDecimal(5).Returns(price);
dataReader.GetDouble(6).Returns(0);
var dbCommand = Substitute.For <IDbCommand>();
dbCommand.ExecuteReader().Returns(dataReader);
var dbConnection = Substitute.For <IDbConnection>();
dbConnection.CreateCommand().Returns(dbCommand);
var sqlLiteDatabase = new SqlLiteDatabase(dbConnection);
Assert.That(price == sqlLiteDatabase.GetPrice("Product1", "Site1", DateTime.Today).Price);
}
public void GetMultipleRowsWhenMultipleRowsMatch()
{
_w.output("**Get data Test**");
SqlLiteDatabase db = CreateTestDatabase(String.Format("{0}", dbConstants.GUID));
_w.output("database made");
db.InsertData(dbConstants.table_name, new string[3] {
dbConstants.STATUS,
dbConstants.XML,
dbConstants.GUID
}
, new object[3] {
"boo status", "boo xml", "GUID_A"
});
_w.output("first roww");
db.InsertData(dbConstants.table_name, new string[3] {
dbConstants.STATUS,
dbConstants.XML,
dbConstants.GUID
}
, new object[3] {
"boo status", "boo xmlB", "GUID_B"
});
System.Collections.Generic.List <object[]> results = db.GetValues(dbConstants.table_name, new string[1] {
dbConstants.GUID
}, dbConstants.STATUS, "boo status");
int count = 0;
if (results != null)
{
foreach (object[] o in results)
{
count++;
foreach (object oo in o)
{
Console.WriteLine(oo.ToString());
}
}
}
Console.WriteLine(count);
Assert.AreEqual(count, 2);
/*// need to find 2 rows
* if (2 == count) {
* Console.WriteLine ("success");
*
* } else {
* Console.WriteLine(count + " rows found instead of 2");
* Assert.True(false);
* }*/
}
public void TestEnumerable()
{
var db = new SqlLiteDatabase("Data Source=:memory:");
db.Process((conn, tran) =>
{
CreateTableForTest(conn);
InsertDataForTest(conn, tran);
SqlLiteDatabase.Query(
"select TEST_COL1,TEST_COL2 from TEST_TABLE",
conn,
tran,
(result) =>
{
var array =
result.AsEnumerable <SampleObject>(
(original) => new SampleObject
{
Val1 = original.TEST_COL1,
Val2 = original.TEST_COL2
}
).ToArray();
Assert.AreEqual(array[0].Val1, "testValue");
Assert.AreEqual(array[0].Val2, 123);
Assert.AreEqual(array.Length, 1);
var list =
result.AsEnumerable <dynamic>(
(original) => original
).ToList();
Assert.AreEqual(1, list.Count);
var sum =
result.AsEnumerable <int>(
(original) => (int)original.TEST_COL2
).Sum();
Assert.AreEqual(123, sum);
InsertDataForTest(conn, tran);
var sum2 =
result.AsEnumerable <int>(
(original) => (int)original.TEST_COL2
).Sum();
Assert.AreEqual(123 * 2, sum2);
});
});
}
public void TestQuery()
{
SqlLiteDatabase db = new SqlLiteDatabase("Data Source=:memory:");
db.Process((connection, transaction) =>
{
CreateTableForTest(connection);
SqlLiteDatabase.ExecuteNonQuery(
"insert into TEST_TABLE(TEST_VAL1,TEST_VAL2) values('abcdef',123)",
connection,
transaction);
SqlLiteDatabase.ExecuteNonQuery(
"insert into TEST_TABLE(TEST_VAL1,TEST_VAL2) values('xyz',456)",
connection,
transaction);
SqlLiteDatabase.Query(
"select TEST_VAL1,TEST_VAL2 from TEST_TABLE",
connection,
transaction,
(result) => {
if (result.Next())
{
var resultValues = result.ResultValues;
Assert.AreEqual(resultValues.TEST_VAL1, "abcdef");
Assert.AreEqual(resultValues.TEST_VAL2, 123L);
//Same instance
Assert.AreSame(resultValues, result.ResultValues);
var resultTuples = result.ResultTuples;
Assert.AreEqual(resultTuples[0].name, "TEST_VAL1");
Assert.AreEqual(resultTuples[0].value, "abcdef");
Assert.AreEqual(resultTuples[1].name, "TEST_VAL2");
Assert.AreEqual(resultTuples[1].value, 123L);
//go to next row.
result.Next();
var resultValues2 = result.ResultValues;
Assert.AreEqual(resultValues2.TEST_VAL1, "xyz");
Assert.AreEqual(resultValues2.TEST_VAL2, 456L);
}
else
{
Assert.Fail();
}
}
);
SqlLiteDatabase.Query(
"select TEST_VAL1,TEST_VAL2 from TEST_TABLE where TEST_VAL1 = @val1",
new (String, object)[] { ValueTuple.Create("@val1", "abcdef") },
public void TestConnect()
{
SqlLiteDatabase db = new SqlLiteDatabase("Data Source=:memory:");
db.Process((connection) => {
});
db.Process((connection, transaction) =>
{
});
}
public void TestScalar()
{
SqlLiteDatabase db = new SqlLiteDatabase("Data Source=:memory:");
db.Process((conn, tran) => {
var testValue = "TESTVALUE";
var result = SqlLiteDatabase.ExecuteFormattableScalar($"values({testValue})", conn, tran);
Assert.AreEqual(testValue, result);
});
}
public void DatabaseIsDisposed()
{
SqlLiteDatabase db = CreateTestDatabase(String.Format("{0}", dbConstants.GUID));
db.Dispose();
Assert.That(delegate { db.GetValues(dbConstants.table_name, new string[1] {
dbConstants.STATUS
}, dbConstants.GUID, "GUID_A"); },
Throws.Exception);
}
public void TestCommandText()
{
var db = new SqlLiteDatabase("Data Source=:memory:");
db.Process((conn, tran) =>
{
var sql = "values(1,2,3)";
SqlLiteDatabase.Query(sql, conn, tran, (result) => {
Assert.AreEqual(sql, result.Sql);
});
});
}
public void TestEmptyFieldName()
{
var db = new SqlLiteDatabase("Data Source=:memory:");
db.Process((conn, tran) =>
{
var sql = "values(1,2,3)";
SqlLiteDatabase.Query(sql, conn, tran, (result) => {
result.Next();
var fieldNames = result.ResultFields;
});
});
}
[TestMethod] public void TestNonQuery()
{
SqlLiteDatabase db = new SqlLiteDatabase("Data Source=:memory:");
db.Process((conn, tran) => {
SqlLiteDatabase.ExecuteNonQuery("create table TEST_TABLE(COL1 text)", conn, tran);
var testValue = "TESTVALUE";
SqlLiteDatabase.ExecuteFormattableNonQuery($"insert into TEST_TABLE(COL1) values({testValue})", conn, tran);
Assert.AreEqual(testValue, SqlLiteDatabase.ExecuteScalar("select COL1 from TEST_TABLE", conn, tran));
});
}
public void BlankTable_GetValues()
{
SqlLiteDatabase db = CreateTestDatabase(String.Format("{0}", dbConstants.GUID));
//db.InsertData (tmpDatabaseConstants.table_name, new string[3] { tmpDatabaseConstants.STATUS,tmpDatabaseConstants.XML,tmpDatabaseConstants.GUID
//}, new object[3] {"boo status", "boo xml", "GUID_A"});
Assert.True(db.GetValues(dbConstants.table_name, new string[1] {
dbConstants.STATUS
}, dbConstants.GUID, "GUID_A").Count == 0);
//Assert.That (delegate {db.GetValues(tmpDatabaseConstants.table_name, new string[1]{"a"}, tmpDatabaseConstants.GUID, "GUID_A"); },Throws.Exception );
//Assert.Throws(typeof(Exception), db.GetValues(tmpDatabaseConstants.table_name, new string[1]{"a"}, tmpDatabaseConstants.GUID, "a"));
db.Dispose();
}
public void GetText_TestShouldHaveNoProblems()
{
SqlLiteDatabase db = CreateTestDatabase(String.Format("{0}", dbConstants.GUID));
_w.output("database made");
db.InsertData(dbConstants.table_name, new string[3] {
dbConstants.STATUS, dbConstants.XML, dbConstants.GUID
}, new object[3] {
"boo status", "boo xml", "GUID_A"
});
db.GetValues(dbConstants.table_name, new string[1] {
dbConstants.STATUS
}, dbConstants.GUID, "GUID_A");
db.Dispose();
}
public void GetText_NoTable()
{
SqlLiteDatabase db = CreateTestDatabase(String.Format("{0}", dbConstants.GUID));
_w.output("database made");
db.InsertData(dbConstants.table_name, new string[3] {
dbConstants.STATUS, dbConstants.XML, dbConstants.GUID
}, new object[3] {
"boo status", "boo xml", "GUID_A"
});
db.GetValues("", new string[1] {
"irrelevant"
}, dbConstants.GUID, "GUID_A");
}
public void UpdateNullValues()
{
SqlLiteDatabase db = CreateTestDatabase(String.Format("{0}", dbConstants.GUID));
db.InsertData(dbConstants.table_name, new string[3] {
dbConstants.STATUS, dbConstants.XML, dbConstants.GUID
}, new object[3] {
"boo status", "boo xml", "GUID_A"
});
db.UpdateSpecificColumnData(dbConstants.table_name, new string[1] {
dbConstants.STATUS
},
null, dbConstants.GUID, "GUID_A");
db.Dispose();
}
public void GetPrice_PriceNotExists_NotReturnsPrice()
{
var dataReader = Substitute.For <IDataReader>();
dataReader.Read().Returns(false);
var dbCommand = Substitute.For <IDbCommand>();
dbCommand.ExecuteReader().Returns(dataReader);
var dbConnection = Substitute.For <IDbConnection>();
dbConnection.CreateCommand().Returns(dbCommand);
var sqlLiteDatabase = new SqlLiteDatabase(dbConnection);
Assert.That(sqlLiteDatabase.GetPrice("Product1", "Site1", DateTime.Today) == null);
}
public void TestSortingOnGetValues_ShouldFailBecauseAreSubPanels()
{
Layout.LayoutDetails.Instance.YOM_DATABASE = test_database_name;
SqlLiteDatabase db = CreateTestDatabase(String.Format("{0}", dbConstants.ID));
db.InsertData(dbConstants.table_name, new string[4] {
dbConstants.NAME, dbConstants.XML, dbConstants.GUID, dbConstants.SUBPANEL
}, new object[4] {
"Zum", "boo xml", "GUID_DDA", 1
});
db.InsertData(dbConstants.table_name, new string[4] {
dbConstants.NAME, dbConstants.XML, dbConstants.GUID, dbConstants.SUBPANEL
}, new object[4] {
"Alexander", "boo xml", "GUID_B", 1
});
db.InsertData(dbConstants.table_name, new string[4] {
dbConstants.NAME, dbConstants.XML, dbConstants.GUID, dbConstants.SUBPANEL
}, new object[4] {
"aboo", "boo xml", "GUID_A", 1
});
db.InsertData(dbConstants.table_name, new string[4] {
dbConstants.NAME, dbConstants.XML, dbConstants.GUID, dbConstants.SUBPANEL
}, new object[4] {
"Calv", "boo xml", "GUID_C", 1
});
// Layout.MasterOfLayouts mastery = new Layout.MasterOfLayouts ();
List <Layout.MasterOfLayouts.NameAndGuid> list = MasterOfLayouts.GetListOfLayouts(Constants.BLANK);
foreach (Layout.MasterOfLayouts.NameAndGuid guid in list)
{
_w.output(guid.Caption);
}
Assert.AreEqual(0, list.Count);
/*Assert.AreEqual ("aboo", list[0].Caption);
* Assert.AreEqual ("Alexander", list[1].Caption);
* Assert.AreEqual ("Calv", list[2].Caption);
* Assert.AreEqual ("Zum", list[3].Caption);
*/
// mastery.Dispose ();
db.Dispose();
}
public void TestConnectAsync()
{
SqlLiteDatabase db = new SqlLiteDatabase("Data Source=:memory:");
Task task1 = db.ProcessAsync(async(connection) =>
{
await Task.Delay(1); //Dummy code to resolve warning in build.
});
task1.Wait();
Task task2 = db.ProcessAsync(async(connection, transaction) =>
{
await Task.Delay(1); //Dummy code to resolve warning in build.
});
task2.Wait();
}
public void TestException()
{
const String ERROR_MSG = "Intentinal Exception";
try
{
SqlLiteDatabase db = new SqlLiteDatabase("Data Source=:memory:");
db.Process((connection, transaction) =>
{
throw new ApplicationException(ERROR_MSG);
});
Assert.Fail();
}
catch (DatabaseException ex)
{
Assert.AreEqual(ex.InnerException.Message, ERROR_MSG);
}
}
public void GetText_ExpectBlankString()
{
SqlLiteDatabase db = CreateTestDatabase(String.Format("{0}", dbConstants.GUID));
_w.output("database made");
db.InsertData(dbConstants.table_name, new string[3] {
dbConstants.STATUS, dbConstants.XML, dbConstants.GUID
}, new object[3] {
"boo status", "boo xml", "GUID_A"
});
System.Collections.Generic.List <object[]> list = db.GetValues(dbConstants.table_name, new string[1] {
dbConstants.STATUS
}, dbConstants.GUID, "GUID_B");
// expect an empty list
Assert.AreEqual(list.Count, 0);
//Assert.IsNull(list);
db.Dispose();
}
//[ExpectedException]
public void GetText_ReturnColumnDoesNotExists()
{
SqlLiteDatabase db = CreateTestDatabase(String.Format("{0}", dbConstants.GUID));
_w.output("database made");
db.InsertData(dbConstants.table_name, new string[3] {
dbConstants.STATUS, dbConstants.XML, dbConstants.GUID
}, new object[3] {
"boo status", "boo xml", "GUID_A"
});
// db.GetValues(tmpDatabaseConstants.table_name, new string[1]{"booboo"}, tmpDatabaseConstants.GUID, "GUID_A");
// just trying another way to structure the test. see http://nunit.net/blogs/?p=63
Assert.That(delegate { db.GetValues(dbConstants.table_name, new string[1] {
"booboo"
}, dbConstants.GUID, "GUID_A"); }, Throws.Exception);
db.Dispose();
}
public void GetText_ExpectExactResult()
{
SqlLiteDatabase db = CreateTestDatabase(String.Format("{0}", dbConstants.GUID));
_w.output("database made");
db.InsertData(dbConstants.table_name, new string[3] {
dbConstants.STATUS, dbConstants.XML, dbConstants.GUID
}, new object[3] {
"boo status", "boo xml", "GUID_A"
});
System.Collections.Generic.List <object[]> list = db.GetValues(dbConstants.table_name, new string[1] {
dbConstants.STATUS
}, dbConstants.GUID, "GUID_A");
_w.output(list[0][0].ToString());
if (list == null)
{
Assert.True(false);
}
Assert.AreEqual(list[0][0].ToString(), "boo status");
db.Dispose();
}
public void TestQuery()
{
SqlLiteDatabase db = new SqlLiteDatabase("Data Source=:memory:");
db.Process((conn, tran) => {
var testValue = "TESTVALUE";
var testValue2 = "TESTVALUE2";
SqlLiteDatabase.QueryFormattable(
$"values({testValue},{testValue2})",
conn,
tran,
(result) => {
Assert.AreEqual(result.Sql, "values(@0,@1)");
result.Next();
Assert.AreEqual(testValue, result.ResultTuples[0].value);
Assert.AreEqual(testValue2, result.ResultTuples[1].value);
}
);
});
}
public void TestFieldName()
{
var db = new SqlLiteDatabase("Data Source=:memory:");
db.Process((conn, tran) =>
{
CreateTableForTest(conn);
InsertDataForTest(conn, tran);
SqlLiteDatabase.Query(
"select TEST_COL1,TEST_COL2 from TEST_TABLE",
conn,
tran,
(result) =>
{
result.Next();
var fieldNames = result.ResultFields;
Assert.AreEqual(fieldNames[0], "TEST_COL1");
Assert.AreEqual(fieldNames[1], "TEST_COL2");
});
});
}
public void UpdateDataWorks()
{
SqlLiteDatabase db = CreateTestDatabase(String.Format("{0}", dbConstants.GUID));
db.InsertData(dbConstants.table_name, new string[3] {
dbConstants.STATUS, dbConstants.XML, dbConstants.GUID
}, new object[3] {
"boo status", "boo xml", "GUID_A"
});
db.UpdateSpecificColumnData(dbConstants.table_name, new string[1] {
dbConstants.STATUS
},
new object[1] {
"snakes!"
}, dbConstants.GUID, "GUID_A");
Assert.AreEqual("snakes!", db.GetValues(dbConstants.table_name, new string[1] {
dbConstants.STATUS
}, dbConstants.GUID, "GUID_A")[0][0].ToString());
db.Dispose();
}
public void SpeedTest()
{
// this will be a benchmarking test that will create a complicated Layout
// Then it will time and record the results of LOADING and SAVING that layout into a
// table saved in my backup paths
// will also output a DAAbackup file (text readable) format too
_TestSingleTon.Instance._SetupForLayoutPanelTests();
System.Windows.Forms .Form form = _TestSingleTon.Instance.FORM;//new System.Windows.Forms.Form();
FAKE_LayoutPanel panel = new FAKE_LayoutPanel (CoreUtilities.Constants.BLANK, false);
form.Controls.Add (panel);
// needed else DataGrid does not initialize
form.Show ();
//form.Visible = false;
_w.output("boom");
// March 2013 -- notelist relies on having this
YOM2013.DefaultLayouts.CreateASystemLayout(form,null);
//NOTE: For now remember that htis ADDS 1 Extra notes
string panelname = System.Guid.NewGuid().ToString();
panel.NewLayout (panelname,true, null);
LayoutDetails.Instance.AddToList (typeof(FAKE_NoteDataXML_Panel), "testingpanel");
_w.output ("herefirst");
// ADD 1 of each type
foreach (Type t in LayoutDetails.Instance.ListOfTypesToStoreInXML()) {
for (int i = 0; i < 10; i++) {
NoteDataInterface note = (NoteDataInterface)Activator.CreateInstance (t);
panel.AddNote (note);
note.CreateParent(panel);
}
}
_w.output("here");
FAKE_NoteDataXML_Panel panelA = new FAKE_NoteDataXML_Panel ();
panelA.Caption = "PanelA";
panel.AddNote (panelA);
string stringoftypes = "";
foreach (Type t in LayoutDetails.Instance.ListOfTypesToStoreInXML()) {
NoteDataInterface note = (NoteDataInterface)Activator.CreateInstance (t);
panelA.AddNote (note);
stringoftypes = stringoftypes + " " + t.ToString();
}
panel.SaveLayout();
string base_path = _TestSingleTon.PATH_TO_SpeedTestFiles;//@"C:\Users\BrentK\Documents\Keeper\Files\yomspeedtests2013\";
_w.output ("here");
NoteDataXML_RichText richy;
for (int i = 0; i < 20; i ++) {
richy = new NoteDataXML_RichText ();
richy.Caption = "richtext";
panel.AddNote (richy);
Assert.True (richy.GetIsRichTextBlank ());
richy.DoOverwriteWithRTFFile (System.IO.Path.Combine (base_path,"speedtest.rtf"));
Assert.False (richy.GetIsRichTextBlank ());
}
_w.output("First save");
panel.SaveLayout();
string table = "layoutpanelsaveload";
// Now try and write this data out.
SqlLiteDatabase timetracking = new SqlLiteDatabase(System.IO.Path.Combine (base_path,"speedtests.s3db"));
timetracking.CreateTableIfDoesNotExist(table, new string [5] {"id", "datetime", "timetook", "types","saveorload"},
new string[5] {"INTEGER", "TEXT", "FLOAT", "TEXT", "TEXT"}, "id");
// * Now start the Load Test
TimeSpan time;
CoreUtilities.TimerCore.TimerOn = true;
time = CoreUtilities.TimerCore.Time (() => {
panel = new FAKE_LayoutPanel (CoreUtilities.Constants.BLANK, false);
form.Controls.Add (panel);
panel.LoadLayout(panelname, false,null);
});
_w.output("TIME " + time);
timetracking.InsertData(table, new string[4] {"datetime", "timetook", "types","saveorload"},new object[4] {DateTime.Now.ToString (),
time.TotalSeconds, stringoftypes,"load"});
time = CoreUtilities.TimerCore.Time (() => {
// We keep the PANEL from above! Don't recreate it.
//panel = new FAKE_LayoutPanel (CoreUtilities.Constants.BLANK);
panel.SaveLayout();
});
Console.WriteLine("TIME " + time);
timetracking.InsertData(table, new string[4] {"datetime", "timetook", "types","saveorload"},new object[4] {DateTime.Now.ToString (),
time.TotalSeconds, stringoftypes,"save"});
string backup = timetracking.BackupDatabase();
System.IO.TextWriter write = new System.IO.StreamWriter(System.IO.Path.Combine (base_path,"timeresults.txt"));
write.WriteLine (backup);
write.Close();
FakeLayoutDatabase layout = new FakeLayoutDatabase("testguid");
FAKE_SqlLiteDatabase db = new FAKE_SqlLiteDatabase(layout.GetDatabaseName ());
_w.output("Backup of stored database: " + db.BackupDatabase());
timetracking.Dispose();
db.Dispose();
}
