Update tests to run against commercial builds of SQLCipher

Author: developernotes

app/build.gradle

@@ -25,18 +25,12 @@ dependencies {
   //implementation files('libs/sqlcipher.jar')
 
   // For testing local AAR packages:
-  implementation (name: 'android-database-sqlcipher-4.3.0-release', ext: 'aar')
+  //implementation (name: 'android-database-sqlcipher-4.3.0-release', ext: 'aar')
 
 
   // For testing on remote AAR references:
-  //implementation files('libs/android-database-sqlcipher-4.3.0-release.aar')
-  //implementation 'net.zetetic:android-database-sqlcipher:4.3.0@aar'
-
+  implementation 'net.zetetic:android-database-sqlcipher:4.3.0@aar'
   implementation "androidx.sqlite:sqlite:2.0.1"
   implementation "androidx.room:room-runtime:2.1.0"
   annotationProcessor "androidx.room:room-compiler:2.1.0"
-
-
-  // For testing on remote AAR references:
-  //implementation 'net.zetetic:android-database-sqlcipher:4.2.0@aar'
 }

app/src/main/java/net/zetetic/ZeteticApplication.java

@@ -92,7 +92,7 @@ public void deleteDatabaseFileAndSiblings(String databaseName) {
     }
   }
 
-  private SQLiteDatabaseHook wrapHook(final SQLiteDatabaseHook hook) {
+  public SQLiteDatabaseHook wrapHook(final SQLiteDatabaseHook hook) {
     if (hook == null)
     {
       return keyHook;

app/src/main/java/net/zetetic/tests/DefaultCursorWindowAllocationTest.java

@@ -0,0 +1,47 @@
+package net.zetetic.tests;
+
+import net.sqlcipher.Cursor;
+import net.sqlcipher.database.SQLiteDatabase;
+
+public class DefaultCursorWindowAllocationTest extends SQLCipherTest {
+  @Override
+  public boolean execute(SQLiteDatabase database) {
+    try {
+      int rowCount = 0;
+      int rows = 10000;
+      //final int dataSize = 2048;
+      final int dataSize = 16384;
+      buildDatabase(database, rows, 1, new RowColumnValueBuilder() {
+        @Override
+        public Object buildRowColumnValue(String[] columns, int row, int column) {
+          return generateRandomByteArray(dataSize);
+        }
+      });
+      rows = 1;
+      Cursor cursor = database.rawQuery("SELECT count(length(a)) FROM t1;", new Object[]{});
+      if(cursor == null) return false;
+      while(cursor.moveToNext()){
+        //byte[] data = cursor.getBlob(0);
+        int size = cursor.getInt(0);
+        cursor.close();
+//        if(data.length != dataSize) {
+//          cursor.close();
+//          return false;
+//        }
+        rowCount++;
+      }
+      cursor.close();
+      return rowCount == rows;
+    } catch (Exception e){
+      String message = String.format("Error:%s", e.getMessage());
+      log(message);
+      setMessage(message);
+      return false;
+    }
+  }
+
+  @Override
+  public String getName() {
+    return null;
+  }
+}

app/src/main/java/net/zetetic/tests/DeleteTableWithNullWhereArgsTest.java

@@ -0,0 +1,20 @@
+package net.zetetic.tests;
+
+import net.sqlcipher.database.SQLiteDatabase;
+
+public class DeleteTableWithNullWhereArgsTest extends SQLCipherTest {
+  @Override
+  public boolean execute(SQLiteDatabase database) {
+    String[] args = null;
+    int rowsDeleted = 0;
+    database.rawExecSQL("create table t1(a,b);");
+    database.execSQL("insert into t1(a,b) values(?, ?);", new Object[]{1, 2});
+    rowsDeleted = database.delete("t1", "a = 1", args);
+    return rowsDeleted == 1;
+  }
+
+  @Override
+  public String getName() {
+    return "Delete Table Test";
+  }
+}

app/src/main/java/net/zetetic/tests/JavaClientLibraryVersionTest.java

@@ -4,7 +4,7 @@
 
 public class JavaClientLibraryVersionTest extends SQLCipherTest {
 
-  String expectedClientLibraryVersion = "4.2.0";
+  String expectedClientLibraryVersion = "4.3.0";
 
   @Override
   public boolean execute(SQLiteDatabase database) {

app/src/main/java/net/zetetic/tests/PragmaCipherVersionTest.java

@@ -6,7 +6,7 @@
 
 public class PragmaCipherVersionTest extends SQLCipherTest {
 
-    private final String CURRENT_CIPHER_VERSION = "4.2.0";
+    private final String CURRENT_CIPHER_VERSION = "4.3.0";
 
     @Override
     public boolean execute(SQLiteDatabase database) {

app/src/main/java/net/zetetic/tests/SQLCipherTest.java

@@ -115,6 +115,7 @@ protected void buildDatabase(SQLiteDatabase database, int rows, int columns, Row
         String insert = String.format(insertTemplate, insertBuilder.toString());
         database.execSQL("DROP TABLE IF EXISTS t1;");
         database.execSQL(create);
+        database.execSQL("BEGIN;");
         String[] names = columnNames.toArray(new String[0]);
         for (int row = 0; row < rows; row++) {
             Object[] insertArgs = new Object[columns];
@@ -123,6 +124,7 @@ protected void buildDatabase(SQLiteDatabase database, int rows, int columns, Row
             }
             database.execSQL(insert, insertArgs);
         }
+        database.execSQL("COMMIT;");
         Log.i(TAG, String.format("Database built with %d columns, %d rows", columns, rows));
     }
 

app/src/main/java/net/zetetic/tests/SimpleQueryTest.java

@@ -0,0 +1,40 @@
+package net.zetetic.tests;
+
+import net.sqlcipher.Cursor;
+import net.sqlcipher.database.SQLiteDatabase;
+import net.sqlcipher.database.SQLiteStatement;
+
+import java.util.UUID;
+
+public class SimpleQueryTest extends SQLCipherTest {
+  @Override
+  public boolean execute(SQLiteDatabase database) {
+    database.execSQL("create table t1(a,b);");
+    database.execSQL("insert into t1(a, b) values(?, ?);",
+        new Object[]{UUID.randomUUID().toString(), "foo"});
+    database.execSQL("insert into t1(a, b) values(?, ?);",
+        new Object[]{UUID.randomUUID().toString(), "bar"});
+    int count = 0;
+    Cursor cursor = database.rawQuery("select * from t1 where a = ?1 or ?1 = -1;",
+        new Object[]{-1});
+    if(cursor != null){
+      while (cursor.moveToNext()){
+        count++;
+      }
+      cursor.close();
+    }
+
+//    Works
+//    SQLiteStatement statement = database.compileStatement("select count(*) from t1 where a = ?1 or ?1 = -1;");
+//    statement.
+//    statement.bindLong(1, -1);
+//    long count = statement.simpleQueryForLong();
+//    statement.close();
+    return count == 2;
+  }
+
+  @Override
+  public String getName() {
+    return "Simple Query Test";
+  }
+}

app/src/main/java/net/zetetic/tests/TestSuiteRunner.java

@@ -71,6 +71,10 @@ private void runSuite() {
 
   private List<SQLCipherTest> getTestsToRun() {
     List<SQLCipherTest> tests = new ArrayList<>();
+    tests.add(new SimpleQueryTest());
+    //tests.add(new DefaultCursorWindowAllocationTest());
+
+    //tests.add(new DeleteTableWithNullWhereArgsTest());
     tests.add(new LoopingInsertTest());
     tests.add(new FIPSTest());
     tests.add(new PragmaCipherVersionTest());

app/src/main/java/net/zetetic/tests/support/DecryptedRoomTest.java

@@ -0,0 +1,133 @@
+package net.zetetic.tests.support;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+
+import androidx.annotation.NonNull;
+import androidx.room.Dao;
+import androidx.room.Database;
+import androidx.room.Entity;
+import androidx.room.ForeignKey;
+import androidx.room.Index;
+import androidx.room.Insert;
+import androidx.room.PrimaryKey;
+import androidx.room.Query;
+import androidx.room.Room;
+import androidx.room.RoomDatabase;
+
+import net.zetetic.ZeteticApplication;
+import net.zetetic.tests.TestResult;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+public class DecryptedRoomTest implements ISupportTest {
+  private static final String DB_NAME = "room.db";
+
+  private final Activity activity;
+
+  @Entity()
+  public static class ParentEntity {
+    @PrimaryKey(autoGenerate = true) long id;
+    int intValue;
+    float floatValue;
+    double doubleValue;
+    char charValue;
+    boolean boolValue;
+  }
+
+  @Entity(foreignKeys = @ForeignKey(entity = ParentEntity.class,
+      parentColumns = "id", childColumns = "parentId", onDelete = ForeignKey.CASCADE),
+      indices = @Index("parentId"))
+  public static class ChildEntity {
+    @PrimaryKey @NonNull String uuid;
+    String stringValue;
+    long parentId;
+  }
+
+  @Dao
+  public static abstract class TestDao {
+    @Query("SELECT * FROM ChildEntity WHERE parentId = :parentId or :parentId = -1")
+    abstract List<ChildEntity> getAllChildrenForParent(long parentId);
+
+    @Query("SELECT * FROM ChildEntity")
+    abstract List<ChildEntity> getAllChildren();
+
+    @Insert
+    abstract void insert(List<ChildEntity> entities);
+
+    @Insert
+    abstract long insert(ParentEntity entity);
+  }
+
+  @Database(entities = {ParentEntity.class, ChildEntity.class}, version = 1)
+  public static abstract class TestDatabase extends RoomDatabase {
+    abstract TestDao testDao();
+  }
+
+  public DecryptedRoomTest(Activity activity) {
+    this.activity = activity;
+  }
+
+  @SuppressLint("DefaultLocale")
+  public TestResult run() {
+    File dbFile = ZeteticApplication.getInstance().getDatabasePath(DB_NAME);
+
+    if (dbFile.exists()){
+      dbFile.delete();
+    }
+
+    final TestResult result = new TestResult(getName(), false);
+    final TestDatabase room = Room.databaseBuilder(activity, TestDatabase.class, DB_NAME)
+        .build();
+    ParentEntity parent = new ParentEntity();
+
+    parent.boolValue = true;
+    parent.charValue = 'x';
+    parent.intValue = 1337;
+    parent.doubleValue = 3.14159;
+    parent.floatValue = 2.71828f;
+    parent.id = room.testDao().insert(parent);
+
+    result.setResult(true);
+
+    ChildEntity firstChild = new ChildEntity();
+
+    firstChild.uuid = UUID.randomUUID().toString();
+    firstChild.stringValue = "Um, hi!";
+    firstChild.parentId = parent.id;
+
+    ChildEntity secondChild = new ChildEntity();
+
+    secondChild.uuid = UUID.randomUUID().toString();
+    secondChild.stringValue = "And now for something completely different";
+    secondChild.parentId = parent.id;
+
+    List<ChildEntity> children = new ArrayList<>();
+
+    children.add(firstChild);
+    children.add(secondChild);
+
+    room.testDao().insert(children);
+
+    List<ChildEntity> allChildren = room.testDao().getAllChildren();
+    List<ChildEntity> allChildrenNegativeOne = room.testDao().getAllChildrenForParent(-1);
+    List<ChildEntity> other = room.testDao().getAllChildrenForParent( parent.id);
+
+    //the query should have returned both the list with same sizes here
+    if (allChildren.size() != allChildrenNegativeOne.size()) {
+      result.setResult(false);
+      result.setMessage(String.format("expected all children, found %d from entity and %d from main query", allChildrenNegativeOne.size(), allChildren.size()));
+      return result;
+    }
+
+    return result;
+  }
+
+  @Override
+  public String getName() {
+    return "Decrypted Room Test";
+  }
+}