Additional CursorWindowAllocation and data query size tests

developernotes · developernotes · commit bc0674705104 · 2018-06-28T10:34:43.000-05:00
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
diff --git a/app/libs/android-database-sqlcipher-3.5.9.aar b/app/libs/android-database-sqlcipher-3.5.9.aar
diff --git a/app/src/main/java/net/zetetic/tests/AccessDatabaseTest.java b/app/src/main/java/net/zetetic/tests/AccessDatabaseTest.java
@@ -0,0 +1,37 @@
+package net.zetetic.tests;
+
+import net.sqlcipher.Cursor;
+import net.sqlcipher.database.SQLiteDatabase;
+import net.zetetic.ZeteticApplication;
+
+import java.io.File;
+
+public class AccessDatabaseTest extends SQLCipherTest {
+  @Override
+  public boolean execute(SQLiteDatabase database) {
+    database.close();
+    try {
+      int rows = 0;
+      String filename = "encrypted.db";
+      ZeteticApplication.getInstance().extractAssetToDatabaseDirectory(filename);
+      File databasePath = ZeteticApplication.getInstance().getDatabasePath(filename);
+      database = SQLiteDatabase.openDatabase(databasePath.getAbsolutePath(), "test", null, SQLiteDatabase.OPEN_READWRITE);
+      if(database != null){
+        Cursor cursor = database.rawQuery("SELECT COUNT(*) FROM sqlite_master;", new Object[]{});
+        if(cursor != null){
+          cursor.moveToFirst();
+          rows = cursor.getInt(0);
+          cursor.close();
+        }
+      }
+      return rows > 0;
+    } catch (Exception e) {
+      return false;
+    }
+  }
+
+  @Override
+  public String getName() {
+    return "Access Database File Test";
+  }
+}
diff --git a/app/src/main/java/net/zetetic/tests/FixedCursorWindowAllocationTest.java b/app/src/main/java/net/zetetic/tests/FixedCursorWindowAllocationTest.java
@@ -0,0 +1,51 @@
+package net.zetetic.tests;
+
+import net.sqlcipher.Cursor;
+import net.sqlcipher.CursorWindow;
+import net.sqlcipher.CursorWindowAllocation;
+import net.sqlcipher.CustomCursorWindowAllocation;
+import net.sqlcipher.database.SQLiteDatabase;
+
+public class FixedCursorWindowAllocationTest extends SQLCipherTest {
+
+  @Override
+  public boolean execute(SQLiteDatabase database) {
+    try {
+      int rowCount = 0;
+      int rows = 100;
+      long allocationSize = 1024;
+      final int dataSize = 491;
+      CursorWindowAllocation fixedAllocation = new CustomCursorWindowAllocation(allocationSize, 0, allocationSize);
+      CursorWindow.setCursorWindowAllocation(fixedAllocation);
+      buildDatabase(database, rows, 1, new RowColumnValueBuilder() {
+        @Override
+        public Object buildRowColumnValue(String[] columns, int row, int column) {
+          return generateRandomByteArray(dataSize);
+        }
+      });
+
+      Cursor cursor = database.rawQuery("SELECT * FROM t1;", new Object[]{});
+      if(cursor == null) return false;
+      while(cursor.moveToNext()){
+        byte[] data = cursor.getBlob(0);
+        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 "Small Cursor Window Allocation Test";
+  }
+}
diff --git a/app/src/main/java/net/zetetic/tests/GrowingCursorWindowAllocationTest.java b/app/src/main/java/net/zetetic/tests/GrowingCursorWindowAllocationTest.java
@@ -0,0 +1,53 @@
+package net.zetetic.tests;
+
+import net.sqlcipher.Cursor;
+import net.sqlcipher.CursorWindow;
+import net.sqlcipher.CursorWindowAllocation;
+import net.sqlcipher.CustomCursorWindowAllocation;
+import net.sqlcipher.database.SQLiteDatabase;
+
+public class GrowingCursorWindowAllocationTest extends SQLCipherTest {
+  @Override
+  public boolean execute(SQLiteDatabase database) {
+    try {
+      int rowCount = 0;
+      int rows = 20000;
+      long intialAllocationSize = 128 * 1024;
+      long growthAllocationSize = 1024 * 1024;
+      long maxAllocationSize = 4 * 1024 * 1024;
+      final int dataSize = 2000;
+      CursorWindowAllocation fixedAllocation =
+          new CustomCursorWindowAllocation(intialAllocationSize, growthAllocationSize, maxAllocationSize);
+      CursorWindow.setCursorWindowAllocation(fixedAllocation);
+      buildDatabase(database, rows, 1, new RowColumnValueBuilder() {
+        @Override
+        public Object buildRowColumnValue(String[] columns, int row, int column) {
+          return generateRandomByteArray(dataSize);
+        }
+      });
+
+      Cursor cursor = database.rawQuery("SELECT * FROM t1;", new Object[]{});
+      if(cursor == null) return false;
+      while(cursor.moveToNext()){
+        byte[] data = cursor.getBlob(0);
+        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 "Growing Cursor Window Allocation Test";
+  }
+}
diff --git a/app/src/main/java/net/zetetic/tests/QueryDataSizeTest.java b/app/src/main/java/net/zetetic/tests/QueryDataSizeTest.java
@@ -0,0 +1,22 @@
+package net.zetetic.tests;
+
+import net.sqlcipher.database.SQLiteDatabase;
+import net.sqlcipher.database.SQLiteQueryStats;
+
+public class QueryDataSizeTest 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[]{generateRandomByteArray(256), generateRandomByteArray(256)});
+    database.execSQL("INSERT INTO t1(a,b) VALUES(?, ?);",
+        new Object[]{generateRandomByteArray(1024), generateRandomByteArray(64)});
+    SQLiteQueryStats result = database.getQueryStats("SELECT * FROM t1;", new Object[]{});
+    return result.getTotalQueryResultSize() > 0 && result.getLargestIndividualRowSize() > 0;
+  }
+
+  @Override
+  public String getName() {
+    return "Query Data Size Test";
+  }
+}
diff --git a/app/src/main/java/net/zetetic/tests/ReadWriteWriteAheadLoggingTest.java b/app/src/main/java/net/zetetic/tests/ReadWriteWriteAheadLoggingTest.java
@@ -0,0 +1,51 @@
+package net.zetetic.tests;
+
+import net.sqlcipher.Cursor;
+import net.sqlcipher.CursorWindow;
+import net.sqlcipher.database.SQLiteDatabase;
+
+public class ReadWriteWriteAheadLoggingTest extends SQLCipherTest {
+  @Override
+  public boolean execute(final SQLiteDatabase database) {
+
+    try {
+      final int[] a = new int[1];
+      final int[] b = new int[1];
+      database.setLockingEnabled(false);
+      boolean walEnabled = database.enableWriteAheadLogging();
+      if (!walEnabled) return false;
+
+      //database.execSQL("PRAGMA read_uncommitted = 1;");
+
+      database.execSQL("CREATE TABLE t1(a,b)");
+      database.rawQuery("INSERT INTO t1(a,b) VALUES(?,?);", new Object[]{1, 2});
+      database.beginTransaction();
+      //database.beginTransactionNonExclusive();
+      database.rawQuery("DELETE FROM t1 WHERE a = ?;", new Object[]{1});
+      Thread t = new Thread(new Runnable() {
+        @Override
+        public void run() {
+          Cursor cursor = database.rawQuery("SELECT COUNT(*) FROM t1 WHERE a = ?;", new Object[]{1});
+          if (cursor != null && cursor.moveToFirst()) {
+            a[0] = cursor.getInt(0);
+            b[0] = cursor.getInt(0);
+            log(String.format("Retrieved %d rows back", a[0]));
+          }
+        }
+      });
+      t.start();
+      t.join();
+      database.setTransactionSuccessful();
+      database.endTransaction();
+      //return a[0] == 1 && b[0] == 2;
+      return a[0] == 0 && b[0] == 0;
+    } catch (InterruptedException ex){
+      return false;
+    }
+  }
+
+  @Override
+  public String getName() {
+    return "Read/Write WAL Test";
+  }
+}
diff --git a/app/src/main/java/net/zetetic/tests/SQLCipherTest.java b/app/src/main/java/net/zetetic/tests/SQLCipherTest.java
@@ -125,6 +125,12 @@ protected void buildDatabase(SQLiteDatabase database, int rows, int columns, Row
         Log.i(TAG, String.format("Database built with %d columns, %d rows", columns, rows));
     }
 
+    protected byte[] generateRandomByteArray(int size) {
+        byte[] data = new byte[size];
+        random.nextBytes(data);
+        return data;
+    }
+
     protected void setUp(){};
     protected void tearDown(SQLiteDatabase database){};
     protected void createDatabasePreKey(SQLiteDatabase database){};
diff --git a/app/src/main/java/net/zetetic/tests/TestSuiteRunner.java b/app/src/main/java/net/zetetic/tests/TestSuiteRunner.java
@@ -6,8 +6,9 @@
 import android.util.Log;
 import android.view.WindowManager;
 
+import net.sqlcipher.CursorWindow;
+import net.sqlcipher.CursorWindowAllocation;
 import net.sqlcipher.database.SQLiteDatabase;
-import net.sqlcipher.database.SQLiteDatabaseHook;
 import net.zetetic.ZeteticApplication;
 
 import java.util.ArrayList;
@@ -50,8 +51,10 @@ protected void onPostExecute(Void aVoid) {
   private void runSuite() {
 
     SQLiteDatabase.loadLibs(ZeteticApplication.getInstance());
+    CursorWindowAllocation defaultAllocation = CursorWindow.getCursorWindowAllocation();
     for (SQLCipherTest test : getTestsToRun()) {
       try {
+        CursorWindow.setCursorWindowAllocation(defaultAllocation);
         Log.i(ZeteticApplication.TAG, "Running test:" + test.getName());
         TestResult result = test.run();
         publishProgress(result);
@@ -60,11 +63,18 @@ private void runSuite() {
         Log.i(ZeteticApplication.TAG, e.toString());
         publishProgress(new TestResult(test.getName(), false, e.toString()));
       }
+      finally {
+        CursorWindow.setCursorWindowAllocation(defaultAllocation);
+      }
     }
   }
 
   private List<SQLCipherTest> getTestsToRun() {
     List<SQLCipherTest> tests = new ArrayList<>();
+    tests.add(new QueryDataSizeTest());
+    tests.add(new FixedCursorWindowAllocationTest());
+    tests.add(new GrowingCursorWindowAllocationTest());
+    tests.add(new ReadWriteWriteAheadLoggingTest());
     tests.add(new SQLiteOpenHelperEnableWriteAheadLogBeforeGetDatabaseTest());
     tests.add(new SQLiteOpenHelperEnableWriteAheadLogAfterGetDatabaseTest());
     tests.add(new SQLiteOpenHelperGetNameTest());
@@ -83,7 +93,9 @@ private List<SQLCipherTest> getTestsToRun() {
     tests.add(new TransactionNonExclusiveTest());
     tests.add(new TransactionWithListenerTest());
     tests.add(new LargeDatabaseCursorAccessTest());
+
 //    tests.add(new TimeLargeByteArrayQueryTest());
+
     tests.add(new QueryLimitTest());
     tests.add(new RTreeTest());
     tests.add(new ReadWriteDatabaseToExternalStorageTest());
@@ -171,6 +183,7 @@ private List<SQLCipherTest> getTestsToRun() {
     tests.add(new BindByteArrayRawQueryTest());
     tests.add(new NullRawQueryTest());
     tests.add(new ReadWriteDatabaseToExternalStorageTest());
+
     return tests;
   }
 }
diff --git a/app/src/main/java/net/zetetic/tests/TimeLargeByteArrayQueryTest.java b/app/src/main/java/net/zetetic/tests/TimeLargeByteArrayQueryTest.java
@@ -130,12 +130,6 @@ private Stats timeQuery(SQLiteDatabase database, String query, CursorScenario sc
       return stats;
     }
 
-    private byte[] generateRandomByteArray(int size) {
-      byte[] data = new byte[size];
-      random.nextBytes(data);
-      return data;
-    }
-
     private String bytesToString(long bytes) {
       int unit = 1024;
       if (bytes < unit) return bytes + " B";
