auto import from //depot/cupcake/@135843

1 files changed, 2037 insertions, 0 deletions

diff --git a/sql/src/test/java/tests/SQLite/DatabaseTest.java b/sql/src/test/java/tests/SQLite/DatabaseTest.java
new file mode 100644
index 0000000..50eb6cc
--- /dev/null
+++ b/sql/src/test/java/tests/SQLite/DatabaseTest.java
@@ -0,0 +1,2037 @@
+/*
+ * 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.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}
+                    )
+    })
+    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.SQLITE_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_NUMERIC);
+        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();
+        }
+    }
+   
+}
+