merge more modules into luni

1 files changed, 244 insertions, 0 deletions

diff --git a/luni/src/test/java/tests/SQLite/AbstractSqlTest.java b/luni/src/test/java/tests/SQLite/AbstractSqlTest.java
new file mode 100644
index 0000000..0c7fa61
--- /dev/null
+++ b/luni/src/test/java/tests/SQLite/AbstractSqlTest.java
@@ -0,0 +1,244 @@
+/*
+ * Copyright (C) 2007 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.Callback;
+import SQLite.Database;
+import SQLite.Exception;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+
+import junit.framework.TestCase;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+
+/**
+ * This class provides SQL unit test, which can be used by subclasses eg. to
+ * test JDBC drivers.
+ */
+@TestTargetClass(Database.class)
+abstract class AbstractSqlTest extends TestCase {
+
+    /**
+     * The first connection.
+     */
+    private Connection firstConnection;
+
+    /**
+     * The second connection.
+     */
+    private Connection secondConnection;
+    
+    /**
+     * The statement from the first connection.
+     */
+    private Statement firstStmt;
+
+    /**
+     * The statement from the second connection.
+     */
+    private Statement secondStmt;
+
+    /**
+     * The values of the first column "one".
+     */
+    private final String[] ones = {"hello!", "goodbye"};
+
+    /**
+     * The values of the second column "two".
+     */
+    private final short[] twos = {10, 20};
+
+    /**
+     * The updated values of the first column "one".
+     */
+    private final String[] ones_updated;
+
+    /** Creates a new instance of this class */
+    public AbstractSqlTest() {
+        super();
+        ones_updated = new String[ones.length];
+        for (int i = 0; i < ones.length; i++) {
+            ones_updated[i] = ones[i] + twos[i];
+        }
+    }
+
+    /**
+     * Sets up a unit test, by creating two statements from two connections and
+     * creating a test table.
+     * 
+     * @exception SQLException if there is a problem accessing the database
+     * @throws Exception 
+     * @exception Exception may be thrown by subclasses
+     */
+    @Override
+    protected void setUp() throws InstantiationException,
+            IllegalAccessException, ClassNotFoundException, SQLException, Exception {
+        Class.forName(getDriverClassName()).newInstance();
+        firstConnection = DriverManager.getConnection(getConnectionURL());
+        firstConnection.setTransactionIsolation(getTransactionIsolation());
+        secondConnection = DriverManager.getConnection(getConnectionURL());
+        secondConnection.setTransactionIsolation(getTransactionIsolation());
+        firstStmt = firstConnection.createStatement();
+        firstStmt.execute("create table tbl1(one varchar(10), two smallint)");
+        secondStmt = secondConnection.createStatement();
+    }
+
+    /**
+     * Tears down a unit test, by setting the auto commit property of the first
+     * connection back to true, dropping the test table and closing the two
+     * connections.
+     */
+    @Override
+    protected void tearDown() throws SQLException {
+        firstStmt.close();
+        secondStmt.close();
+        firstConnection.setAutoCommit(true);
+        firstStmt = firstConnection.createStatement();
+        firstStmt.execute("drop table tbl1");
+        firstStmt.close();
+        firstConnection.close();
+        secondConnection.close();
+    }
+
+    /**
+     * Adds some rows to the test table and asserts that the rows can be
+     * retrieved again.
+     * 
+     * @throws SQLException if there is a problem accessing the database
+     */
+    private void autoCommitInsertSelect() throws SQLException {
+        firstStmt.getConnection().setAutoCommit(true);
+        for (int i = 0; i < ones.length; i++) {
+            firstStmt.execute("insert into tbl1 values('" + ones[i] + "',"
+                    + twos[i] + ")");
+        }
+        assertAllFromTbl1(firstStmt, ones, twos);
+    }
+
+    /**
+     * Asserts that the expected values can be selected from the test table.
+     * 
+     * @param stmt the statement to be used for the selection of the data
+     * @param ones the expected values of the column 'one'
+     * @param twos the expected values of the column 'two'
+     * @throws SQLException if there is a problem accessing the database
+     */
+    private void assertAllFromTbl1(Statement stmt, String[] ones, short[] twos)
+            throws SQLException {
+        ResultSet rs = stmt.executeQuery("select * from tbl1");
+        int i = 0;
+        for (; rs.next(); i++) {
+            assertTrue(i < ones.length);
+            assertEquals(ones[i], rs.getString("one"));
+            assertEquals(twos[i], rs.getShort("two"));
+        }
+        assertTrue(i == ones.length);
+    }
+    
+    @TestTargetNew(
+      level = TestLevel.PARTIAL_COMPLETE,
+      notes = "",
+      clazz = Database.class,
+      method = "exec",
+      args = {String.class, Callback.class}
+    )
+    public void testAutoCommitInsertSelect() throws SQLException{
+        autoCommitInsertSelect();
+    }
+    
+    /**
+     * Tests the following sequence after successful insertion of some test
+     * data: 
+     * - update data from connection one 
+     * - select data from connection two (-> should have the old values) 
+     * - commit data from connection one 
+     * - select data from connection two (-> should have the new values)
+     * 
+     * @throws SQLException if there is a problem accessing the database
+     */
+    @TestTargetNew(
+      level = TestLevel.PARTIAL_COMPLETE,
+      notes = "",
+      clazz = Database.class,
+      method = "exec",
+      args = {String.class, Callback.class}
+      )
+    public void testUpdateSelectCommitSelect() throws SQLException {
+        autoCommitInsertSelect();
+        firstStmt.getConnection().setAutoCommit(false);
+        updateOnes(firstStmt, ones_updated, twos);
+        assertAllFromTbl1(secondStmt, ones, twos);
+        firstStmt.getConnection().commit();
+        assertAllFromTbl1(secondStmt, ones_updated, twos);
+    }
+
+    /**
+     * Tests the following sequence after successful insertion of some test
+     * data: 
+     * - update data from connection one 
+     * - select data from connection two (-> should have the old values) 
+     * - rollback data from connection one 
+     * - select data from connection two (-> should still have the old values)
+     * 
+     * @throws SQLException if there is a problem accessing the database
+     */
+    @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            clazz = Database.class,
+            method = "exec",
+            args = {String.class, Callback.class}
+    )
+    public void testUpdateSelectRollbackSelect() throws SQLException {
+        autoCommitInsertSelect();
+        firstStmt.getConnection().setAutoCommit(false);
+        updateOnes(firstStmt, ones_updated, twos);
+        assertAllFromTbl1(secondStmt, ones, twos);
+        firstStmt.getConnection().rollback();
+        assertAllFromTbl1(secondStmt, ones, twos);
+    }
+
+    /**
+     * Updates the values in column 'one'
+     * @param stmt the statement to be used to update the data
+     * @param ones_updated the updated valus of column 'one'
+     * @param twos the reference values of column 'two'
+     * @throws SQLException if there is a problem accessing the database
+     */
+    private void updateOnes(Statement stmt, String[] ones_updated, short[] twos)
+            throws SQLException {
+        for (int i = 0; i < ones_updated.length; i++) {
+            stmt.execute("UPDATE tbl1 SET one = '" + ones_updated[i]
+                    + "' WHERE two = " + twos[i]);
+        }
+    }
+
+    protected abstract String getConnectionURL();
+    
+    protected abstract String getDriverClassName();
+    
+    protected abstract int getTransactionIsolation();
+
+}