| /* |
| * 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 android.database.sqlite; |
| |
| import java.io.File; |
| import java.sql.Connection; |
| import java.sql.DriverManager; |
| import java.sql.ResultSet; |
| import java.sql.SQLException; |
| import java.sql.Statement; |
| |
| import junit.framework.TestCase; |
| import android.test.suitebuilder.annotation.MediumTest; |
| |
| /** |
| * Tests for the most commonly used methods of sql like creating a connection, |
| * inserting, selecting, updating. |
| */ |
| public abstract class AbstractJDBCDriverTest extends TestCase { |
| |
| @MediumTest |
| public void testJDBCDriver() throws Exception { |
| Connection firstConnection = null; |
| Connection secondConnection = null; |
| File dbFile = getDbFile(); |
| String connectionURL = getConnectionURL(); |
| Statement firstStmt = null; |
| Statement secondStmt = null; |
| try { |
| Class.forName(getJDBCDriverClassName()); |
| firstConnection = DriverManager.getConnection(connectionURL); |
| secondConnection = DriverManager.getConnection(connectionURL); |
| |
| String[] ones = {"hello!", "goodbye"}; |
| short[] twos = {10, 20}; |
| String[] onesUpdated = new String[ones.length]; |
| for (int i = 0; i < ones.length; i++) { |
| onesUpdated[i] = ones[i] + twos[i]; |
| } |
| firstStmt = firstConnection.createStatement(); |
| firstStmt.execute("create table tbl1(one varchar(10), two smallint)"); |
| secondStmt = secondConnection.createStatement(); |
| |
| autoCommitInsertSelectTest(firstStmt, ones, twos); |
| updateSelectCommitSelectTest(firstStmt, secondStmt, ones, onesUpdated, twos); |
| updateSelectRollbackSelectTest(firstStmt, secondStmt, onesUpdated, ones, twos); |
| } finally { |
| closeConnections(firstConnection, secondConnection, dbFile, firstStmt, secondStmt); |
| } |
| } |
| |
| protected abstract String getJDBCDriverClassName(); |
| protected abstract String getConnectionURL(); |
| protected abstract File getDbFile(); |
| |
| private void closeConnections(Connection firstConnection, Connection secondConnection, |
| File dbFile, Statement firstStmt, Statement secondStmt) { |
| String failText = null; |
| try { |
| if (firstStmt != null) { |
| firstStmt.execute("drop table tbl1"); |
| } |
| } catch (SQLException e) { |
| failText = e.getLocalizedMessage(); |
| } |
| try { |
| if (firstStmt != null) { |
| firstStmt.close(); |
| } |
| } catch (SQLException e) { |
| failText = e.getLocalizedMessage(); |
| } |
| try { |
| if (firstConnection != null) { |
| firstConnection.close(); |
| } |
| } catch (SQLException e) { |
| failText = e.getLocalizedMessage(); |
| } |
| try { |
| if (secondStmt != null) { |
| secondStmt.close(); |
| } |
| } catch (SQLException e) { |
| failText = e.getLocalizedMessage(); |
| } |
| try { |
| if (secondConnection != null) { |
| secondConnection.close(); |
| } |
| } catch (SQLException e) { |
| failText = e.getLocalizedMessage(); |
| } |
| dbFile.delete(); |
| assertNull(failText, failText); |
| } |
| |
| /** |
| * Inserts the values from 'ones' with the values from 'twos' into 'tbl1' |
| * @param stmt the statement to use for the inserts. |
| * @param ones the string values to insert into tbl1. |
| * @param twos the corresponding numerical values to insert into tbl1. |
| * @throws SQLException in case of a problem during insert. |
| */ |
| private void autoCommitInsertSelectTest(Statement stmt, String[] ones, |
| short[] twos) throws SQLException { |
| for (int i = 0; i < ones.length; i++) { |
| stmt.execute("insert into tbl1 values('" + ones[i] + "'," + twos[i] |
| + ")"); |
| } |
| assertAllFromTbl1(stmt, ones, twos); |
| } |
| |
| /** |
| * Asserts that all values that where added to tbl1 are actually in tbl1. |
| * @param stmt the statement to use for the select. |
| * @param ones the string values that where added. |
| * @param twos the numerical values that where added. |
| * @throws SQLException in case of a problem during select. |
| */ |
| 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")); |
| } |
| assertEquals(i, ones.length); |
| } |
| |
| /** |
| * Tests the results of an update followed bz a select on a diffrent statement. |
| * After that the first statement commits its update. and now the second |
| * statement should also be able to see the changed values in a select. |
| * @param firstStmt the statement to use for the update and commit. |
| * @param secondStmt the statement that should be used to check if the commit works |
| * @param ones the original string values. |
| * @param onesUpdated the updated string values. |
| * @param twos the numerical values. |
| * @throws SQLException in case of a problem during any of the executed commands. |
| */ |
| private void updateSelectCommitSelectTest(Statement firstStmt, |
| Statement secondStmt, String[] ones, String[] onesUpdated, |
| short[] twos) throws SQLException { |
| firstStmt.getConnection().setAutoCommit(false); |
| try { |
| updateOnes(firstStmt, onesUpdated, twos); |
| assertAllFromTbl1(secondStmt, ones, twos); |
| firstStmt.getConnection().commit(); |
| assertAllFromTbl1(secondStmt, onesUpdated, twos); |
| } finally { |
| firstStmt.getConnection().setAutoCommit(true); |
| } |
| } |
| |
| /** |
| * Tests if an update followed by a select works. After that a rollback will |
| * be made and again a select should show that the rollback worked. |
| * @param firstStmt the statement to use for the update and the rollback |
| * @param secondStmt the statement to use for checking if the rollback worked as intended. |
| * @param ones the original string values. |
| * @param onesUpdated the updated string values. |
| * @param twos the nomerical values. |
| * @throws SQLException in case of a problem during any command. |
| */ |
| private void updateSelectRollbackSelectTest(Statement firstStmt, |
| Statement secondStmt, String[] ones, String[] onesUpdated, |
| short[] twos) throws SQLException { |
| firstStmt.getConnection().setAutoCommit(false); |
| try { |
| updateOnes(firstStmt, onesUpdated, twos); |
| assertAllFromTbl1(secondStmt, ones, twos); |
| firstStmt.getConnection().rollback(); |
| assertAllFromTbl1(secondStmt, ones, twos); |
| } finally { |
| firstStmt.getConnection().setAutoCommit(true); |
| } |
| } |
| |
| /** |
| * updates the sring values. the original values are stored in 'ones' |
| * and the updated values in 'ones_updated' |
| * @param stmt the statement to use for the update. |
| * @param onesUpdated the new string values. |
| * @param twos the numerical values. |
| * @throws SQLException in case of a problem during update. |
| */ |
| private void updateOnes(Statement stmt, String[] onesUpdated, short[] twos) |
| throws SQLException { |
| for (int i = 0; i < onesUpdated.length; i++) { |
| stmt.execute("UPDATE tbl1 SET one = '" + onesUpdated[i] |
| + "' WHERE two = " + twos[i]); |
| } |
| } |
| } |