/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package libcore.sqlite;
import SQLite.Constants;
import SQLite.Database;
import SQLite.Stmt;
import SQLite.TableResult;
import java.sql.Connection;
import tests.support.DatabaseCreator;
import tests.support.Support_SQL;
public class OldStmtTest extends OldSQLiteTest {
private Database db;
private Stmt st;
private static final String CREATE_ALL_TYPES = "create table type ("
+ " BoolVal BOOLEAN,"
+ " IntVal INT,"
+ " LongVal LONG,"
+ " Bint BIGINT,"
+ " Tint TINYINT,"
+ " Sint SMALLINT,"
+ " Mint MEDIUMINT,"
+ " IntegerVal INTEGER,"
+ " RealVal REAL,"
+ " DoubleVal DOUBLE,"
+ " FloatVal FLOAT,"
+ " DecVal DECIMAL,"
+ " NumVal NUMERIC,"
+ " charStr CHAR(20),"
+ " dateVal DATE,"
+ " timeVal TIME,"
+ " TS TIMESTAMP,"
+ " DT DATETIME,"
+ " TBlob TINYBLOB,"
+ " BlobVal BLOB,"
+ " MBlob MEDIUMBLOB,"
+ " LBlob LONGBLOB,"
+ " TText TINYTEXT,"
+ " TextVal TEXT,"
+ " MText MEDIUMTEXT,"
+ " LText LONGTEXT,"
+ " MaxLongVal BIGINT,"
+ " MinLongVal BIGINT,"
+ " validURL URL,"
+ " invalidURL URL);";
static final String INSERT_ALL_TYPES = "insert into type ("
+ "BoolVal, IntVal, LongVal, Bint, Tint, Sint, Mint,IntegerVal, RealVal, DoubleVal, "
+ "FloatVal, DecVal,NumVal, charStr, dateVal, timeVal, TS,DT, TBlob, BlobVal, MBlob, "
+ "LBlob,TText, TextVal, MText, LText, MaxLongVal, MinLongVal, validURL, invalidURL) "
+ "values (1, -1, 22, 2, 33,3, 1, 2, 3.9, 23.2, 33.3, 44,5, 'test string', '1799-05-26',"
+ "'12:35:45', '2007-10-09 14:28:02.0','1221-09-22 10:11:55', 1, 2, 3, 4,"
+ "'Test text message tiny', 'Test text', 'Test text message medium',"
+ "'Test text message long', " + Long.MAX_VALUE + ", " + Long.MIN_VALUE + ","
+ "null, null);";
static final String ALL_TYPES_TABLE = "type";
@Override public void setUp() throws Exception {
super.setUp();
Support_SQL.loadDriver();
db = new Database();
db.open(dbFile.getPath(), 0);
db.exec(DatabaseCreator.CREATE_TABLE_SIMPLE1, null);
DatabaseCreator.fillSimpleTable1(conn);
st = new Stmt();
}
@Override public void tearDown() throws Exception {
if (st != null) {
try {
st.close();
} catch (Exception e) {
}
}
db.close();
Connection con = Support_SQL.getConnection();
con.close();
super.tearDown();
}
public void testStmt() throws Exception {
db.prepare("");
try {
st.step();
fail("Cannot execute non prepared Stmt");
} catch (SQLite.Exception expected) {
}
}
public void testPrepare() throws Exception {
try {
st = db.prepare("");
st.prepare();
fail("statement is closed");
} catch (SQLite.Exception expected) {
assertEquals("stmt already closed", expected.getMessage());
}
st = new Stmt();
st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1);
assertFalse(st.prepare());
st = new Stmt();
st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+ " values (:one,:two,:three)");
assertFalse(st.prepare());
st = new Stmt();
st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+ " values (:one,:two,:three)");
st.bind(1, 1);
st.bind(2, 10);
st.bind(3, 30);
assertFalse(st.prepare());
st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1
+ "; " + "delete from " + DatabaseCreator.SIMPLE_TABLE1
+ " where id = 5; " + "insert into "
+ DatabaseCreator.SIMPLE_TABLE1 + " values(5, 10, 20); "
+ "select * from " + DatabaseCreator.SIMPLE_TABLE1 + ";");
assertTrue(st.prepare());
assertTrue(st.prepare());
assertTrue(st.prepare());
assertFalse(st.prepare());
}
public void testStep() throws Exception {
try {
st.step();
fail("Exception expected");
} catch (SQLite.Exception expected) {
assertEquals("stmt already closed", expected.getMessage());
}
st = new Stmt();
st = db.prepare("select name from sqlite_master where type = 'table'");
st.step();
}
public void testClose() throws Exception {
st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+ " values (:one,:two,:three)");
st.close();
try {
st.step();
fail("Test fails");
} catch (SQLite.Exception expected) {
assertEquals("stmt already closed", expected.getMessage());
}
}
public void testReset() throws Exception {
db.exec("create table TEST (res integer not null)", null);
st = db.prepare("insert into TEST values (:one);");
st.bind(1, 1);
st.step();
// verify that parameter is still bound
st.reset();
assertEquals(1,st.bind_parameter_count());
st.step();
TableResult count = db.get_table("select count(*) from TEST where res=1", null);
String[] row0 = (String[]) count.rows.elementAt(0);
assertEquals(2, Integer.parseInt(row0[0]));
}
public void testClear_bindings() {
try {
st.clear_bindings();
} catch (SQLite.Exception expected) {
assertEquals("unsupported", expected.getMessage());
}
}
public void testBindIntInt() throws Exception {
int input = 0;
int maxVal = Integer.MAX_VALUE;
int minVal = Integer.MIN_VALUE;
db.exec("create table TEST (res integer)", null);
st = db.prepare("insert into TEST values (:one);");
st.bind(1, input);
st.step();
st.reset();
st.bind(1,maxVal);
st.step();
st.reset();
st.bind(1,minVal);
st.step();
TableResult r = db.get_table("select * from TEST");
String[] row0 = (String[]) r.rows.elementAt(0);
assertEquals(input,Integer.parseInt(row0[0]));
String[] row1 = (String[]) r.rows.elementAt(1);
assertEquals(maxVal,Integer.parseInt(row1[0]));
String[] row2 = (String[]) r.rows.elementAt(2);
assertEquals(minVal,Integer.parseInt(row2[0]));
try {
st.close();
st.bind(1,Integer.MIN_VALUE);
fail("Exception expected");
} catch (SQLite.Exception expected) {
}
}
public void testBindIntLong() throws Exception {
long input = 0;
long maxVal = Long.MAX_VALUE;
long minVal = Long.MIN_VALUE;
db.exec("create table TEST (res long)", null);
st = db.prepare("insert into TEST values (:one);");
st.bind(1, input);
st.step();
st.reset();
st.bind(1,maxVal);
st.step();
st.reset();
st.bind(1,minVal);
st.step();
TableResult r = db.get_table("select * from TEST");
String[] row0 = (String[]) r.rows.elementAt(0);
assertEquals(input,Long.parseLong(row0[0]));
String[] row1 = (String[]) r.rows.elementAt(1);
assertEquals(maxVal,Long.parseLong(row1[0]));
String[] row2 = (String[]) r.rows.elementAt(2);
assertEquals(minVal,Long.parseLong(row2[0]));
try {
st.close();
st.bind(1,Long.MIN_VALUE);
fail("Exception expected");
} catch (SQLite.Exception expected) {
}
}
public void testBindIntDouble() throws Exception {
double input = 0.0;
double maxVal = Double.MAX_VALUE;
double minVal = Double.MIN_VALUE;
double negInf = Double.NEGATIVE_INFINITY;
double posInf = Double.POSITIVE_INFINITY;
double nan = Double.NaN;
db.exec("create table TEST (res double)", null);
st = db.prepare("insert into TEST values (:one);");
st.bind(1, input);
st.step();
st.reset();
st.bind(1, maxVal);
st.step();
st.reset();
st.bind(1, minVal);
st.step();
st.reset();
st.bind(1, negInf);
st.step();
st.reset();
st.bind(1, posInf);
st.step();
st.reset();
st.bind(1, nan);
st.step();
TableResult r = db.get_table("select * from TEST");
String[] row0 = (String[]) r.rows.elementAt(0);
assertTrue(Double.compare(input, Double.parseDouble(row0[0])) == 0);
String[] row1 = (String[]) r.rows.elementAt(1);
assertFalse(Double.compare(maxVal, Double.parseDouble(row1[0])) == 0);
assertTrue(Double.compare(maxVal, Double.parseDouble(row1[0])) < 0);
assertTrue(Double.isInfinite(Double.parseDouble(row1[0])));
String[] row2 = (String[]) r.rows.elementAt(2);
assertTrue(Double.compare(minVal, Double.parseDouble(row2[0])) == 0);
String[] row3 = (String[]) r.rows.elementAt(3);
assertEquals("Double.NEGATIVE_INFINITY SQLite representation",
"-Inf", row3[0]);
String[] row4 = (String[]) r.rows.elementAt(4);
assertEquals("Double.POSITIVE_INFINITY SQLite representation",
"Inf", row4[0]);
String[] row5 = (String[]) r.rows.elementAt(4);
assertEquals("Double.Nan SQLite representation", "Inf", row5[0]);
try {
st.close();
st.bind(1,0.0);
fail("Exception expected");
} catch (SQLite.Exception expected) {
}
}
public void testBindIntByteArray() throws Exception {
String name = "Hello World";
byte[] b = name.getBytes();
String stringInHex = "";
db.exec(DatabaseCreator.CREATE_TABLE_PARENT, null);
st = db.prepare("insert into " + DatabaseCreator.PARENT_TABLE
+ " values (:one, :two);");
st.bind(1, 2);
st.bind(2, b);
st.step();
//compare what was stored with input based on Hex representation
// since type of column is CHAR
TableResult r = db.get_table("select * from "
+ DatabaseCreator.PARENT_TABLE);
String[] row = (String[]) r.rows.elementAt(0);
for (byte aByte : b) {
stringInHex += Integer.toHexString(aByte);
}
stringInHex = "X'" + stringInHex + "'";
assertTrue(stringInHex.equalsIgnoreCase(row[1]));
try {
st.close();
st.bind(1,name.getBytes());
fail("Exception expected");
} catch (SQLite.Exception expected) {
}
}
public void testBindIntString() throws Exception {
String name = "Hello World";
db.exec(DatabaseCreator.CREATE_TABLE_PARENT, null);
st = db.prepare("insert into " + DatabaseCreator.PARENT_TABLE
+ " values (:one, :two);");
st.bind(1, 2);
st.bind(2, name);
st.step();
TableResult r = db.get_table("select * from "
+ DatabaseCreator.PARENT_TABLE);
String[] row = (String[]) r.rows.elementAt(0);
assertEquals(name,row[1]);
try {
st.close();
st.bind(1,name);
fail("Exception expected");
} catch (SQLite.Exception expected) {
}
}
public void testBindInt() throws Exception {
try {
st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+ " values (:one,:two,:three)");
st.bind(4);
st.bind(1, 4);
st.bind(2, 10);
st.bind(3, 30);
st.step();
fail();
} catch (SQLite.Exception expected) {
// What happens if null is bound to non existing variable position
assertEquals("parameter position out of bounds", expected.getMessage());
}
// functional tests
try {
st.reset();
st.bind(1);
st.bind(2, 10);
st.bind(3, 30);
st.step();
fail();
} catch (SQLite.Exception expected) {
// What happens if null is bound to NON NULL field
assertEquals("SQL logic error or missing database", expected.getMessage());
}
st.reset();
st.bind(1, 3);
st.bind(2);
st.bind(3, 30);
st.step();
}
public void testBind_zeroblob() {
try {
st.bind_zeroblob(1, 128);
fail();
} catch (SQLite.Exception expected) {
assertEquals("unsupported", expected.getMessage());
}
}
public void testBind_parameter_count() throws Exception {
try {
st.bind_parameter_count();
fail();
} catch (SQLite.Exception expected) {
assertEquals("stmt already closed", expected.getMessage());
}
st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+ " values (:one,:two,:three)");
assertEquals(3, st.bind_parameter_count());
st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+ " values (?, ?, ?)");
assertEquals(3, st.bind_parameter_count());
st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1);
assertEquals(0, st.bind_parameter_count());
try {
st.close();
st.bind_parameter_count();
fail("Exception expected");
} catch (SQLite.Exception expected) {
}
}
public void testBind_parameter_name() {
try {
st.bind_parameter_name(1);
fail("Exception expected");
} catch (SQLite.Exception expected) {
assertEquals("stmt already closed", expected.getMessage());
}
try {
st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+ " values (:one,:two,:three)");
assertEquals(":one", st.bind_parameter_name(1));
assertEquals(":two", st.bind_parameter_name(2));
assertEquals(":three", st.bind_parameter_name(3));
st.bind_parameter_name(4);
fail();
} catch (SQLite.Exception expected) {
assertEquals("parameter position out of bounds", expected.getMessage());
}
}
public void testBind_parameter_index() throws Exception {
try {
st.bind_parameter_index("");
fail("Exception expected");
} catch (SQLite.Exception expected) {
assertEquals("stmt already closed", expected.getMessage());
}
st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+ " values (:one,:two,:three)");
assertEquals(3, st.bind_parameter_index(":three"));
st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+ " values (:one,:two,:three)");
assertEquals(0, st.bind_parameter_index(":t"));
st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+ " values (?, ?, ?)");
assertEquals(0, st.bind_parameter_index("?"));
}
public void testColumn_int() throws Exception {
db.exec(CREATE_ALL_TYPES, null);
db.exec(INSERT_ALL_TYPES, null);
Object columnObject;
int intColumn;
String selectStmt = "select * from "+DatabaseCreator.SIMPLE_TABLE1;
st = db.prepare(selectStmt);
st.step();
// select 'speed' value
columnObject = st.column(1);
intColumn = st.column_int(1);
assertNotNull(intColumn);
assertTrue("Integer".equalsIgnoreCase(st.column_decltype(1)));
int stSpeed = Integer.parseInt(columnObject.toString());
assertNotNull(stSpeed);
assertEquals( intColumn, stSpeed);
assertEquals(10,stSpeed);
selectStmt = "select TextVal from "+ ALL_TYPES_TABLE;
st = db.prepare(selectStmt);
st.step();
st.column_int(0);
}
public void testColumn_long() throws Exception {
Object columnObject;
long longColumn;
String selectStmt = "select * from "+DatabaseCreator.SIMPLE_TABLE1;
st = db.prepare(selectStmt);
st.step();
columnObject = st.column(1);
longColumn = st.column_long(1);
assertNotNull(longColumn);
// column declared as integer
assertTrue("Integer".equalsIgnoreCase(st.column_decltype(1)));
int stSpeed = Integer.parseInt(columnObject.toString());
assertNotNull(stSpeed);
assertEquals( longColumn, stSpeed);
try {
st.column_long(4);
fail("Exception expected");
} catch (SQLite.Exception expected) {
assertEquals("column out of bounds", expected.getMessage());
}
try {
st.column_long(-1);
fail("Exception expected");
} catch (SQLite.Exception expected) {
assertEquals("column out of bounds", expected.getMessage());
}
}
public void testColumn_double() throws Exception {
db.exec(CREATE_ALL_TYPES, null);
db.exec(INSERT_ALL_TYPES, null);
double doubleColumn;
double actualVal = 23.2;
String selectStmt = "select DoubleVal from "+ ALL_TYPES_TABLE;
st = db.prepare(selectStmt);
st.step();
// select double value
doubleColumn = st.column_double(0);
assertNotNull(doubleColumn);
assertTrue("DOUBLE".equalsIgnoreCase(st.column_decltype(0)));
assertNotNull(doubleColumn);
assertEquals( actualVal, doubleColumn);
// Exception test
selectStmt = "select dateVal from "+ ALL_TYPES_TABLE;
st = db.prepare(selectStmt);
st.step();
// select double value
st.column_double(0);
}
public void testColumn_bytes() throws Exception {
db.exec("create table B(id integer primary key, val blob)",null);
db.exec("insert into B values(1, zeroblob(128))", null);
st = db.prepare("select val from B where id = 1");
assertTrue(st.step());
st.column_bytes(0);
}
public void testColumn_string() throws Exception {
db.exec(CREATE_ALL_TYPES, null);
db.exec(INSERT_ALL_TYPES, null);
String stringColumn;
String actualVal = "test string";
String selectStmt = "select charStr from "+ ALL_TYPES_TABLE;
st = db.prepare(selectStmt);
st.step();
// select string value
stringColumn = st.column_string(0);
assertNotNull(stringColumn);
assertTrue("CHAR(20)".equalsIgnoreCase(st.column_decltype(0)));
assertNotNull(stringColumn);
assertEquals( actualVal, stringColumn);
// Exception test
selectStmt = "select DoubleVal from "+ ALL_TYPES_TABLE;
st = db.prepare(selectStmt);
st.step();
st.column_string(0);
}
public void testColumn_type() throws Exception {
db.exec(CREATE_ALL_TYPES, null);
db.exec(INSERT_ALL_TYPES, null);
st = db.prepare("select * from " + ALL_TYPES_TABLE);
st.step();
// Exception test
try {
st.column_type(100);
fail();
} catch (SQLite.Exception expected) {
}
/*
Dictionary
public static final int SQLITE_INTEGER = 1;
public static final int SQLITE_FLOAT = 2;
public static final int SQLITE_BLOB = 4;
public static final int SQLITE_NULL = 5;
public static final int SQLITE3_TEXT = 3;
public static final int SQLITE_NUMERIC = -1;
*/
assertEquals(Constants.SQLITE3_TEXT, st.column_type(23)); // ok TEXT
assertEquals(Constants.SQLITE3_TEXT, st.column_type(13)); // CHAR(20)
assertEquals(Constants.SQLITE_FLOAT, st.column_type(8));
assertEquals(Constants.SQLITE_FLOAT, st.column_type(9));
assertEquals(Constants.SQLITE_FLOAT, st.column_type(10)); // FLOAT
for (int i = 0; i < 8; i++) {
assertEquals("Expected Integer at position " + i,
Constants.SQLITE_INTEGER, st.column_type(i));
}
assertEquals(Constants.SQLITE_NULL, st.column_type(28));
assertEquals(Constants.SQLITE_NULL, st.column_type(29));
// Failing tests
assertTrue("INTEGER".equalsIgnoreCase(st.column_decltype(12)));
assertEquals(Constants.SQLITE_INTEGER, st.column_type(12));
assertTrue("FLOAT".equalsIgnoreCase(st.column_decltype(11)));
assertEquals(Constants.SQLITE_FLOAT, st.column_type(11)); // FLOAT ->
// got INTEGER
assertTrue("BLOB".equalsIgnoreCase(st.column_decltype(19)));
assertEquals(Constants.SQLITE_BLOB, st.column_type(19)); // Blob got
// INTEGER
}
/**
* Wrong value is returned in case of a prepared statement to which a '*' bound
*/
public void testColumn_count() throws Exception {
String selectStmt = "select * from "+DatabaseCreator.SIMPLE_TABLE1;
st = db.prepare(selectStmt);
assertEquals(3, st.column_count());
st.step();
int columnCount = st.column_count();
assertNotNull(columnCount);
assertEquals( 3, columnCount);
// actual prepared statement
selectStmt = "select ? from "+DatabaseCreator.SIMPLE_TABLE1;
st = db.prepare(selectStmt);
assertEquals(3, st.column_count());
st.bind(1, "*");
st.step();
columnCount = st.column_count();
assertNotNull(columnCount);
assertEquals( 3, columnCount);
}
public void testColumn() throws Exception {
Object columnObject;
int intColumn;
String selectStmt = "select * from "+DatabaseCreator.SIMPLE_TABLE1;
db.get_table(selectStmt);
st = db.prepare(selectStmt);
st.step();
columnObject = st.column(1);
intColumn = st.column_int(1);
assertNotNull(intColumn);
assertTrue("Integer".equalsIgnoreCase(st.column_decltype(1)));
int stSpeed = Integer.parseInt(columnObject.toString());
assertNotNull(stSpeed);
assertEquals( intColumn, stSpeed);
try {
assertNotNull(columnObject);
((Integer) columnObject).intValue();
fail("Cast to Integer should fail");
} catch (ClassCastException expected) {
}
try {
st.column(4);
fail("Exception expected");
} catch (SQLite.Exception expected) {
assertEquals("column out of bounds", expected.getMessage());
}
try {
st.column(-1);
fail("Exception expected");
} catch (SQLite.Exception expected) {
assertEquals("column out of bounds", expected.getMessage());
}
}
public void testColumn_table_name() {
try {
st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1);
st.column_table_name(1);
fail("Function is now supported.");
} catch (SQLite.Exception expected) {
assertEquals("unsupported", expected.getMessage());
}
}
public void testColumn_database_name() {
try {
st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+ " values (:one,:two,:three)");
st.column_database_name(1);
fail("Function is now supported.");
} catch (SQLite.Exception expected) {
assertEquals("unsupported", expected.getMessage());
}
}
public void testColumn_decltype() throws Exception {
db.exec(CREATE_ALL_TYPES, null);
db.exec(INSERT_ALL_TYPES, null);
st = db.prepare("select * from " + ALL_TYPES_TABLE);
st.step();
// Exception test
try {
st.column_decltype(100);
fail();
} catch (SQLite.Exception expected) {
}
assertTrue(st.column_decltype(0), "BOOLEAN".equalsIgnoreCase(st
.column_decltype(0)));
assertTrue(st.column_decltype(1), "INT".equalsIgnoreCase(st
.column_decltype(1)));
assertTrue(st.column_decltype(2), "LONG".equalsIgnoreCase(st
.column_decltype(2)));
assertTrue(st.column_decltype(3), "BIGINT".equalsIgnoreCase(st
.column_decltype(3)));
assertTrue(st.column_decltype(4), "TINYINT".equalsIgnoreCase(st
.column_decltype(4)));
assertTrue(st.column_decltype(5), "SMALLINT".equalsIgnoreCase(st
.column_decltype(5)));
assertTrue(st.column_decltype(6), "MEDIUMINT".equalsIgnoreCase(st
.column_decltype(6)));
assertTrue(st.column_decltype(7), "INTEGER".equalsIgnoreCase(st
.column_decltype(7)));
assertTrue(st.column_decltype(8), "REAL".equalsIgnoreCase(st
.column_decltype(8)));
assertTrue(st.column_decltype(9), "DOUBLE".equalsIgnoreCase(st
.column_decltype(9)));
assertTrue(st.column_decltype(10), "FLOAT".equalsIgnoreCase(st
.column_decltype(10)));
assertTrue(st.column_decltype(11), "DECIMAL".equalsIgnoreCase(st
.column_decltype(11)));
assertTrue(st.column_decltype(12), "NUMERIC".equalsIgnoreCase(st
.column_decltype(12)));
assertTrue(st.column_decltype(13), "CHAR(20)".equalsIgnoreCase(st
.column_decltype(13)));
assertTrue(st.column_decltype(19), "BLOB".equalsIgnoreCase(st
.column_decltype(19)));
assertTrue(st.column_decltype(23), "TEXT".equalsIgnoreCase(st
.column_decltype(23)));
assertTrue(st.column_decltype(28), "URL".equalsIgnoreCase(st
.column_decltype(28)));
assertTrue(st.column_decltype(29), "URL".equalsIgnoreCase(st
.column_decltype(29)));
}
public void testColumn_origin_name() {
try {
st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1);
st.column_origin_name(1);
fail("Function is now supported.");
} catch (SQLite.Exception expected) {
assertEquals("unsupported", expected.getMessage());
}
}
}