| /* |
| * 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 tests.SQLite; |
| |
| import dalvik.annotation.AndroidOnly; |
| import dalvik.annotation.KnownFailure; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetClass; |
| import dalvik.annotation.TestTargetNew; |
| import dalvik.annotation.TestTargets; |
| import tests.support.DatabaseCreator; |
| import tests.support.MockFunction; |
| import tests.support.ThreadPool; |
| import tests.support.resource.Support_Resources; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.UnsupportedEncodingException; |
| import java.net.URL; |
| import java.sql.DatabaseMetaData; |
| import java.sql.ResultSet; |
| import java.sql.SQLException; |
| import java.sql.Statement; |
| |
| import SQLite.Authorizer; |
| import SQLite.Blob; |
| import SQLite.BusyHandler; |
| import SQLite.Callback; |
| import SQLite.Constants; |
| import SQLite.Database; |
| import SQLite.Exception; |
| import SQLite.Function; |
| import SQLite.FunctionContext; |
| import SQLite.ProgressHandler; |
| import SQLite.Stmt; |
| import SQLite.TableResult; |
| import SQLite.Trace; |
| import SQLite.Vm; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.logging.Logger; |
| |
| @TestTargetClass(Database.class) |
| public class DatabaseTest extends SQLiteTest { |
| |
| /** |
| * The SQLite db file. |
| */ |
| // protected final File dbFile = new File("sqliteTest.db"); |
| // |
| // private final String connectionURL = "jdbc:sqlite:/" + dbFile.getPath(); |
| // |
| // private final String classname = "SQLite.JDBCDriver"; |
| // |
| // private static Connection conn = null; |
| |
| private static ErrorTracker tracker = null; |
| |
| private Statement statement; |
| |
| private Database db = null; |
| |
| private static final int numThreads = 10; |
| |
| private static final int numOfRecords = 30; |
| |
| public void setUp() throws java.lang.Exception { |
| try { |
| super.setUp(); |
| assertNotNull("Could not establish DB connection",conn); |
| tracker = new ErrorTracker(); |
| |
| statement = conn.createStatement(); |
| |
| //Cleanup tables if necessary |
| |
| DatabaseMetaData meta = conn.getMetaData(); |
| assertNotNull(meta); |
| if (meta != null) { |
| ResultSet userTab = meta.getTables(null, null, null, null); |
| while (userTab.next()) { |
| String tableName = userTab.getString("TABLE_NAME"); |
| this.statement.execute("drop table "+tableName); |
| } |
| } |
| |
| // Create default test table |
| // statement = conn.createStatement(); |
| statement.execute(DatabaseCreator.CREATE_TABLE_SIMPLE1); |
| statement.close(); |
| |
| try { |
| db = new Database(); |
| db.open(dbFile.getPath(), 0); |
| db.busy_handler(null); |
| } catch (Exception e) { |
| System.out.println("2: Error opening File: Dir "+dbFile.getPath()+" Name: "+dbFile.getPath()); |
| } catch (java.lang.Exception e) { |
| System.err.println("Non SQLException "+e.getMessage()); |
| } |
| } catch (Exception e) { |
| System.out.println("Database setup fails: "+e.getMessage()); |
| e.printStackTrace(); |
| } |
| |
| } |
| |
| public void tearDown() { |
| |
| try { |
| db.close(); |
| }catch (Exception e) { |
| if (! (e.getMessage().equals("database already closed"))) { |
| System.err.println("Error closing DB "+dbFile.getPath()); |
| } |
| } |
| // conn.close(); |
| // dbFile.delete(); |
| tracker.reset(); |
| super.tearDown(); |
| } |
| |
| /** |
| * @tests Database#Database() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "constructor test", |
| method = "Database", |
| args = {} |
| ) |
| public void testDatabase() { |
| // db closed |
| Database db2 = new Database(); |
| try { |
| db.close(); |
| db2 = new Database(); |
| db2.open(dbFile.getPath(), 0); |
| db2.close(); |
| db.open(dbFile.getPath(), 0); |
| } catch (Exception e) { |
| fail("Database object could not be created "+e.getMessage()); |
| e.printStackTrace(); |
| } |
| //db is open |
| try { |
| db2.open(dbFile.getPath(), 0); |
| db2.close(); |
| } catch (Exception e) { |
| fail("Second Database object could not be created "+e.getMessage()); |
| e.printStackTrace(); |
| } |
| } |
| |
| /** |
| * @tests Database#finalize() |
| */ |
| @TestTargetNew( |
| level = TestLevel.NOT_FEASIBLE, |
| notes = "method test", |
| method = "finalize", |
| args = {} |
| ) |
| public void testFinalize() { |
| } |
| |
| /** |
| * @tests {@link Database#open(String, int)}. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test. Test fails.", |
| method = "open", |
| args = {java.lang.String.class, int.class} |
| ) |
| public void testOpen() { |
| try { |
| db.close(); |
| db.open(dbFile.getPath(), 0); |
| } catch (Exception e) { |
| fail("Database object could not be opened: " + e.getMessage()); |
| e.printStackTrace(); |
| } |
| // open second db while db1 still open |
| Database db2 = new Database(); |
| try { |
| db2.open(dbFile.getPath(), 0); |
| db2.open(dbFile.getPath(), 0); |
| db2.close(); |
| } catch (Exception e) { |
| fail("Database object could not be opened: " + e.getMessage()); |
| e.printStackTrace(); |
| } |
| // open non db file |
| File tempDir = Support_Resources.createTempFolder(); |
| final String resourceName = "blob.c"; |
| try { |
| URL file = Class.forName(this.getClass().getName()) |
| .getResource("/blob.c"); |
| db2.open(file.getPath(), 0); |
| fail("Should not be able to open non db file"); |
| } catch (Exception e) { |
| assertEquals("unknown error in open", e.getMessage()); |
| } catch (java.lang.Exception e) { |
| fail("Error in setup " + e.getMessage()); |
| e.printStackTrace(); |
| } |
| |
| } |
| |
| /** |
| * @tests Database#open_aux_file(String) |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "not supported", |
| method = "open_aux_file", |
| args = {java.lang.String.class} |
| ) |
| public void testOpen_aux_file() { |
| File temp = null; |
| try { |
| db.open_aux_file(""); |
| fail("open should fail"); |
| } catch (Exception e) { |
| assertEquals("unsupported", e.getMessage()); |
| } |
| |
| /* |
| try { |
| temp = File.createTempFile("openAuxMethod", ".db"); |
| db.open_aux_file(""); |
| db.exec("create table AUX_TABLE", null); |
| db.close(); |
| } catch (Exception e) { |
| temp.delete(); |
| fail("Error handling temporary file "+e.getMessage()); |
| e.printStackTrace(); |
| } catch (IOException e) { |
| temp.delete(); |
| fail("Could not create temporary File"); |
| e.printStackTrace(); |
| } |
| try { |
| db.open(dbFile.getPath(),0); |
| db.exec("select * from AUX_TABLE", null); |
| fail("Statement should fail"); |
| } catch (Exception e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| |
| temp.delete(); |
| */ |
| } |
| |
| /** |
| * @tests Database#close() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "close", |
| args = {} |
| ) |
| public void testClose() { |
| try { |
| db.close(); |
| db.get_table("test"); |
| } catch (Exception e) { |
| assertTrue(e.getMessage().equals("database already closed")); |
| try { |
| db.open(dbFile.getPath(), 0); |
| } catch (Exception e1) { |
| fail("Database object could not be reopened after 'close': " |
| + e.getMessage()); |
| e1.printStackTrace(); |
| } |
| } |
| |
| try { |
| db.close(); |
| db.close(); |
| } catch (Exception e) { |
| assertTrue(e.getMessage().equals("database already closed")); |
| try { |
| db.open(dbFile.getPath(), 0); |
| } catch (Exception e1) { |
| fail("Database object could not be reopened after 'close': " |
| + e.getMessage()); |
| e1.printStackTrace(); |
| } |
| } |
| } |
| |
| /** |
| * @tests Database#exec(String, Callback) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "exec", |
| args = {java.lang.String.class, Callback.class} |
| ) |
| public void testExecStringCallback() { |
| TableResult res = new TableResult(); |
| try { |
| db.exec("insert into " + DatabaseCreator.SIMPLE_TABLE1 |
| + " VALUES(1, 10, 20)", null); |
| db.exec("select * from " + DatabaseCreator.SIMPLE_TABLE1, res); |
| db |
| .exec("delete from " + DatabaseCreator.SIMPLE_TABLE1 |
| + " where 1", null); |
| } catch (Exception e) { |
| fail("Database error"); |
| e.printStackTrace(); |
| } |
| String row[] = (String[]) res.rows.elementAt(0); |
| assertEquals(Integer.parseInt(row[0]), 1); |
| assertEquals(Integer.parseInt(row[1]), 10); |
| assertEquals(Integer.parseInt(row[2]), 20); |
| } |
| |
| /** |
| * @tests Database#exec(String, Callback, String[]) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "exec", |
| args = {java.lang.String.class, Callback.class, java.lang.String[].class} |
| ) |
| public void testExecStringCallbackStringArray() { |
| TableResult res = new TableResult(); |
| String args[] = new String[1]; |
| args[0] = "table"; |
| try { |
| db.exec("select name from sqlite_master where type = '%q';", res, |
| args); |
| String[] s = (String[]) res.rows.elementAt(0); |
| assertEquals(s[0], DatabaseCreator.SIMPLE_TABLE1); |
| } catch (Exception e) { |
| fail("DB Error occurred"); |
| e.printStackTrace(); |
| } |
| |
| try { |
| db.exec("select name from sqlite_master where type = ", res, args); |
| fail("Testmethod should fail"); |
| } catch (Exception e) { |
| // Ok |
| } |
| } |
| |
| /** |
| * @tests {@link Database#last_insert_rowid()} |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "last_insert_rowid", |
| args = {} |
| ) |
| public void testLast_insert_rowid() { |
| assertEquals(0, db.last_insert_rowid()); |
| try { |
| db |
| .exec( |
| "create table TEST5(id integer, firstname text, lastname text);", |
| null); |
| db.exec("insert into TEST5 values (1,'James','Bond');", null); |
| db.exec("insert into TEST5 values (2,'Fiona','Apple');", null); |
| } catch (Exception e) { |
| fail("Error in test setup: " + e.getMessage()); |
| e.printStackTrace(); |
| } |
| assertEquals(2, db.last_insert_rowid()); |
| assertEquals(db.last_insert_rowid(), db.last_insert_rowid()); |
| |
| try { |
| db.exec("drop table TEST5;", null); |
| } catch (Exception e) { |
| fail("Error in test setup: " + e.getMessage()); |
| e.printStackTrace(); |
| } |
| assertEquals(2, db.last_insert_rowid()); |
| } |
| |
| /** |
| * @throws Exception |
| * @tests {@link Database#interrupt()} |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "interrupt", |
| args = {} |
| ) |
| @KnownFailure("Reason for failure unknown: Database should be locked. " + |
| "Specification of interrupt is scarce.") |
| public void testInterrupt() throws Exception { |
| ThreadPool threadPool = new ThreadPool(numThreads); |
| |
| // initialization |
| ResultSet userTabs; |
| try { |
| userTabs = conn.getMetaData().getTables(null, null, null, null); |
| while (userTabs.next()) { |
| String tableName = userTabs.getString("TABLE_NAME"); |
| if (tableName.equals(DatabaseCreator.TEST_TABLE1)) { |
| statement.execute(DatabaseCreator.DROP_TABLE1); |
| } |
| } |
| db.exec(DatabaseCreator.CREATE_TABLE3, null); |
| db.exec(DatabaseCreator.CREATE_TABLE1, null); |
| } catch (SQLException e1) { |
| fail("Error initializing test " + e1.toString()); |
| e1.printStackTrace(); |
| } catch (Exception e) { |
| fail("Error initializing test " + e.getMessage()); |
| e.printStackTrace(); |
| } |
| |
| int id1 = numOfRecords - 3; |
| threadPool.runTask(createTask1(id1, dbFile.getPath(), tracker)); |
| // should not be able to do any other insertions since task 1 holds lock |
| int id2 = numOfRecords + 3; |
| threadPool |
| .runTask(createTask2Interrupt(id2, dbFile.getPath(), tracker)); |
| |
| threadPool.join(); |
| |
| List<String> errors = tracker.getErrors(); |
| System.out.println("Last error: " + db.error_message()); |
| if (errors.size() > 0) { |
| assertEquals(errors.get(0), db |
| .error_string(Constants.SQLITE_LOCKED)); |
| for (String s : errors) { |
| Logger.global.info("INTERRUPT Error: " + s); |
| } |
| |
| } else { |
| fail("Should have one exception: database should be locked."); |
| } |
| |
| // reset |
| |
| db |
| .exec( |
| "delete from " + DatabaseCreator.TEST_TABLE1 |
| + " where 1", null); |
| db |
| .exec( |
| "delete from " + DatabaseCreator.TEST_TABLE3 |
| + " where 1", null); |
| |
| } |
| |
| /** |
| * @tests {@link Database#changes()} |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "test fails", |
| method = "changes", |
| args = {} |
| ) |
| @KnownFailure("Returns wrong number for updates: returns value > 1 for select.") |
| public void testChanges() { |
| TableResult res = new TableResult(); |
| try { |
| assertTrue(db.changes() == 0); |
| db.exec("INSERT INTO " + DatabaseCreator.SIMPLE_TABLE1 |
| + " VALUES(2, 5, 7);", null); |
| int rows = (int) db.changes(); |
| assertEquals(1,db.changes()); |
| db.exec("update " + DatabaseCreator.SIMPLE_TABLE1 |
| + " set speed = 7, size= 5 where id = 2;", null); |
| assertEquals(1,db.changes()); |
| db.exec("select * from " + DatabaseCreator.SIMPLE_TABLE1, res); |
| assertEquals(0,db.changes()); |
| db.exec("INSERT INTO " + DatabaseCreator.SIMPLE_TABLE1 |
| + " VALUES(8, 5, 7);", null); |
| db.exec("Update "+DatabaseCreator.SIMPLE_TABLE1+" set speed = 10;",null); |
| assertTrue(db.changes() > 2); |
| } catch (Exception e) { |
| fail("Could not get changes: " + e.getMessage()); |
| e.printStackTrace(); |
| } |
| } |
| |
| /** |
| * @throws SQLException |
| * @throws Exception |
| * @tests {@link Database#busy_handler(BusyHandler)} |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.NOT_FEASIBLE, |
| notes = "method test fails once in a while. Cannot be sure that exception is thrown every time.", |
| method = "busy_handler", |
| args = {BusyHandler.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.NOT_FEASIBLE, |
| notes = "method test fails once in a while. Cannot be sure that exception is thrown every time.", |
| method = "busy", |
| clazz = BusyHandler.class, |
| args = {java.lang.String.class, int.class} |
| ) |
| }) |
| @KnownFailure("method test fails once in a while. "+ |
| "Cannot be sure that exception is thrown in every test execution.") |
| public void testBusy_handler() throws SQLException, Exception { |
| TestBusyHandler bh = new TestBusyHandler(); |
| db.busy_handler(bh); |
| int counter = 0; |
| ThreadPool threadPool = new ThreadPool(numThreads); |
| |
| // initialization |
| ResultSet userTabs; |
| try { |
| userTabs = conn.getMetaData().getTables(null, null, null, null); |
| while (userTabs.next()) { |
| String tableName = userTabs.getString("TABLE_NAME"); |
| if (tableName.equals(DatabaseCreator.TEST_TABLE1)) { |
| statement.execute(DatabaseCreator.DROP_TABLE1); |
| } |
| } |
| db.exec(DatabaseCreator.CREATE_TABLE3, null); |
| db.exec(DatabaseCreator.CREATE_TABLE1, null); |
| } catch (SQLException e1) { |
| fail("Error initializing test " + e1.toString()); |
| e1.printStackTrace(); |
| } catch (Exception e) { |
| fail("Error initializing test " + e.getMessage()); |
| e.printStackTrace(); |
| } |
| |
| |
| // try { |
| // DatabaseCreator.fillTestTable1(conn, numOfRecords); |
| // set to fail immediately if table is locked. |
| // db.busy_handler(bh); |
| // db.busy_timeout(0); |
| try { |
| conn.setAutoCommit(false); |
| int id1 = numOfRecords - 3; |
| threadPool.runTask(createTask1(id1, dbFile.getPath(), tracker)); |
| int id2 = numOfRecords + 3; |
| threadPool.runTask(createTask2(id2, dbFile.getPath(), tracker)); |
| int oldID = 5; |
| int newID = 100; |
| threadPool.runTask(createTask3(oldID, dbFile.getPath(), newID, |
| tracker)); |
| |
| threadPool.join(); |
| |
| List<String> errors = tracker.getErrors(); |
| if (errors.size() > 0) { |
| // assertEquals(errors.get(0), |
| // db.error_string(Constants.SQLITE_LOCKED)); |
| for (String s: errors) { |
| System.out.println("Round 2 Error: "+s); |
| } |
| } else { |
| fail("No error happened"); |
| } |
| |
| // reset |
| |
| |
| db.exec("delete from " + DatabaseCreator.TEST_TABLE1 + " where 1", |
| null); |
| db.exec("delete from " + DatabaseCreator.TEST_TABLE3 + " where 1", |
| null); |
| // |
| // // increase timeout for retry |
| // db.busy_timeout(1000); |
| // db.busy_handler(bh); |
| // tracker.reset(); |
| |
| // threadPool = new ThreadPool(numThreads); |
| // |
| // threadPool.runTask(createTask1(id1, dbFile.getPath(), tracker)); |
| // threadPool.runTask(createTask2(id2, dbFile.getPath(), tracker)); |
| // |
| // threadPool.join(); |
| // |
| // errors = tracker.getErrors(); |
| // if (errors.size() > 0) { |
| // // assertEquals(errors.get(0), |
| // // db.error_string(Constants.SQLITE_LOCKED)); |
| // for (String s: errors) { |
| // System.out.println("Round 2 Error"+s); |
| // } |
| // } else { |
| // // ok |
| // System.out.println("BUSY: No Error!"); |
| // } |
| // |
| // |
| } catch (Exception e) { |
| fail("Error in test setup " + e.getMessage()); |
| try { |
| db.get_table("select * from " + DatabaseCreator.TEST_TABLE1, |
| null).toString(); |
| } catch (Exception e1) { |
| |
| e1.printStackTrace(); |
| } |
| e.printStackTrace(); |
| // } catch (SQLException e2) { |
| // System.out.println("Error in test setup "+e2.toString()); |
| // try { |
| // db.get_table("select * from "+DatabaseCreator.TEST_TABLE1,null). |
| // toString(); |
| // } catch (Exception e1) { |
| // e2.printStackTrace(); |
| // } |
| } finally { |
| conn.setAutoCommit(true); |
| db.exec(DatabaseCreator.DROP_TABLE1, null); |
| db.exec(DatabaseCreator.DROP_TABLE3, null); |
| } |
| } |
| |
| /** |
| * @throws Exception |
| * @throws SQLException |
| * @tests {@link Database#busy_timeout(int)} |
| */ |
| @TestTargetNew( |
| level = TestLevel.NOT_FEASIBLE, |
| notes = "test fails. Cannot be sure that exception is thrown every time.", |
| method = "busy_timeout", |
| args = {int.class} |
| ) |
| @KnownFailure("Database does not lock values") |
| public void testBusy_timeout() throws Exception, SQLException { |
| int counter = 0; |
| ThreadPool threadPool = new ThreadPool(numThreads); |
| |
| // initialization |
| ResultSet userTabs; |
| try { |
| userTabs = conn.getMetaData().getTables(null, null, null, null); |
| while (userTabs.next()) { |
| String tableName = userTabs.getString("TABLE_NAME"); |
| if (tableName.equals(DatabaseCreator.TEST_TABLE1)) { |
| statement.execute(DatabaseCreator.DROP_TABLE1); |
| } |
| } |
| db.exec(DatabaseCreator.CREATE_TABLE3, null); |
| db.exec(DatabaseCreator.CREATE_TABLE1, null); |
| } catch (SQLException e1) { |
| fail("Error initializing test " + e1.toString()); |
| e1.printStackTrace(); |
| } catch (Exception e) { |
| fail("Error initializing test " + e.getMessage()); |
| e.printStackTrace(); |
| } |
| |
| |
| // test run |
| try { |
| conn.setAutoCommit(false); |
| |
| // DatabaseCreator.fillTestTable1(conn, numOfRecords); |
| // set to fail immediately if table is locked. |
| db.busy_handler(null); |
| db.busy_timeout(0); |
| int id1 = numOfRecords - 3; |
| |
| threadPool.runTask(createTask2(id1, dbFile.getPath(), tracker)); |
| int id2 = numOfRecords + 3; |
| threadPool.runTask(createTask1(id2, dbFile.getPath(), tracker)); |
| int oldID = 5; |
| int newID = 100; |
| threadPool.runTask(createTask3(oldID, dbFile.getPath(), newID, |
| tracker)); |
| |
| threadPool.join(); |
| |
| List<String> errors = tracker.getErrors(); |
| assertTrue("No error occurred on DB but should have",errors.size() > 0); |
| |
| assertEquals(errors.get(0), |
| db.error_string(Constants.SQLITE_LOCKED)); |
| assertEquals(errors.get(0), "database is locked"); |
| |
| // reset |
| |
| db.exec("delete from " + DatabaseCreator.TEST_TABLE1 + " where 1", |
| null); |
| db.exec("delete from " + DatabaseCreator.TEST_TABLE3 + " where 1", |
| null); |
| |
| // increase timeout for retry |
| db.busy_timeout(10000); |
| db.busy_handler(null); |
| tracker.reset(); |
| threadPool = new ThreadPool(numThreads); |
| |
| threadPool.runTask(createTask1(id1, dbFile.getPath(), tracker)); |
| threadPool.runTask(createTask2(id2, dbFile.getPath(), tracker)); |
| |
| threadPool.join(); |
| |
| errors = tracker.getErrors(); |
| if (errors.size() > 0) { |
| fail("busy timeout should prevent from lock exception!"); |
| for (String s: errors) { |
| System.out.println("Round 2 Error"+s); |
| } |
| } else { |
| // ok |
| } |
| |
| |
| } catch (Exception e) { |
| fail("Error in test setup " + e.getMessage()); |
| try { |
| db.get_table("select * from " + DatabaseCreator.TEST_TABLE1, |
| null).toString(); |
| } catch (Exception e1) { |
| |
| e1.printStackTrace(); |
| } |
| e.printStackTrace(); |
| } finally { |
| conn.setAutoCommit(true); |
| // cleanup |
| db.exec(DatabaseCreator.DROP_TABLE1, null); |
| db.exec(DatabaseCreator.DROP_TABLE3, null); |
| } |
| } |
| |
| /** |
| * @tests {@link Database#get_table(String)} |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "get_table", |
| args = {java.lang.String.class} |
| ) |
| public void testGet_tableString() { |
| TableResult emptyTable = new TableResult(); |
| try { |
| //select from empty table |
| TableResult res = db.get_table("select * from " |
| + DatabaseCreator.SIMPLE_TABLE1); |
| assertEquals(res.toString(), emptyTable.toString()); |
| //fill table-> t |
| // DatabaseCreator.fillSimpleTable1(conn); |
| // res = db.get_table("select * from " |
| // + DatabaseCreator.SIMPLE_TABLE1); |
| // assertFalse(emptyTable.toString().equals(res.toString())); |
| |
| try { |
| db.exec("insert into " + DatabaseCreator.SIMPLE_TABLE1 |
| + " VALUES(1, 10, 20)", null); |
| res = db.get_table("select * from " + DatabaseCreator.SIMPLE_TABLE1); |
| db |
| .exec("delete from " + DatabaseCreator.SIMPLE_TABLE1 |
| + " where 1", null); |
| } catch (Exception e) { |
| fail("Database error"); |
| e.printStackTrace(); |
| } |
| String row[] = (String[]) res.rows.elementAt(0); |
| assertEquals(Integer.parseInt(row[0]), 1); |
| assertEquals(Integer.parseInt(row[1]), 10); |
| assertEquals(Integer.parseInt(row[2]), 20); |
| } catch (Exception e) { |
| fail("Error getting table " + e.getMessage()); |
| e.printStackTrace(); |
| // } catch (SQLException e) { |
| // fail("Error initialising table " + e.getMessage()); |
| // e.printStackTrace(); |
| } |
| } |
| |
| /** |
| * @tests {@link Database#get_table(String, String[])} |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "get_table", |
| args = {java.lang.String.class, java.lang.String[].class} |
| ) |
| public void testGet_tableStringStringArray() { |
| String args[] = new String[1]; |
| args[0] = "table"; |
| String argsFail[] = new String[1]; |
| try { |
| TableResult res = db.get_table( |
| "select name from sqlite_master where type = ", argsFail); |
| fail("Testmethod should fail"); |
| } catch (Exception e) { |
| try { |
| TableResult res = db.get_table( |
| "select name from sqlite_master where type = '%q'", |
| args); |
| String[] s = (String[]) res.rows.elementAt(0); |
| assertEquals(s[0], DatabaseCreator.SIMPLE_TABLE1); |
| } catch (Exception e2) { |
| fail("Testmethod failed: " + e2.getMessage()); |
| e.printStackTrace(); |
| } |
| } |
| |
| } |
| |
| /** |
| * @tests {@link Database#get_table(String, String[], TableResult)} |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "get_table", |
| args = {java.lang.String.class, java.lang.String[].class, TableResult.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "toString", |
| clazz = TableResult.class, |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "types", |
| clazz = TableResult.class, |
| args = {String[].class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "TableResult", |
| clazz = TableResult.class, |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.NOT_NECESSARY, |
| notes = "method test", |
| method = "columns", |
| clazz = TableResult.class, |
| args = {String[].class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.NOT_NECESSARY, |
| notes = "method test", |
| method = "newrow", |
| clazz = TableResult.class, |
| args = {String[].class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.NOT_NECESSARY, |
| notes = "method test", |
| method = "clear", |
| clazz = TableResult.class, |
| args = {} |
| ) |
| |
| }) |
| public void testGet_tableStringStringArrayTableResult() { |
| String args[] = new String[1]; |
| String argsFail[] = new String[1]; |
| TableResult res = new TableResult(); |
| TableResult defaultTableRes = new TableResult(); |
| args[0] = "table"; |
| |
| try { |
| db.get_table("select name from sqlite_master where type = '%q'", |
| argsFail, res); |
| assertEquals(defaultTableRes.toString(), res.toString()); |
| } catch (Exception e) { |
| try { |
| db.get_table( |
| "select name from sqlite_master where type = '%q'", |
| args, res); |
| String[] s = (String[]) res.rows.elementAt(0); |
| assertEquals(s[0], DatabaseCreator.SIMPLE_TABLE1); |
| String[] types = res.types; |
| System.out |
| .println("DatabaseTest.testGet_tableStringStringArrayTableResult() "+types.toString()); |
| } catch (Exception e2) { |
| fail("Testmethod failed: " + e2.getMessage()); |
| e.printStackTrace(); |
| } |
| } |
| } |
| |
| |
| /** |
| * @tests {@link Database#complete(String)} |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "complete", |
| args = {java.lang.String.class} |
| ) |
| public void testComplete() { |
| assertFalse(db.complete("create")); |
| assertTrue(db.complete("create table TEST (res double);")); |
| } |
| |
| /** |
| * @tests {@link Database#version()} |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "version", |
| args = {} |
| ) |
| public void testVersion() { |
| String version = db.version(); |
| if (version != null) { |
| assertTrue(Integer.parseInt(db.version().substring(0,1)) > 0); |
| assertEquals(db.version(), db.version()); |
| } else { |
| fail("DB version info missing"); |
| } |
| |
| } |
| |
| /** |
| * @tests {@link Database#dbversion()} |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "dbversion", |
| args = {} |
| ) |
| public void testDbversion() { |
| String verNo = ""; |
| try { |
| verNo = db.dbversion(); |
| db.close(); |
| assertEquals(db.dbversion(),"unknown"); |
| db.open(dbFile.getPath(), 0); |
| assertEquals(verNo,db.dbversion()); |
| } catch (Exception e) { |
| try { |
| db.open(dbFile.getPath(), 0); |
| } catch (Exception e1) { |
| fail("error in db setup "+e.getMessage()); |
| e.printStackTrace(); |
| } |
| fail("error in db setup "+e.getMessage()); |
| e.printStackTrace(); |
| } |
| |
| assertTrue(Integer.parseInt(verNo.substring(0, 1))>= 3 ); |
| |
| } |
| |
| /** |
| * @tests {@link Database#create_function(String, int, Function)} |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "create_function", |
| args = {java.lang.String.class, int.class, Function.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "create_function", |
| args = {java.lang.String.class, int.class, Function.class} |
| ) |
| }) |
| public void testCreate_function() { |
| try { |
| double input = 1.0; |
| db.exec("create table TEST (res double)", null); |
| db.exec("insert into TEST values (" + Double.toString(input) + ")", |
| null); |
| TableResult res = new TableResult(); |
| Function sinFunc = (Function) new SinFunc(); |
| db.create_function("sin", 1, sinFunc); |
| db.exec("select sin(res) from TEST WHERE res = " |
| + Double.toString(input), res); |
| String row[] = (String[]) res.rows.elementAt(0); |
| String val = row[0]; |
| double sinusVal = Double.parseDouble(val); |
| double funcVal = Math.sin(input); |
| |
| assertTrue(Math.round(funcVal) == Math.round(sinusVal)); |
| } catch (Exception e) { |
| fail("Error happened creating function:" + e.getMessage()); |
| e.printStackTrace(); |
| } |
| } |
| |
| /** |
| * @tests {@link Database#create_aggregate(String, int, Function)} |
| */ |
| @TestTargets({ |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "create_aggregate", |
| args = {java.lang.String.class, int.class, Function.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "step", |
| clazz = Function.class, |
| args = {FunctionContext.class, String[].class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "last_step", |
| clazz = Function.class, |
| args = {FunctionContext.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "function", |
| clazz = Function.class, |
| args = {FunctionContext.class, String[].class} |
| ) |
| }) |
| @KnownFailure("Aggregation function not called") |
| public void testCreate_aggregate() { |
| TestTrace t = new TestTrace(); |
| |
| MockFunction aggFunction = new MockFunction(); |
| |
| try { |
| db |
| .exec( |
| "create table TEST(id integer, firstname text, lastname text)", |
| null); |
| db.exec("insert into TEST values(3, 'James', 'Bond'); ", null); |
| db.exec("insert into TEST values(4, 'Fiona', 'Apple'); ", null); |
| db.trace((Trace) t); |
| db.create_aggregate("myaggfunc", 1, aggFunction); |
| db.function_type("myaggfunc", Constants.SQLITE3_TEXT); |
| db.exec("PRAGMA show_datatypes = on", null); |
| |
| assertFalse(aggFunction.functionCalled); |
| assertFalse(aggFunction.stepCalled); |
| assertFalse(aggFunction.lastStepCalled); |
| db.exec("select myaggfunc(TEST.firstname) from TEST", t); |
| assertTrue(aggFunction.stepCalled); |
| assertTrue(aggFunction.lastStepCalled); |
| assertTrue(aggFunction.functionCalled); |
| |
| assertEquals("James Fiona ",aggFunction.getAggValue()); |
| db.exec("drop table TEST", null); |
| } catch (Exception e) { |
| System.out.println(t.getTrace()); |
| fail("Error in test setup: " + e.getMessage()); |
| e.printStackTrace(); |
| } |
| |
| try { |
| db.create_aggregate("myaggfunc", 0, null); |
| } catch (Throwable e) { |
| assertEquals("null SQLite.Function not allowed",e.getMessage()); |
| } |
| |
| try { |
| db.create_aggregate("myaggfunc", 0, aggFunction); |
| } catch (Throwable e) { |
| assertEquals("wrong number of arguments to function myaggfunc()",e.getMessage()); |
| } |
| |
| } |
| |
| /** |
| * @throws Exception |
| * @tests {@link Database#function_type(String, int)} |
| * This method does not make sense |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Method does not make sense: for functions, return type is already set.", |
| method = "function_type", |
| args = {java.lang.String.class, int.class} |
| ) |
| public void testFunction_type() throws Exception { |
| |
| double input = 1.0; |
| TableResult res = new TableResult(); |
| Function sinFunc = (Function) new SinFunc(); |
| |
| db.exec("PRAGMA show_datatypes = on", null); |
| db.exec("create table TEST (res double)", null); |
| db.exec("insert into TEST values (" + Double.toString(input) + ")", |
| null); |
| |
| db.create_function("sin", 1, sinFunc); |
| db.function_type("sin", Constants.SQLITE_FLOAT); |
| res = db.get_table("select sin(res) from TEST WHERE res = " |
| + Double.toString(input)); |
| |
| String row[] = (String[]) res.rows.elementAt(0); |
| String val = row[0]; |
| assertTrue("double".equalsIgnoreCase(res.types[0])); |
| assertSame(Math.round(Math.sin(input)), Math.round(Double.parseDouble(val))); |
| |
| // function determines return type: test that Double type is returned. |
| db.function_type("sin", Constants.SQLITE_BLOB); |
| Stmt s = db.prepare("select sin(res) from TEST WHERE res = ?"); |
| s.bind(1,input); |
| s.step(); |
| |
| res = db.get_table("select sin(res) from TEST WHERE res = " |
| + Double.toString(input)); |
| assertTrue("double".equalsIgnoreCase(res.types[0])); |
| row = (String[]) res.rows.elementAt(0); |
| val = row[0]; |
| assertSame(Math.round(Math.sin(input)), Math.round(Double.parseDouble(val))); |
| |
| |
| |
| |
| } |
| |
| /** |
| * @tests {@link Database#last_error()} |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "last_error", |
| args = {} |
| ) |
| public void testLast_error() { |
| assertEquals(db.last_error(), Constants.SQLITE_OK); |
| try { |
| db.exec("create table TEST (res double)",null); |
| db.exec("create table TEST (res double)",null); |
| fail("Error should have happened"); |
| } catch (Exception e) { |
| assertEquals(db.last_error(),db.last_error()); |
| assertEquals(db.last_error(),Constants.SQLITE_ERROR); |
| } |
| |
| } |
| |
| /** |
| * @tests {@link Database#set_last_error(int)} |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "don't now which other errors may occur from black-box approach.", |
| method = "set_last_error", |
| args = {int.class} |
| ) |
| public void testSet_last_error() { |
| assertEquals(db.last_error(), Constants.SQLITE_OK); |
| |
| try { |
| db.exec("sel from test;", null); |
| } catch (Exception e) { |
| assertEquals(Constants.SQLITE_ERROR,db.last_error()); |
| } |
| } |
| |
| /** |
| * @tests {@link Database#error_message()} |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "error_message", |
| args = {} |
| ) |
| public void testError_message() { |
| String statement = "create table TEST (res double)"; |
| try { |
| db.exec(statement,null); |
| db.exec(statement,null); |
| fail("DB Error expected"); |
| } catch (Exception e) { |
| String dbError = db.error_message(); |
| assertTrue(e.getMessage().equals(dbError)); |
| |
| } |
| } |
| |
| /** |
| * @tests {@link Database#error_string(int)} |
| */ |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "error_string", |
| args = {int.class} |
| ) |
| public void testError_string() { |
| TestTrace t = new TestTrace(); |
| assertEquals(db.last_error(), Constants.SQLITE_OK); |
| String errorString = db.error_string(Constants.SQLITE_ERROR); |
| try { |
| db.trace((Trace) t); |
| db.exec("create table TEST (res double)", t); |
| db.exec("create table TEST (res double)", t); |
| } catch (Exception e) { |
| assertEquals(db.last_error(), Constants.SQLITE_ERROR); |
| if (db.is3()) { |
| assertEquals("Unsupported Method (sqlite 3): error_string", db |
| .error_string(db.last_error()), errorString); |
| } |
| } |
| } |
| |
| /** |
| * @throws UnsupportedEncodingException |
| * @tests {@link Database#set_encoding(String)} |
| * Method unsupported? -> tests fail |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test fails.", |
| method = "set_encoding", |
| args = {java.lang.String.class} |
| ) |
| @KnownFailure("ASCII encoding does not work: a UTF encoded val is returned. Spec is not sufficient. " |
| + "Might be that test impl is wrong or String constructor for the ASCII encoding.") |
| public void testSet_encoding() throws UnsupportedEncodingException { |
| String input = "\u00bfMa\u00f1ana\u003f"; // ?Manana? |
| TableResult res = new TableResult(); |
| String refOutput = null; |
| Stmt stat = null; |
| |
| // DB setup |
| try { |
| db.exec("create table encodingTest (encoded text DEFAULT NULL);", |
| null); |
| stat = db |
| .prepare("insert into encodingTest(encoded) values(:one);"); |
| stat.bind(1, input); |
| stat.step(); |
| // stat.close(); |
| db.exec("select * from encodingTest;", res); |
| String[] encInput = (String[]) res.rows.elementAt(0); |
| String output = encInput[0]; |
| assertEquals(input, output); |
| // db.exec("delete from encodingTest where 1", null); |
| } catch (Exception e1) { |
| fail("Error in test setup: " + e1.getMessage()); |
| e1.printStackTrace(); |
| } |
| |
| // tests for different encoding schemes |
| String[] charsetNames = {"UTF-8", "UTF-16", "UTF-16BE", "UTF-16LE"}; |
| for (int i = 0; i < charsetNames.length; i++) { |
| try { |
| byte[] encInput = input.getBytes(charsetNames[i]); |
| db.set_encoding(charsetNames[i]); |
| db.exec("select * from encodingTest;", res); |
| String[] encOutput = (String[]) res.rows.elementAt(0); |
| String inputAsString = new String(encInput,charsetNames[i]); |
| assertEquals(inputAsString, encOutput[0]); |
| } catch (Exception e4) { |
| fail("Error setting the encoding." + e4.getMessage()); |
| e4.printStackTrace(); |
| } catch (UnsupportedEncodingException e2) { |
| fail(e2.getMessage()); |
| e2.printStackTrace(); |
| } |
| } |
| |
| // Default tests |
| try { |
| db.set_encoding("UTF-16"); |
| db.exec("select * from encodingTest;", res); |
| String[] encOutput1 = (String[]) res.rows.elementAt(0); |
| assertEquals("Got "+encOutput1[0]+" as UTF-16",input,encOutput1[0]); |
| |
| db.set_encoding("US-ASCII"); |
| db.exec("select * from encodingTest;", res); |
| String[] encOutput2 = (String[]) res.rows.elementAt(0); |
| assertEquals(new String(input.getBytes(),"US-ASCII"),encOutput2[0]); |
| } catch (Exception e) { |
| fail("Error setting the encoding." + e.getMessage()); |
| e.printStackTrace(); |
| } |
| |
| |
| // DB teardown |
| try { |
| stat.close(); |
| db.exec("delete from encodingTest", null); |
| // reset encoding |
| } catch (Exception e3) { |
| fail("Error in teardown of encoding environment"); |
| e3.printStackTrace(); |
| } |
| |
| // Default tests |
| try { |
| db.set_encoding(""); |
| fail("invalid input should fail"); |
| } catch (Exception e) { |
| //ok |
| } |
| |
| } |
| |
| /** |
| * Test fails -> implemented correctly? |
| * @tests {@link Database#set_authorizer(Authorizer)} |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test fails.", |
| method = "set_authorizer", |
| args = {Authorizer.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test fails.", |
| method = "authorize", |
| clazz = Authorizer.class, |
| args = {int.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class} |
| ) |
| }) |
| @KnownFailure("Callback never made for authorization. "+ |
| "Results of private table are returned withouth furhter checks.") |
| public void testSet_authorizer() { |
| |
| TableResult resPriv = null; |
| TableResult resPub = null; |
| TableResult emptyTable = new TableResult(); |
| String insertPublic = "insert into public_table values(1,2)"; |
| String insertPrivate = "insert into private_table values(1,2)"; |
| try { |
| // prepare, authorizer is not activated yet |
| db.exec("create table public_table(c1 integer, c2 integer);", null); |
| db.exec("create table private_table(c1 integer, c2 integer);", null); |
| // inserts |
| db.exec(insertPublic, null); |
| db.exec(insertPrivate, null); |
| // selects |
| resPriv = db.get_table("select * from private_table"); |
| resPub = db.get_table("select * from public_table"); |
| |
| // db.exec("delete from public_table where 1", null); |
| // TableResult emptyPubTable = db.exec("select * from public"); |
| |
| // set Authorizer (positive case): denies private table |
| AuthorizerCallback cb = new AuthorizerCallback(); |
| db.set_authorizer(cb); |
| //select |
| |
| db.exec("select * from private_table", cb); |
| assertTrue(cb.wasCalled()); |
| |
| /* |
| TableResult res = db.get_table("select * from private_table"); |
| assertEquals(emptyTable.toString(),res.toString()); |
| assertFalse(emptyTable.equals(resPriv)); |
| |
| res = db.get_table("select * from public_table"); |
| assertEquals(resPub,res); |
| */ |
| } catch (Exception e) { |
| fail("Error testing authorization: "+e.getMessage()); |
| } |
| |
| // Try insert |
| try { |
| db.exec(insertPublic, null); |
| fail("authorization failed"); |
| } catch (Exception e) { |
| try { |
| db.exec(insertPrivate, null); |
| fail("authorization failed"); |
| } catch (Exception e1) { |
| // ok |
| } |
| } |
| |
| } |
| |
| /** |
| * @tests {@link Database#trace(Trace)} |
| */ |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "trace", |
| args = {Trace.class} |
| ) |
| public void testTrace() { |
| String stmt = "create table TEST (res double);"; |
| TestTrace t = new TestTrace(); |
| assertFalse(t.traceCalled); |
| assertEquals(db.last_error(),Constants.SQLITE_OK); |
| try { |
| db.trace((Trace) t); |
| db.exec(stmt,t); |
| assertTrue(t.traceCalled); |
| assertEquals(t.getTrace(),stmt); |
| } catch (Exception e) { |
| fail("Error testing traces: "+e.getMessage()); |
| e.printStackTrace(); |
| } |
| |
| try { |
| db.close(); |
| db.exec(stmt,t); |
| fail("Exception Expected"); |
| } catch (Exception e) { |
| //ok |
| } |
| |
| |
| } |
| |
| /** |
| * @tests {@link Database#compile(String)} |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "compile", |
| args = {java.lang.String.class} |
| ) |
| public void testCompileString() { |
| try { |
| db.compile("select name from sqlite_master;"); |
| } catch (Exception e) { |
| fail("Error compiling sql statement " + e.getMessage()); |
| e.printStackTrace(); |
| } |
| try { |
| db.compile("test"); |
| fail("Compiling of inaccurate statement does not fail."); |
| } catch (Exception e) { |
| |
| } |
| } |
| |
| /** |
| * @tests {@link Database#compile(String, String[])} |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "compile", |
| args = {java.lang.String.class, java.lang.String[].class} |
| ) |
| public void testCompileStringStringArray() { |
| String args[] = new String[1]; |
| args[0] = "table"; |
| try { |
| db.compile("select name from sqlite_master where type = '%q';",args); |
| } catch (Exception e) { |
| fail("Error compiling sql statement " + e.getMessage()); |
| e.printStackTrace(); |
| } |
| try { |
| db.compile("test",null); |
| fail("Compiling of inaccurate statement does not fail."); |
| } catch (Exception e) { |
| |
| } |
| } |
| |
| /** |
| * @tests {@link Database#prepare(String)} |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "prepare", |
| args = {java.lang.String.class} |
| ) |
| public void testPrepare() { |
| Stmt st = null; |
| Stmt st2 = null; |
| // test empty statement |
| try { |
| st = db.prepare(""); |
| assertEquals(0, st.bind_parameter_count()); |
| st.step(); |
| fail("stmt should not be prepared"); |
| } catch (Exception e) { |
| assertEquals("stmt already closed", e.getMessage()); |
| } |
| |
| // test statement with unbound arguments |
| try { |
| st2 = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1 |
| + " values (:one,:two,:three)"); |
| assertEquals(3, st2.bind_parameter_count()); |
| assertEquals(3, st2.bind_parameter_index(":three")); |
| assertEquals(":two", st2.bind_parameter_name(2)); |
| } catch (Exception e) { |
| fail("error in prepare method: " + e.getMessage()); |
| e.printStackTrace(); |
| } finally { |
| try { |
| st2.close(); |
| } catch (Exception e) { |
| fail("error in prepare method cleanup: " + e.getMessage()); |
| e.printStackTrace(); |
| } |
| } |
| |
| try { |
| db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1 |
| + " values(:one,:two,:three,:four);"); |
| } catch (Exception e) { |
| assertEquals("table " + DatabaseCreator.SIMPLE_TABLE1 |
| + " has 3 columns but 4 values were supplied", e |
| .getMessage()); |
| } |
| |
| try { |
| db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1 |
| + " values(5, '10, 20);"); |
| } catch (Exception e) { |
| assertEquals("unrecognized token: \"'10, 20);\"", e.getMessage()); |
| } |
| |
| try { |
| db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1 |
| + " values(5, 10 20);"); |
| } catch (Exception e) { |
| assertEquals("near \"20\": syntax error", e.getMessage()); |
| } |
| |
| } |
| |
| /** |
| * @throws Exception |
| * @throws java.lang.Exception |
| * @tests {@link Database#open_blob(String, String, String, long, boolean)} |
| * unsupported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "open_blob", |
| args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, long.class, boolean.class} |
| ) |
| @KnownFailure("not supported") |
| public void testOpen_blob() throws Exception, java.lang.Exception { |
| Stmt statement2; |
| Blob blobInput = new Blob(); |
| |
| |
| // Create test input Blob |
| InputStream inStream = null; |
| byte[] in = {(byte) 1, (byte) 2, (byte) 3, (byte) 4}; |
| |
| // setup test input |
| db.exec("create table TEST (res blob)",null); |
| inStream = Class.forName(this.getClass().getName()).getResourceAsStream("/blob.c"); |
| assertNotNull(inStream); |
| |
| |
| // insert byte array in db |
| try { |
| statement2 = db.prepare("insert into TEST(res) values (?)"); |
| statement2.bind(1, in); |
| statement2.step(); |
| statement2.close(); |
| } catch (Exception e) { |
| fail("Error happened inserting blob" + e.getMessage()); |
| e.printStackTrace(); |
| } |
| |
| // read from db |
| byte[] output = null; |
| Blob blob; |
| |
| blob = db.open_blob(dbFile.getPath(), "TEST", "res", 1, true); |
| if (blob == null) { |
| fail("Blob could not be retrieved"); |
| } |
| //read from blob and compare values (positive case) |
| InputStream is = blob.getInputStream(); |
| |
| int i = 0; |
| int outByte = 0; |
| byte[] out = new byte[4]; |
| while ((outByte = is.read()) > -1) { |
| out[i] = (byte) outByte; |
| i++; |
| } |
| is.close(); |
| |
| blob.close(); |
| |
| assertTrue(Arrays.equals(in, out)); |
| |
| //read from blob and compare values (default blob) |
| db.exec("insert into TEST values(zeroblob(128))", null); |
| Blob blob2 = db.open_blob(dbFile.getPath(), "TEST", "res", 2, true); |
| is = blob2.getInputStream(); |
| for (i = 0; i < 128; i++) { |
| assertEquals(0, is.read()); |
| } |
| is.close(); |
| } |
| |
| /** |
| * @tests {@link Database#is3()} |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "is3", |
| args = {} |
| ) |
| public void testIs3() { |
| int ver = Integer.parseInt(db.version().substring(0,1)); |
| if (db.is3()) { |
| assertTrue( ver == 3); |
| } else { |
| assertTrue(ver != 3); |
| } |
| } |
| |
| /** |
| * @tests {@link Database#progress_handler(int, ProgressHandler)} |
| */ |
| @TestTargets ({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "progress_handler", |
| args = {int.class, ProgressHandler.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "method test", |
| method = "progress", |
| clazz = ProgressHandler.class, |
| args = {} |
| ) |
| }) |
| public void testProgress_handler() { |
| int inputVal = 3; |
| TestProgressHandler prog = new TestProgressHandler(); |
| try { |
| db.exec("create table TEST5(id integer, firstname text, lastname text)",null); |
| Vm vm = db.compile("select * from TEST5; " |
| + "insert into TEST5 values(3, 'James', 'Bond'); " |
| + "delete from TEST5 where id = 3; " |
| + "select * from TEST5"); |
| int stmt = 0; |
| do { |
| ++stmt; |
| if (stmt > inputVal) { |
| db.progress_handler(inputVal, prog); |
| } else { |
| assertEquals(0, prog.getCounts()); |
| } |
| while (vm.step(prog)) { |
| } |
| } while (vm.compile()); |
| assertEquals(inputVal,prog.getCounts()); |
| } catch (Exception e) { |
| fail("Error in test setup: "+e.getMessage()); |
| e.printStackTrace(); |
| } |
| |
| // Boundary value test |
| inputVal = 0; |
| TestProgressHandler progBoundary = new TestProgressHandler(); |
| db.progress_handler(inputVal, progBoundary); |
| try { |
| Vm vm2 = db.compile("select * from TEST5; " |
| + "insert into TEST5 values(3, 'James', 'Bond'); " |
| + "delete from TEST5 where id = 3; " |
| + "select * from TEST5"); |
| do { |
| vm2.step(progBoundary); |
| } while (vm2.compile()); |
| assertEquals(inputVal, progBoundary.getCounts()); |
| }catch (Exception e) { |
| fail("Error in test setup: "+e.getMessage()); |
| e.printStackTrace(); |
| } |
| |
| try { |
| db.exec("drop table TEST5",null); |
| } catch (Exception e) { |
| System.out.println(e.getMessage()); |
| e.printStackTrace(); |
| } |
| } |
| |
| |
| |
| class SinFunc implements Function { |
| |
| |
| public void function(FunctionContext fc, String args[]) { |
| Double d = new Double(args[0]); |
| fc.set_result(Math.sin(d.doubleValue())); |
| } |
| |
| public void last_step(FunctionContext fc) { |
| // TODO Auto-generated method stub |
| |
| } |
| |
| public void step(FunctionContext fc, String[] args) { |
| // TODO Auto-generated method stub |
| |
| } |
| } |
| |
| @TestTargetClass(Trace.class) |
| class TestTrace implements Trace,Callback { |
| |
| private StringBuffer buf = new StringBuffer(); |
| |
| public boolean traceCalled = false; |
| |
| public String getTrace() { |
| return buf.toString(); |
| } |
| |
| public void trace(String stmt) { |
| traceCalled = true; |
| buf.append(stmt); |
| } |
| |
| public void columns(String[] coldata) { |
| // TODO Auto-generated method stub |
| |
| } |
| |
| public boolean newrow(String[] rowdata) { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| |
| public void types(String[] types) { |
| // TODO Auto-generated method stub |
| |
| } |
| } |
| |
| @TestTargetClass(Authorizer.class) |
| class AuthorizerCallback implements Authorizer,Callback { |
| private boolean isAuthorizing = false; |
| |
| public boolean wasCalled() { |
| return isAuthorizing; |
| } |
| |
| public int authorize(int action, String arg1, String arg2, String arg3, |
| String arg4) { |
| Logger.global.info("DB authorization callback "+action+" "+arg1+" "+arg2+" "+arg3+" "+arg4+" "); |
| this.isAuthorizing = true; |
| if (action != Constants.SQLITE_SELECT || arg1.contains("private_table")) { |
| return Constants.SQLITE_DENY; |
| } else { |
| return Constants.SQLITE_OK; |
| } |
| } |
| |
| public void columns(String[] coldata) { |
| // TODO Auto-generated method stub |
| |
| } |
| |
| public boolean newrow(String[] rowdata) { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| |
| public void types(String[] types) { |
| // TODO Auto-generated method stub |
| |
| } |
| |
| } |
| |
| class TestBusyHandler implements BusyHandler, Callback { |
| |
| public boolean busy(String table, int count) { |
| System.out.println("BUSY!"); |
| return true; |
| } |
| |
| public void columns(String[] coldata) { |
| // TODO Auto-generated method stub |
| |
| } |
| |
| public boolean newrow(String[] rowdata) { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| |
| public void types(String[] types) { |
| // TODO Auto-generated method stub |
| |
| } |
| |
| } |
| |
| class TestProgressHandler implements ProgressHandler,Callback { |
| |
| private boolean progressed = false; |
| |
| private int counter = 0; |
| |
| public boolean isProgressed() { |
| return progressed; |
| } |
| |
| public int getCounts() { |
| return counter; |
| } |
| |
| public boolean progress() { |
| this.progressed = true; |
| counter++; |
| return true; |
| } |
| |
| public void columns(String[] coldata) { |
| // TODO Auto-generated method stub |
| |
| } |
| |
| public boolean newrow(String[] rowdata) { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| |
| public void types(String[] types) { |
| // TODO Auto-generated method stub |
| |
| } |
| |
| } |
| |
| // class dbBusyThread implements Runnable { |
| // |
| // String dbName = "sqliteTest.db"; |
| // |
| // Thread runner; |
| // public dbBusyThread() { |
| // } |
| // public dbBusyThread(String threadName) { |
| // runner = new Thread(this, threadName); // (1) Create a new thread. |
| // System.out.println(runner.getName()); |
| // runner.start(); // (2) Start the thread. |
| // } |
| // public void run() { |
| // insert(3000); |
| // } |
| // |
| // public void runNoDelay() { |
| // insert(0); |
| // } |
| // |
| // synchronized private void insert(long delay) { |
| // Database db2 = new Database(); |
| // try { |
| // db2.open(dbName, 0); |
| // db2.exec("insert into TEST5 values (4,'Anglina','Jolie');", |
| // null); |
| // wait(delay); |
| // } catch (Exception e) { |
| // System.out.println("Error in Thread " + e.getMessage()); |
| // e.printStackTrace(); |
| // } catch (InterruptedException e2) { |
| // System.out.println("Error in Thread " + e2.getMessage()); |
| // e2.printStackTrace(); |
| // } finally { |
| // try { |
| // db2.close(); |
| // } catch (Exception e) { |
| // // We do not handle this case |
| // } |
| // } |
| // } |
| // } |
| |
| /** |
| * This method creates a Runnable that executes insert operation for the |
| * first table |
| */ |
| private static Runnable createTask2Interrupt(final int id, |
| final String dbName, final ErrorTracker errorTracker) { |
| return new Runnable() { |
| public void run() { |
| Database db = new Database(); |
| try { |
| String value = DatabaseCreator.defaultString + id; |
| |
| db.open(dbName, 0); |
| String insertQuery = "INSERT INTO " |
| + DatabaseCreator.TEST_TABLE1 |
| + " (id, field1, field2, field3) VALUES(" + id |
| + ", '" + value + "', " + id + ", " + id + ")"; |
| db.exec(insertQuery, null); |
| } catch (Exception e) { |
| errorTracker.registerException(this, e); |
| try { |
| db.interrupt(); |
| db.exec("DELETE FROM " + DatabaseCreator.SIMPLE_TABLE1 |
| + " WHERE id=" + id, null); |
| } catch (Exception e1) { |
| errorTracker.registerException(this, e1); |
| } |
| } |
| } |
| }; |
| } |
| |
| /** |
| * This method creates a Runnable that executes delete operation for the |
| * first table |
| */ |
| private static Runnable createTask1(final int id,final String dbName, final ErrorTracker errorTracker) { |
| return new Runnable() { |
| public void run() { |
| try { |
| Database db = new Database(); |
| db.open(dbName, 0); |
| db.exec("DELETE FROM " |
| + DatabaseCreator.SIMPLE_TABLE1 + " WHERE id=" + id,null); |
| } catch (Exception e) { |
| errorTracker.registerException(this, e); |
| } |
| } |
| }; |
| } |
| |
| /** |
| * This method creates a Runnable that executes insert operation for the |
| * first table |
| */ |
| private static Runnable createTask2(final int id, final String dbName, final ErrorTracker errorTracker ) { |
| return new Runnable() { |
| public void run() { |
| try { |
| String value = DatabaseCreator.defaultString + id; |
| Database db = new Database(); |
| db.open(dbName, 0); |
| String insertQuery = "INSERT INTO " |
| + DatabaseCreator.TEST_TABLE1 |
| + " (id, field1, field2, field3) VALUES(" + id |
| + ", '" + value + "', " + id + ", " + id + ")"; |
| db.exec(insertQuery,null); |
| } catch (Exception e) { |
| errorTracker.registerException(this, e); |
| |
| } |
| } |
| }; |
| } |
| |
| /** |
| * This method creates a Runnable that executes update operation for the one |
| * record of the first table |
| */ |
| private static Runnable createTask3(final int oldID, final String dbName, |
| final int newID, final ErrorTracker errorTracker) { |
| return new Runnable() { |
| public void run() { |
| Database db = new Database(); |
| try { |
| db.open(dbName, 0); |
| String value = DatabaseCreator.defaultString + newID; |
| String updateQuery = "UPDATE " |
| + DatabaseCreator.TEST_TABLE1 + " SET id=" + newID |
| + ", field1='" + value + "', field2=" + newID |
| + ", field3=" + newID + " WHERE id=" + oldID; |
| db.exec(updateQuery, null); |
| } catch (Exception e) { |
| errorTracker.registerException(this, e); |
| } |
| } |
| }; |
| } |
| |
| private class ErrorTracker { |
| private List<String> errors = new ArrayList<String>(); |
| |
| public void registerException(Runnable runnable, Exception e) { |
| System.out.println("Registered: "+e.getMessage()); |
| errors.add(e.getMessage()); |
| } |
| |
| public List<String> getErrors() { |
| return errors; |
| } |
| |
| public void reset() { |
| errors.clear(); |
| } |
| } |
| |
| } |
