Merge pull request #9 from brodybits/cb-test-custom-corruption-handler

Test changes for custom database corruption error handler

Author: developernotes

src/main/java/net/zetetic/tests/ClosedDatabaseTest.java

@@ -7,6 +7,7 @@
 
 import java.util.Locale;
 
+import net.sqlcipher.DatabaseErrorHandler;
 import net.sqlcipher.database.SQLiteDatabase;
 import net.sqlcipher.database.SQLiteException;
 import net.zetetic.ZeteticApplication;
@@ -29,12 +30,12 @@ public TestResult run() {
     @Override
     public boolean execute(SQLiteDatabase null_database_ignored) {
 
-        File testDatabasePath = ZeteticApplication.getInstance().getDatabasePath("closed-db-test.db");
+        File closedDatabasePath = ZeteticApplication.getInstance().getDatabasePath("closed-db-test.db");
 
         boolean status = false;
 
         try {
-            SQLiteDatabase database = SQLiteDatabase.openOrCreateDatabase(testDatabasePath, "", null);
+            SQLiteDatabase database = SQLiteDatabase.openOrCreateDatabase(closedDatabasePath, "", null);
 
             database.close();
 
@@ -45,7 +46,58 @@ public boolean execute(SQLiteDatabase null_database_ignored) {
             return false;
         }
         finally {
-            testDatabasePath.delete();
+            closedDatabasePath.delete();
+        }
+
+        if (!status) return false;
+
+        status = false;
+
+        final File corruptDatabase = ZeteticApplication.getInstance().getDatabasePath("corrupt.db");
+
+        // run closed database tests again in custom DatabaseErrorHandler:
+        try {
+            ZeteticApplication.getInstance().extractAssetToDatabaseDirectory("corrupt.db");
+
+            // ugly trick from: http://stackoverflow.com/questions/5977735/setting-outer-variable-from-anonymous-inner-class
+            final boolean[] inner_status_slot = new boolean[1];
+
+            // on a database object that was NEVER actually opened (due to a corrupt database file):
+            SQLiteDatabase database = SQLiteDatabase.openDatabase(corruptDatabase.getPath(), "", null, SQLiteDatabase.CREATE_IF_NECESSARY, null, new DatabaseErrorHandler() {
+                @Override
+                public void onCorruption(SQLiteDatabase db) {
+                    try {
+                        inner_status_slot[0] = execute_closed_database_tests(db);
+                    } catch (Exception ex) {
+                        // Uncaught exception (not expected):
+                        Log.e(TAG, "UNEXPECTED EXCEPTION", ex);
+                    }
+
+                    try {
+                        corruptDatabase.delete();
+                    } catch (Exception ex) {
+                        // Uncaught exception (not expected):
+                        Log.e(TAG, "UNEXPECTED EXCEPTION", ex);
+                    }
+                }
+            });
+
+            status = inner_status_slot[0];
+
+            // NOTE: database not expected to be null, but double-check:
+            if (database == null) {
+                Log.e(TAG, "ERROR: got null database object");
+                return false;
+            }
+
+            database.close();
+        } catch (Exception ex) {
+            // Uncaught exception (not expected):
+            Log.e(TAG, "UNEXPECTED EXCEPTION", ex);
+            return false;
+        }
+        finally {
+            corruptDatabase.delete();
         }
 
         return status;
@@ -257,9 +309,8 @@ boolean execute_closed_database_tests(SQLiteDatabase database) {
                 Log.v(ZeteticApplication.TAG, "SQLiteDatabase.markTableSyncable(String, String) did throw exception on closed database OK", e);
             }
 
-            // TBD SQLiteDatabase.markTableSyncable(String, String, String) does NOT throw exception on closed database:
             try {
-                // NOTE: does not (yet) throw an exception on a closed database:
+                // [should] throw an exception on a closed database:
                 database.markTableSyncable("aa", "bb", "cc");
 
                 // ...
@@ -297,6 +348,10 @@ boolean execute_closed_database_tests(SQLiteDatabase database) {
             database.setLockingEnabled(false);
             database.setLockingEnabled(true);
 
+            database.inTransaction();
+            database.isDbLockedByCurrentThread();
+            database.isDbLockedByOtherThreads();
+
             database.close();
 
             database.isReadOnly();

src/main/java/net/zetetic/tests/CorruptDatabaseTest.java

@@ -5,6 +5,7 @@
 import android.database.Cursor;
 
 import net.sqlcipher.database.SQLiteDatabase;
+import net.sqlcipher.database.SQLiteDatabaseCorruptException;
 
 import net.zetetic.ZeteticApplication;
 
@@ -36,13 +37,39 @@ public boolean execute(SQLiteDatabase null_database_ignored) {
 
             SQLiteDatabase database = SQLiteDatabase.openOrCreateDatabase(unencryptedDatabase, "", null);
 
-            // NOTE: database not expected to be null, but check:
+            // NOTE: database not expected to be null, but double-check:
             if (database == null) {
                 Log.e(TAG, "ERROR: got null database object");
                 return false;
             }
 
-            database.close();
+            // *Should* have been recovered:
+            Cursor cursor = database.rawQuery("select * from sqlite_master;", null);
+
+            if (cursor == null) {
+                Log.e(TAG, "NOT EXPECTED: database.rawQuery() returned null cursor");
+                return false;
+            }
+
+            // *Should* corrupt the database file that is already open:
+            ZeteticApplication.getInstance().extractAssetToDatabaseDirectory("corrupt.db");
+
+            try {
+                // Attempt to write to corrupt database file *should* fail:
+                database.execSQL("CREATE TABLE t1(a,b);");
+
+                // NOT EXPECTED to get here:
+                Log.e(TAG, "NOT EXPECTED: CREATE TABLE succeeded ");
+                return false;
+            } catch (SQLiteDatabaseCorruptException ex) {
+                Log.v(TAG, "Caught SQLiteDatabaseCorruptException as expected OK");
+            }
+
+            // *Expected* to be closed now
+            if (database.isOpen()) {
+                Log.e(TAG, "NOT EXPECTED: database is still open");
+                return false;
+            }
 
             return true;
         } catch (Exception ex) {