public void test_result_errors()
{
int code = 10;
delegate_function_scalar errorcode_func =
(ctx, user_data, args) => raw.sqlite3_result_error_code(ctx, code);
delegate_function_scalar toobig_func =
(ctx, user_data, args) => raw.sqlite3_result_error_toobig(ctx);
delegate_function_scalar nomem_func =
(ctx, user_data, args) => raw.sqlite3_result_error_nomem(ctx);
using (sqlite3 db = ugly.open(":memory:"))
{
db.create_function("errorcode", 0, null, errorcode_func);
db.create_function("toobig", 0, null, toobig_func);
db.create_function("nomem", 0, null, nomem_func);
try
{
db.exec("select errorcode();");
Assert.Fail("expected exception");
}
catch (ugly.sqlite3_exception e)
{
Assert.AreEqual(e.errcode, code);
}
try
{
db.exec("select toobig();");
Assert.Fail("expected exception");
}
catch (ugly.sqlite3_exception e)
{
Assert.AreEqual(e.errcode, raw.SQLITE_TOOBIG);
}
try
{
db.exec("select nomem();");
Assert.Fail("expected exception");
}
catch (ugly.sqlite3_exception e)
{
Assert.AreEqual(e.errcode, raw.SQLITE_NOMEM);
}
}
}
public void test_makeblob()
{
using (sqlite3 db = ugly.open(":memory:"))
{
db.create_function("makeblob", 1, null, makeblob);
byte[] c = db.query_scalar <byte[]>("SELECT makeblob(?);", val);
Assert.AreEqual(c.Length, val);
}
}
public void test_concat()
{
using (sqlite3 db = ugly.open(":memory:"))
{
db.create_function("my_concat", -1, null, concat);
Assert.AreEqual("foobar", db.query_scalar <string>("SELECT my_concat('foo', 'bar');"));
Assert.AreEqual("abc", db.query_scalar <string>("SELECT my_concat('a', 'b', 'c');"));
}
}
public void test_cube()
{
using (sqlite3 db = ugly.open(":memory:"))
{
db.create_function("cube", 1, null, cube);
long c = db.query_scalar <long>("SELECT cube(?);", val);
Assert.AreEqual(c, val * val * val);
}
}
public void test_len_as_blobs()
{
using (sqlite3 db = ugly.open(":memory:"))
{
db.create_function("len_as_blobs", -1, null, len_as_blobs);
Assert.AreEqual(0, db.query_scalar <int>("SELECT len_as_blobs();"));
Assert.AreEqual(0, db.query_scalar <int>("SELECT len_as_blobs(null);"));
Assert.IsTrue(8 <= db.query_scalar <int>("SELECT len_as_blobs(1,2,3,4,5,6,7,8);"));
}
}
public void test_countargs()
{
using (sqlite3 db = ugly.open(":memory:"))
{
db.create_function("count_args", -1, null, count_args);
Assert.AreEqual(8, db.query_scalar <int>("SELECT count_args(1,2,3,4,5,6,7,8);"));
Assert.AreEqual(0, db.query_scalar <int>("SELECT count_args();"));
Assert.AreEqual(1, db.query_scalar <int>("SELECT count_args(null);"));
}
}
public void test_scalar_mean_double()
{
using (sqlite3 db = ugly.open(":memory:"))
{
db.create_function("my_mean", -1, null, mean);
double d = db.query_scalar <double>("SELECT my_mean(1,2,3,4,5,6,7,8);");
Assert.IsTrue(d >= (36 / 8));
Assert.IsTrue(d <= (36 / 8 + 1));
}
}
public void test_sum_plus_count()
{
using (sqlite3 db = ugly.open(":memory:"))
{
db.create_function("sum_plus_count", 1, null, sum_plus_count_step, sum_plus_count_final);
db.exec("CREATE TABLE foo (x int);");
for (int i = 0; i < 5; i++)
{
db.exec("INSERT INTO foo (x) VALUES (?);", i);
}
long c = db.query_scalar <long>("SELECT sum_plus_count(x) FROM foo;");
Assert.AreEqual(c, (0 + 1 + 2 + 3 + 4) + 5);
}
}
public void test_result_zeroblob()
{
delegate_function_scalar zeroblob_func =
(ctx, user_data, args) =>
{
int size = raw.sqlite3_value_int(args[0]);
raw.sqlite3_result_zeroblob(ctx, size);
};
using (sqlite3 db = ugly.open(":memory:"))
{
db.exec("CREATE TABLE foo (x blob);");
db.create_function("createblob", 1, null, zeroblob_func);
db.exec("INSERT INTO foo (x) VALUES(createblob(10));");
var rowid = db.last_insert_rowid();
byte[] blob = db.query_scalar <byte[]>("SELECT x FROM foo WHERE rowid=" + rowid);
Assert.AreEqual(blob.Length, 10);
foreach (var b in blob)
{
Assert.AreEqual(b, 0);
}
}
}
