From adc854b798c1cfe3bfd4c27d68d5cee38ca617da Mon Sep 17 00:00:00 2001 From: The Android Open Source Project Date: Tue, 3 Mar 2009 19:28:47 -0800 Subject: auto import from //depot/cupcake/@135843 --- .../test/java/tests/SQLite/AbstractSqlTest.java | 244 +++++++++++++++++++++ 1 file changed, 244 insertions(+) create mode 100644 sql/src/test/java/tests/SQLite/AbstractSqlTest.java (limited to 'sql/src/test/java/tests/SQLite/AbstractSqlTest.java') diff --git a/sql/src/test/java/tests/SQLite/AbstractSqlTest.java b/sql/src/test/java/tests/SQLite/AbstractSqlTest.java new file mode 100644 index 0000000..0c7fa61 --- /dev/null +++ b/sql/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(); + +} -- cgit v1.1