merge more modules into luni

1 files changed, 1250 insertions, 0 deletions

diff --git a/luni/src/test/java/tests/SQLite/StmtTest.java b/luni/src/test/java/tests/SQLite/StmtTest.java
new file mode 100644
index 0000000..7a37154
--- /dev/null
+++ b/luni/src/test/java/tests/SQLite/StmtTest.java
@@ -0,0 +1,1250 @@
+/*
+ * 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#finalize()}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "method test",
+        method = "finalize",
+        args = {}
+    )
+    public void testFinalize() {
+        
+    }
+
+    /**
+     * @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());
+        }
+
+    }
+    
+    /**
+     * @tests {@link Stmt#bind_zeroblob(int, int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "bind_zeroblob",
+        args = {int.class, int.class}
+    )
+    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
+        }
+        
+        
+    }
+
+    /**
+     * @throws Exception 
+     * @tests {@link Stmt#column_bytes(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "column_bytes",
+        args = {int.class}
+    )
+    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());
+        }
+    }
+
+    /**
+     * @tests {@link Stmt#column_table_name(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "column_table_name",
+        args = {int.class}
+    )
+    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());
+        }
+    }
+
+    /**
+     * @tests {@link Stmt#column_database_name(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "column_database_name",
+        args = {int.class}
+    )
+    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)));
+    }
+ 
+    /**
+     * @tests {@link Stmt#column_origin_name(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "column_origin_name",
+        args = {int.class}
+    )
+    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());
+        }
+    }
+}