Scrub libcore's SQLite and JDBC tests.

I've moved the tests to the libcore package because they're
maintained by Androids, unlike the tests.* classes maintained
by Apache Harmony.

Change-Id: I23b5ca845517129f426addeabc38e43a8fee4299

1 files changed, 0 insertions, 1191 deletions

diff --git a/luni/src/test/java/tests/SQLite/StmtTest.java b/luni/src/test/java/tests/SQLite/StmtTest.java
deleted file mode 100644
index d512325..0000000
--- a/luni/src/test/java/tests/SQLite/StmtTest.java
+++ /dev/null
@@ -1,1191 +0,0 @@
-/*
- * 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 SQLite.Constants;
-import SQLite.Database;
-import SQLite.Exception;
-import SQLite.Stmt;
-import SQLite.TableResult;
-import dalvik.annotation.BrokenTest;
-import dalvik.annotation.KnownFailure;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTargetNew;
-import dalvik.annotation.TestTargetClass;
-
-
-import tests.support.DatabaseCreator;
-import tests.support.Support_SQL;
-
-import java.sql.Connection;
-import java.sql.SQLException;
-
-@TestTargetClass(Stmt.class)
-public class StmtTest extends SQLiteTest {
-
-    private static Database db = null;
-
-    private static Stmt st = null;
-
-    private static final String createAllTypes =
-    "create table type (" +
-
-    " BoolVal BOOLEAN," + " IntVal INT," + " LongVal LONG,"
-            + " Bint BIGINT," + " Tint TINYINT," + " Sint SMALLINT,"
-            + " Mint MEDIUMINT, " +
-
-            " IntegerVal INTEGER, " + " RealVal REAL, "
-            + " DoubleVal DOUBLE, " + " FloatVal FLOAT, "
-            + " DecVal DECIMAL, " +
-
-            " NumVal NUMERIC, " + " charStr CHAR(20), "
-            + " dateVal DATE, " + " timeVal TIME, " + " TS TIMESTAMP, "
-            +
-
-            " DT DATETIME, " + " TBlob TINYBLOB, " + " BlobVal BLOB, "
-            + " MBlob MEDIUMBLOB, " + " LBlob LONGBLOB, " +
-
-            " TText TINYTEXT, " + " TextVal TEXT, "
-            + " MText MEDIUMTEXT, " + " LText LONGTEXT, " +
-
-            " MaxLongVal BIGINT, MinLongVal BIGINT, "+
-
-            " validURL URL, invalidURL URL "+
-
-            ");";
-
-    static final String insertAllTypes =
-        "insert into type (BoolVal, IntVal, LongVal, Bint, Tint, Sint, Mint,"
-        + "IntegerVal, RealVal, DoubleVal, FloatVal, DecVal,"
-        + "NumVal, charStr, dateVal, timeVal, TS,"
-        + "DT, TBlob, BlobVal, MBlob, LBlob,"
-        + "TText, TextVal, MText, LText, MaxLongVal, MinLongVal,"
-        + " validURL, invalidURL"
-        + ") "
-        + "values (1, -1, 22, 2, 33,"
-        + "3, 1, 2, 3.9, 23.2, 33.3, 44,"
-        + "5, 'test string', '1799-05-26', '12:35:45', '2007-10-09 14:28:02.0',"
-        + "'1221-09-22 10:11:55', 1, 2, 3, 4,"
-        + "'Test text message tiny', 'Test text',"
-        + " 'Test text message medium', 'Test text message long', "
-        + Long.MAX_VALUE+", "+Long.MIN_VALUE+", "
-        + "null, null "+
-        ");";
-
-    static final String allTypesTable = "type";
-
-    public void setUp() throws java.lang.Exception {
-        super.setUp();
-        Support_SQL.loadDriver();
-        db = new Database();
-        db.open(dbFile.getPath(), 0);
-        db.exec(DatabaseCreator.CREATE_TABLE_SIMPLE1, null);
-        DatabaseCreator.fillSimpleTable1(conn);
-
-    }
-
-    public void tearDown() {
-        if (st != null) {
-            try {
-            st.close();
-            } catch (Exception e) {
-
-            }
-        }
-        try {
-            db.close();
-            Connection con = Support_SQL.getConnection();
-            con.close();
-//            dbFile.delete();
-        } catch (Exception e) {
-            fail("Exception in tearDown: "+e.getMessage());
-        } catch (SQLException e) {
-            fail("SQLException in tearDown: "+e.getMessage());
-        }
-        super.tearDown();
-    }
-
-    /**
-     * @tests {@link Stmt#Stmt()}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "constructor test",
-        method = "Stmt",
-        args = {}
-    )
-    public void testStmt() {
-        Stmt st = new Stmt();
-        assertNotNull(st);
-        try {
-            Stmt actual = db.prepare("");
-            assertNotNull(st);
-            // no black box test assertEquals(actual.error_code,st.error_code);
-        } catch (Exception e) {
-            fail("Statement setup fails: "+e.getMessage());
-            e.printStackTrace();
-        }
-
-        try {
-               st.step();
-               fail("Cannot execute non prepared Stmt");
-        } catch (Exception e) {
-            //ok
-        }
-    }
-
-    /**
-     * @tests {@link Stmt#prepare()}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "method test",
-        method = "prepare",
-        args = {}
-    )
-    public void testPrepare() {
-        try {
-            st = db.prepare("");
-            st.prepare();
-            fail("statement is closed");
-        } catch (Exception e) {
-            assertEquals("stmt already closed", e.getMessage());
-        }
-
-        try {
-            st = new Stmt();
-            st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1);
-            assertFalse(st.prepare());
-            st = new Stmt();
-            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
-                    + " values (:one,:two,:three)");
-            assertFalse(st.prepare());
-            st = new Stmt();
-            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
-                    + " values (:one,:two,:three)");
-            st.bind(1, 1);
-            st.bind(2, 10);
-            st.bind(3, 30);
-            assertFalse(st.prepare());
-            st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1
-                    + "; " + "delete from " + DatabaseCreator.SIMPLE_TABLE1
-                    + " where id = 5; " + "insert into "
-                    + DatabaseCreator.SIMPLE_TABLE1 + " values(5, 10, 20); "
-                    + "select * from " + DatabaseCreator.SIMPLE_TABLE1 + ";");
-            assertTrue(st.prepare());
-            assertTrue(st.prepare());
-            assertTrue(st.prepare());
-            assertFalse(st.prepare());
-        } catch (Exception e) {
-            fail("statement should be ready for execution: "
-                    + e.getMessage());
-            e.printStackTrace();
-        }
-    }
-
-    /**
-     * @tests {@link Stmt#step()}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "method test",
-        method = "step",
-        args = {}
-    )
-    public void testStep() {
-        try {
-            st.step();
-            fail("Exception expected");
-        } catch (Exception e) {
-            assertEquals("stmt already closed", e.getMessage());
-        }
-
-        try {
-            st = new Stmt();
-            st = db.prepare("select name from sqlite_master where type = 'table'");
-            st.step();
-        } catch (Exception e) {
-           fail("test fails");
-        }
-
-    }
-
-    /**
-     * @tests {@link Stmt#close()}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "method test",
-        method = "close",
-        args = {}
-    )
-    public void testClose() {
-        try {
-            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
-                    + " values (:one,:two,:three)");
-            st.close();
-        } catch (Exception e) {
-            fail("Test fails");
-            e.printStackTrace();
-        }
-
-        try {
-            st.step();
-            fail("Test fails");
-        } catch (Exception e) {
-            assertEquals("stmt already closed", e.getMessage());
-        }
-    }
-
-    /**
-     * @throws Exception
-     * @tests {@link Stmt#reset()}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "method test",
-        method = "reset",
-        args = {}
-    )
-    public void testReset() throws Exception {
-        db.exec("create table TEST (res integer not null)", null);
-
-        st = db.prepare("insert into TEST values (:one);");
-        st.bind(1, 1);
-        st.step();
-
-        // verify that parameter is still bound
-        st.reset();
-        assertEquals(1,st.bind_parameter_count());
-        st.step();
-
-        TableResult count = db.get_table("select count(*) from TEST where res=1", null);
-
-        String[] row0 = (String[]) count.rows.elementAt(0);
-        assertEquals(2, Integer.parseInt(row0[0]));
-    }
-
-    /**
-     * @tests {@link Stmt#clear_bindings()}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "not supported",
-        method = "clear_bindings",
-        args = {}
-    )
-    public void testClear_bindings() {
-        try {
-            st.clear_bindings();
-        } catch (Exception e) {
-            assertEquals("unsupported", e.getMessage());
-        }
-    }
-
-    /**
-     * @tests {@link Stmt#bind(int, int)}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "method test",
-        method = "bind",
-        args = {int.class, int.class}
-    )
-    public void testBindIntInt() {
-        try {
-            int input = 0;
-            int maxVal = Integer.MAX_VALUE;
-            int minVal = Integer.MIN_VALUE;
-
-            db.exec("create table TEST (res integer)", null);
-            st = db.prepare("insert into TEST values (:one);");
-            st.bind(1, input);
-            st.step();
-
-            st.reset();
-            st.bind(1,maxVal);
-            st.step();
-
-            st.reset();
-            st.bind(1,minVal);
-            st.step();
-
-            TableResult r = db.get_table("select * from TEST");
-
-            String[] row0 = (String[]) r.rows.elementAt(0);
-            assertEquals(input,Integer.parseInt(row0[0]));
-
-            String[] row1 = (String[]) r.rows.elementAt(1);
-            assertEquals(maxVal,Integer.parseInt(row1[0]));
-
-            String[] row2 = (String[]) r.rows.elementAt(2);
-            assertEquals(minVal,Integer.parseInt(row2[0]));
-
-        } catch (Exception e) {
-            fail("Error in test setup: "+e.getMessage());
-            e.printStackTrace();
-        }
-
-        try {
-            st.close();
-            st.bind(1,Integer.MIN_VALUE);
-            fail("Exception expected");
-        } catch (Exception e) {
-            //ok
-        }
-    }
-
-    /**
-     * @tests {@link Stmt#bind(int, long)}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "method test",
-        method = "bind",
-        args = {int.class, long.class}
-    )
-    public void testBindIntLong() {
-        try {
-            long input = 0;
-            long maxVal = Long.MAX_VALUE;
-            long minVal = Long.MIN_VALUE;
-
-            db.exec("create table TEST (res long)", null);
-            st = db.prepare("insert into TEST values (:one);");
-            st.bind(1, input);
-            st.step();
-
-            st.reset();
-            st.bind(1,maxVal);
-            st.step();
-
-            st.reset();
-            st.bind(1,minVal);
-            st.step();
-
-            TableResult r = db.get_table("select * from TEST");
-
-            String[] row0 = (String[]) r.rows.elementAt(0);
-            assertEquals(input,Long.parseLong(row0[0]));
-
-            String[] row1 = (String[]) r.rows.elementAt(1);
-            assertEquals(maxVal,Long.parseLong(row1[0]));
-
-            String[] row2 = (String[]) r.rows.elementAt(2);
-            assertEquals(minVal,Long.parseLong(row2[0]));
-
-        } catch (Exception e) {
-            fail("Error in test setup: "+e.getMessage());
-            e.printStackTrace();
-        }
-
-        try {
-            st.close();
-            st.bind(1,Long.MIN_VALUE);
-            fail("Exception expected");
-        } catch (Exception e) {
-            //ok
-        }
-    }
-
-    /**
-     * @tests {@link Stmt#bind(int, double)}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "method test",
-        method = "bind",
-        args = {int.class, double.class}
-    )
-    public void testBindIntDouble() {
-        try {
-            double input = 0.0;
-            double maxVal = Double.MAX_VALUE;
-            double minVal = Double.MIN_VALUE;
-            double negInf = Double.NEGATIVE_INFINITY;
-            double posInf = Double.POSITIVE_INFINITY;
-            double nan = Double.NaN;
-
-            db.exec("create table TEST (res double)", null);
-            st = db.prepare("insert into TEST values (:one);");
-            st.bind(1, input);
-            st.step();
-
-            st.reset();
-            st.bind(1, maxVal);
-            st.step();
-
-            st.reset();
-            st.bind(1, minVal);
-            st.step();
-
-            st.reset();
-            st.bind(1, negInf);
-            st.step();
-
-            st.reset();
-            st.bind(1, posInf);
-            st.step();
-
-            st.reset();
-            st.bind(1, nan);
-            st.step();
-
-
-            TableResult r = db.get_table("select * from TEST");
-
-            String[] row0 = (String[]) r.rows.elementAt(0);
-            assertTrue(Double.compare(input, Double.parseDouble(row0[0])) == 0);
-
-            String[] row1 = (String[]) r.rows.elementAt(1);
-            assertFalse(Double.compare(maxVal, Double.parseDouble(row1[0])) == 0);
-            assertTrue(Double.compare(maxVal, Double.parseDouble(row1[0])) < 0);
-            assertTrue(Double.isInfinite(Double.parseDouble(row1[0])));
-
-            String[] row2 = (String[]) r.rows.elementAt(2);
-            assertTrue(Double.compare(minVal, Double.parseDouble(row2[0])) == 0);
-
-            String[] row3 = (String[]) r.rows.elementAt(3);
-            assertEquals("Double.NEGATIVE_INFINITY SQLite representation",
-                    "-Inf", row3[0]);
-
-            String[] row4 = (String[]) r.rows.elementAt(4);
-            assertEquals("Double.POSITIVE_INFINITY SQLite representation",
-                    "Inf", row4[0]);
-
-            String[] row5 = (String[]) r.rows.elementAt(4);
-            assertEquals("Double.Nan SQLite representation", "Inf", row5[0]);
-
-        } catch (Exception e) {
-            fail("Error in test setup: " + e.getMessage());
-            e.printStackTrace();
-        }
-
-        try {
-            st.close();
-            st.bind(1,0.0);
-            fail("Exception expected");
-        } catch (Exception e) {
-            //ok
-        }
-    }
-
-    /**
-     * @tests {@link Stmt#bind(int, byte[])}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "",
-        method = "bind",
-        args = {int.class, byte[].class}
-    )
-    public void testBindIntByteArray() {
-
-        String name = "Hello World";
-
-        try {
-            byte[] b = new byte[name.getBytes().length];
-            b = name.getBytes();
-            String stringInHex = "";
-
-            db.exec(DatabaseCreator.CREATE_TABLE_PARENT, null);
-            st = db.prepare("insert into " + DatabaseCreator.PARENT_TABLE
-                    + " values (:one, :two);");
-            st.bind(1, 2);
-            st.bind(2, b);
-            st.step();
-
-            //compare what was stored with input based on Hex representation
-            // since type of column is CHAR
-            TableResult r = db.get_table("select * from "
-                    + DatabaseCreator.PARENT_TABLE);
-            String[] row = (String[]) r.rows.elementAt(0);
-
-            for (byte aByte : b) {
-                stringInHex += Integer.toHexString(aByte);
-            }
-            stringInHex = "X'" + stringInHex + "'";
-            assertTrue(stringInHex.equalsIgnoreCase(row[1]));
-
-        } catch (Exception e) {
-            fail("Error in test setup: "+e.getMessage());
-            e.printStackTrace();
-        }
-
-        try {
-            st.close();
-            st.bind(1,name.getBytes());
-            fail("Exception expected");
-        } catch (Exception e) {
-            //ok
-        }
-    }
-
-    /**
-     * @tests {@link Stmt#bind(int, String)}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "method test",
-        method = "bind",
-        args = {int.class, java.lang.String.class}
-    )
-    public void testBindIntString() {
-        String name = "Hello World";
-
-        try {
-
-            db.exec(DatabaseCreator.CREATE_TABLE_PARENT, null);
-            st = db.prepare("insert into " + DatabaseCreator.PARENT_TABLE
-                    + " values (:one, :two);");
-            st.bind(1, 2);
-            st.bind(2, name);
-            st.step();
-
-            TableResult r = db.get_table("select * from "
-                    + DatabaseCreator.PARENT_TABLE);
-            String[] row = (String[]) r.rows.elementAt(0);
-            assertEquals(name,row[1]);
-
-        } catch (Exception e) {
-            fail("Error in test setup: "+e.getMessage());
-            e.printStackTrace();
-        }
-
-        try {
-            st.close();
-            st.bind(1,name);
-            fail("Exception expected");
-        } catch (Exception e) {
-            //ok
-        }
-    }
-
-    /**
-     * @tests {@link Stmt#bind(int)}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "method test",
-        method = "bind",
-        args = {int.class}
-    )
-    public void testBindInt() {
-
-        try {
-            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
-                    + " values (:one,:two,:three)");
-            st.bind(4);
-            st.bind(1, 4);
-            st.bind(2, 10);
-            st.bind(3, 30);
-            st.step();
-            fail("Test failes");
-        } catch (Exception e) {
-            // What happens if null is bound to non existing variable position
-            assertEquals("parameter position out of bounds" , e.getMessage());
-        }
-
-        // functional tests
-
-        try {
-            st.reset();
-            st.bind(1);
-            st.bind(2, 10);
-            st.bind(3, 30);
-            st.step();
-            fail("Test failes");
-        } catch (Exception e) {
-            // What happens if null is bound to NON NULL field
-            assertEquals("SQL logic error or missing database", e.getMessage());
-        }
-
-        try {
-            st.reset();
-            st.bind(1, 3);
-            st.bind(2);
-            st.bind(3, 30);
-            st.step();
-        } catch (Exception e) {
-            fail("Error in test setup : " + e.getMessage());
-        }
-
-    }
-
-    public void testBind_zeroblob() {
-        try {
-            st.bind_zeroblob(1, 128);
-        } catch (Exception e) {
-            assertEquals("unsupported", e.getMessage());
-        }
-    }
-
-    /**
-     * @tests {@link Stmt#bind_parameter_count()}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "method test",
-        method = "bind_parameter_count",
-        args = {}
-    )
-    public void testBind_parameter_count() {
-        try {
-            st.bind_parameter_count();
-        } catch (Exception e) {
-            assertEquals("stmt already closed", e.getMessage());
-        }
-
-        try {
-            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
-                    + " values (:one,:two,:three)");
-            assertEquals(3, st.bind_parameter_count());
-        } catch (Exception e) {
-            fail("Error in test setup : " + e.getMessage());
-            e.printStackTrace();
-        }
-
-        try {
-            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
-                    + " values (?, ?, ?)");
-            assertEquals(3, st.bind_parameter_count());
-        } catch (Exception e) {
-            fail("Error in test setup : " + e.getMessage());
-            e.printStackTrace();
-        }
-
-        try {
-            st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1);
-            assertEquals(0, st.bind_parameter_count());
-        } catch (Exception e) {
-            fail("Error in test setup : " + e.getMessage());
-            e.printStackTrace();
-        }
-
-        try {
-            st.close();
-            st.bind_parameter_count();
-            fail("Exception expected");
-        } catch (Exception e) {
-            //ok
-        }
-
-    }
-
-    /**
-     * @tests {@link Stmt#bind_parameter_name(int)}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "method test",
-        method = "bind_parameter_name",
-        args = {int.class}
-    )
-    public void testBind_parameter_name() {
-        try {
-            st.bind_parameter_name(1);
-            fail("Exception expected");
-        } catch (Exception e) {
-            assertEquals("stmt already closed", e.getMessage());
-        }
-
-        try {
-            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
-                    + " values (:one,:two,:three)");
-            assertEquals(":one", st.bind_parameter_name(1));
-            assertEquals(":two", st.bind_parameter_name(2));
-            assertEquals(":three", st.bind_parameter_name(3));
-            String name = st.bind_parameter_name(4);
-        } catch (Exception e) {
-            assertEquals("parameter position out of bounds",e.getMessage());
-        }
-    }
-
-    /**
-     * @tests {@link Stmt#bind_parameter_index(String)}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "method test",
-        method = "bind_parameter_index",
-        args = {java.lang.String.class}
-    )
-    public void testBind_parameter_index() {
-
-        try {
-            st.bind_parameter_index("");
-            fail("Exception expected");
-        } catch (Exception e) {
-            assertEquals("stmt already closed", e.getMessage());
-        }
-
-        try {
-            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
-                    + " values (:one,:two,:three)");
-            assertEquals(3, st.bind_parameter_index(":three"));
-        } catch (Exception e) {
-            fail("Error in test setup : " + e.getMessage());
-            e.printStackTrace();
-        }
-
-        try {
-            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
-                    + " values (:one,:two,:three)");
-            assertEquals(0, st.bind_parameter_index(":t"));
-        } catch (Exception e) {
-            fail("Error in test setup : " + e.getMessage());
-            e.printStackTrace();
-        }
-
-        try {
-            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
-                    + " values (?, ?, ?)");
-            assertEquals(0, st.bind_parameter_index("?"));
-        } catch (Exception e) {
-            fail("Error in test setup : " + e.getMessage());
-            e.printStackTrace();
-        }
-
-    }
-
-    /**
-     * @throws Exception
-     * @tests {@link Stmt#column_int(int)}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "method test",
-        method = "column_int",
-        args = {int.class}
-    )
-    public void testColumn_int() throws Exception {
-        db.exec(createAllTypes, null);
-        db.exec(insertAllTypes, null);
-
-        int columnObjectCastFromLong;
-        Object columnObject  = null;
-        int intColumn = 0;
-        String selectStmt = "select * from "+DatabaseCreator.SIMPLE_TABLE1;
-
-        st = db.prepare(selectStmt);
-        st.step();
-        // select 'speed' value
-        columnObject = st.column(1);
-        intColumn = st.column_int(1);
-        assertNotNull(intColumn);
-
-        assertTrue("Integer".equalsIgnoreCase(st.column_decltype(1)));
-        int stSpeed = Integer.parseInt(columnObject.toString());
-        assertNotNull(stSpeed);
-        assertEquals( intColumn, stSpeed);
-        assertEquals(10,stSpeed);
-
-        selectStmt = "select TextVal from "+allTypesTable;
-
-        st = db.prepare(selectStmt);
-        st.step();
-        // select double value
-        try {
-            st.column_int(0);
-        } catch (Exception e) {
-            //ok
-        }
-    }
-
-    /**
-     * @tests {@link Stmt#column_long(int)}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "method test",
-        method = "column_long",
-        args = {int.class}
-    )
-    public void testColumn_long() {
-        Object columnObject  = null;
-        int columnObjectCastFromLong;
-        long longColumn = 0;
-        try {
-            String selectStmt = "select * from "+DatabaseCreator.SIMPLE_TABLE1;
-            st = db.prepare(selectStmt);
-            st.step();
-            columnObject = st.column(1);
-            longColumn = st.column_long(1);
-            assertNotNull(longColumn);
-            // column declared as integer
-            assertTrue("Integer".equalsIgnoreCase(st.column_decltype(1)));
-            int stSpeed = Integer.parseInt(columnObject.toString());
-            assertNotNull(stSpeed);
-            assertEquals( longColumn, stSpeed);
-        } catch (Exception e) {
-            fail("Error in test setup : " + e.getMessage());
-            e.printStackTrace();
-        }
-
-        try {
-            st.column_long(4);
-            fail("Exception expected");
-        } catch (Exception e) {
-            assertEquals( "column out of bounds" , e.getMessage());
-        }
-
-        try {
-            st.column_long(-1);
-            fail("Exception expected");
-        } catch (Exception e) {
-            assertEquals( "column out of bounds" , e.getMessage());
-        }
-    }
-
-    /**
-     * @throws Exception
-     * @tests {@link Stmt#column_double(int)}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "method test",
-        method = "column_double",
-        args = {int.class}
-    )
-    public void testColumn_double() throws Exception {
-        db.exec(createAllTypes, null);
-        db.exec(insertAllTypes, null);
-
-        Object columnObject  = null;
-        double doubleColumn = 0;
-        double actualVal = 23.2;
-        String selectStmt = "select DoubleVal from "+allTypesTable;
-
-        st = db.prepare(selectStmt);
-        st.step();
-        // select double value
-        doubleColumn = st.column_double(0);
-        assertNotNull(doubleColumn);
-
-        assertTrue("DOUBLE".equalsIgnoreCase(st.column_decltype(0)));
-        assertNotNull(doubleColumn);
-        assertEquals( actualVal, doubleColumn);
-
-        // Exception test
-        selectStmt = "select dateVal from "+allTypesTable;
-
-        st = db.prepare(selectStmt);
-        st.step();
-        // select double value
-        try {
-        st.column_double(0);
-        } catch (Exception e) {
-            //ok
-        }
-
-
-    }
-
-    public void testColumn_bytes() throws Exception {
-
-        db.exec("create table B(id integer primary key, val blob)",null);
-        db.exec("insert into B values(1, zeroblob(128))", null);
-        st = db.prepare("select val from B where id = 1");
-        assertTrue(st.step());
-        try {
-            st.column_bytes(0);
-        } catch (Exception e) {
-            assertEquals("unsupported", e.getMessage());
-        }
-    }
-
-    /**
-     * @throws Exception
-     * @tests {@link Stmt#column_string(int)}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "method test",
-        method = "column_string",
-        args = {int.class}
-    )
-    public void testColumn_string() throws Exception {
-        db.exec(createAllTypes, null);
-        db.exec(insertAllTypes, null);
-
-        Object columnObject  = null;
-        String stringColumn = "";
-        String actualVal = "test string";
-        String selectStmt = "select charStr from "+allTypesTable;
-
-        st = db.prepare(selectStmt);
-        st.step();
-        // select string value
-        stringColumn = st.column_string(0);
-        assertNotNull(stringColumn);
-
-        assertTrue("CHAR(20)".equalsIgnoreCase(st.column_decltype(0)));
-        assertNotNull(stringColumn);
-        assertEquals( actualVal, stringColumn);
-
-        // Exception test
-        selectStmt = "select DoubleVal from "+allTypesTable;
-
-        st = db.prepare(selectStmt);
-        st.step();
-        // select double value
-        try {
-        st.column_string(0);
-        } catch (Exception e) {
-            //ok
-        }
-    }
-
-    public void testColumn_type() throws Exception {
-        db.exec(createAllTypes, null);
-        db.exec(insertAllTypes, null);
-        st = db.prepare("select * from " + allTypesTable);
-        st.step();
-
-        // Exception test
-        try {
-            st.column_type(100);
-        } catch (Exception e) {
-            // ok
-        }
-
-        /*
-        Dictionary
-
-        public static final int SQLITE_INTEGER = 1;
-        public static final int SQLITE_FLOAT = 2;
-        public static final int SQLITE_BLOB = 4;
-        public static final int SQLITE_NULL = 5;
-        public static final int SQLITE3_TEXT = 3;
-        public static final int SQLITE_NUMERIC = -1;
-        */
-
-        assertEquals(Constants.SQLITE3_TEXT, st.column_type(23)); // ok TEXT
-        assertEquals(Constants.SQLITE3_TEXT, st.column_type(13)); // CHAR(20)
-
-        assertEquals(Constants.SQLITE_FLOAT, st.column_type(8));
-        assertEquals(Constants.SQLITE_FLOAT, st.column_type(9));
-        assertEquals(Constants.SQLITE_FLOAT, st.column_type(10)); // FLOAT
-
-        for (int i = 0; i < 8; i++) {
-            assertEquals("Expected Integer at position " + i,
-                    Constants.SQLITE_INTEGER, st.column_type(i));
-        }
-
-        assertEquals(Constants.SQLITE_NULL, st.column_type(28));
-        assertEquals(Constants.SQLITE_NULL, st.column_type(29));
-
-        // Failing tests
-        assertTrue("INTEGER".equalsIgnoreCase(st.column_decltype(12)));
-        assertEquals(Constants.SQLITE_INTEGER, st.column_type(12));
-
-        assertTrue("FLOAT".equalsIgnoreCase(st.column_decltype(11)));
-        assertEquals(Constants.SQLITE_FLOAT, st.column_type(11)); // FLOAT ->
-                                                                  // got INTEGER
-        assertTrue("BLOB".equalsIgnoreCase(st.column_decltype(19)));
-        assertEquals(Constants.SQLITE_BLOB, st.column_type(19)); // Blob got
-                                                                 // INTEGER
-
-    }
-
-    /**
-     * @throws Exception
-     * @tests {@link Stmt#column_count() )}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "method test",
-        method = "column_count",
-        args = {}
-    )
-    @KnownFailure("Wrong value is returned in case of a prepared statment to "+
-            "which a '*' bound ")
-    public void testColumn_count() throws Exception {
-
-        String selectStmt = "select * from "+DatabaseCreator.SIMPLE_TABLE1;
-        st = db.prepare(selectStmt);
-
-        assertEquals(3, st.column_count());
-
-        st.step();
-        int columnCount = st.column_count();
-        assertNotNull(columnCount);
-        assertEquals( 3, columnCount);
-
-        // actual prepared statement
-        selectStmt = "select ? from "+DatabaseCreator.SIMPLE_TABLE1;
-        st = db.prepare(selectStmt);
-
-        assertEquals(3, st.column_count());
-
-        st.bind(1, "*");
-        st.step();
-        columnCount = st.column_count();
-        assertNotNull(columnCount);
-        assertEquals( 3, columnCount);
-
-    }
-
-    /**
-     * @throws Exception
-     * @tests {@link Stmt#column(int) )}
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "method test",
-        method = "column",
-        args = {int.class}
-    )
-    public void testColumn() throws Exception {
-        Object columnObject  = null;
-        int columnObjectCastFromLong;
-        int intColumn = 0;
-        try {
-            String selectStmt = "select * from "+DatabaseCreator.SIMPLE_TABLE1;
-            TableResult res = db.get_table(selectStmt);
-            st = db.prepare(selectStmt);
-            st.step();
-            columnObject = st.column(1);
-            intColumn = st.column_int(1);
-            assertNotNull(intColumn);
-            assertTrue("Integer".equalsIgnoreCase(st.column_decltype(1)));
-            int stSpeed = Integer.parseInt(columnObject.toString());
-            assertNotNull(stSpeed);
-            assertEquals( intColumn, stSpeed);
-        } catch (Exception e) {
-            fail("Error in test setup : " + e.getMessage());
-            e.printStackTrace();
-        }
-
-        try {
-            assertNotNull(columnObject);
-            int dummy = ((Integer) columnObject).intValue();
-            fail("Cast to Integer should fail");
-        } catch (ClassCastException e) {
-            assertEquals("java.lang.Long", e.getMessage());
-        }
-
-        try {
-            st.column(4);
-            fail("Exception expected");
-        } catch (Exception e) {
-            assertEquals( "column out of bounds" , e.getMessage());
-        }
-
-        try {
-            st.column(-1);
-            fail("Exception expected");
-        } catch (Exception e) {
-            assertEquals( "column out of bounds" , e.getMessage());
-        }
-    }
-
-    public void testColumn_table_name() {
-        try {
-            st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1);
-            String name = st.column_table_name(1);
-           fail("Function is now supported.");
-        } catch (Exception e) {
-            assertEquals("unsupported", e.getMessage());
-        }
-    }
-
-    public void testColumn_database_name() {
-        try {
-            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
-                    + " values (:one,:two,:three)");
-            String name = st.column_database_name(1);
-           fail("Function is now supported.");
-        } catch (Exception e) {
-            assertEquals("unsupported", e.getMessage());
-        }
-
-    }
-
-    /**
-     * @throws Exception
-     * @tests {@link Stmt#column_decltype(int)}
-     */
-    @TestTargetNew(
-        level = TestLevel.SUFFICIENT,
-        notes = "method test",
-        method = "column_decltype",
-        args = {int.class}
-    )
-    public void testColumn_decltype() throws Exception {
-        db.exec(createAllTypes, null);
-        db.exec(insertAllTypes, null);
-        st = db.prepare("select * from " + allTypesTable);
-        st.step();
-
-        // Exception test
-        try {
-            st.column_decltype(100);
-        } catch (Exception e) {
-            // ok
-        }
-
-        assertTrue(st.column_decltype(0), "BOOLEAN".equalsIgnoreCase(st
-                .column_decltype(0)));
-        assertTrue(st.column_decltype(1), "INT".equalsIgnoreCase(st
-                .column_decltype(1)));
-        assertTrue(st.column_decltype(2), "LONG".equalsIgnoreCase(st
-                .column_decltype(2)));
-        assertTrue(st.column_decltype(3), "BIGINT".equalsIgnoreCase(st
-                .column_decltype(3)));
-        assertTrue(st.column_decltype(4), "TINYINT".equalsIgnoreCase(st
-                .column_decltype(4)));
-        assertTrue(st.column_decltype(5), "SMALLINT".equalsIgnoreCase(st
-                .column_decltype(5)));
-        assertTrue(st.column_decltype(6), "MEDIUMINT".equalsIgnoreCase(st
-                .column_decltype(6)));
-        assertTrue(st.column_decltype(7), "INTEGER".equalsIgnoreCase(st
-                .column_decltype(7)));
-        assertTrue(st.column_decltype(8), "REAL".equalsIgnoreCase(st
-                .column_decltype(8)));
-        assertTrue(st.column_decltype(9), "DOUBLE".equalsIgnoreCase(st
-                .column_decltype(9)));
-        assertTrue(st.column_decltype(10), "FLOAT".equalsIgnoreCase(st
-                .column_decltype(10)));
-        assertTrue(st.column_decltype(11), "DECIMAL".equalsIgnoreCase(st
-                .column_decltype(11)));
-        assertTrue(st.column_decltype(12), "NUMERIC".equalsIgnoreCase(st
-                .column_decltype(12)));
-        assertTrue(st.column_decltype(13), "CHAR(20)".equalsIgnoreCase(st
-                .column_decltype(13)));
-
-        assertTrue(st.column_decltype(19), "BLOB".equalsIgnoreCase(st
-                .column_decltype(19)));
-
-        assertTrue(st.column_decltype(23), "TEXT".equalsIgnoreCase(st
-                .column_decltype(23)));
-        assertTrue(st.column_decltype(28), "URL".equalsIgnoreCase(st
-                .column_decltype(28)));
-        assertTrue(st.column_decltype(29), "URL".equalsIgnoreCase(st
-                .column_decltype(29)));
-    }
-
-    public void testColumn_origin_name() {
-        try {
-            st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1);
-            String name = st.column_origin_name(1);
-           fail("Function is now supported.");
-        } catch (Exception e) {
-            assertEquals("unsupported", e.getMessage());
-        }
-    }
-}