Improve the fidelity of legacy SQLite error messages

Previously, in the legacy SQLite mode, all exceptions thrown by SQLite were
wrapped in an arbitrary RuntimeExceptions. This is not consistent with real
Android, which always throws exceptions of type
android.database.sqlite.SQLiteException (including subclasses). This has impact
on data layer libraries such as Room that explicitly catch Android
SQLiteExceptions in order to execute error callback logic.

For #8469

PiperOrigin-RevId: 582331582

integration_tests/ctesque/src/sharedTest/java/android/database/SQLiteDatabaseTest.java

@@ -283,4 +283,26 @@ public void fts4() {
     assertThat(results.getCount()).isEqualTo(0);
     results.close();
   }
+
+  @Config(minSdk = LOLLIPOP) // The SQLite error messages were updated significantly in Lollipop.
+  @SdkSuppress(minSdkVersion = LOLLIPOP)
+  @Test
+  public void uniqueConstraintViolation_errorMessage() {
+    database.execSQL(
+        "CREATE TABLE my_table(\n"
+            + "  _id INTEGER PRIMARY KEY AUTOINCREMENT, \n"
+            + "  unique_column TEXT UNIQUE\n"
+            + ");\n");
+    ContentValues values = new ContentValues();
+    values.put("unique_column", "test");
+    database.insertOrThrow("my_table", null, values);
+    SQLiteConstraintException exception =
+        assertThrows(
+            SQLiteConstraintException.class,
+            () -> database.insertOrThrow("my_table", null, values));
+    assertThat(exception)
+        .hasMessageThat()
+        .startsWith("UNIQUE constraint failed: my_table.unique_column");
+    assertThat(exception).hasMessageThat().contains("code 2067");
+  }
 }

integration_tests/room/build.gradle

@@ -0,0 +1,38 @@
+import org.robolectric.gradle.AndroidProjectConfigPlugin
+
+apply plugin: 'com.android.library'
+apply plugin: AndroidProjectConfigPlugin
+
+android {
+    compileSdk 34
+    namespace 'org.robolectric.integrationtests.room'
+
+    defaultConfig {
+        minSdk 19
+        targetSdk 34
+    }
+
+    compileOptions {
+        sourceCompatibility = '1.8'
+        targetCompatibility = '1.8'
+    }
+
+    testOptions {
+        unitTests {
+            includeAndroidResources = true
+        }
+    }
+
+}
+
+dependencies {
+    // Testing dependencies
+    testImplementation project(path: ':testapp')
+    testImplementation project(":robolectric")
+    testImplementation libs.junit4
+    testImplementation libs.guava.testlib
+    testImplementation libs.guava.testlib
+    testImplementation libs.truth
+    implementation 'androidx.room:room-runtime:2.6.0'
+    annotationProcessor 'androidx.room:room-compiler:2.6.0'
+}

integration_tests/room/src/main/AndroidManifest.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Manifest for androidx memoryleaks test module
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="org.robolectric.integrationtests.room">
+
+    <application>
+    </application>
+</manifest>

integration_tests/room/src/main/java/org/robolectric/integrationtests/room/User.java

@@ -0,0 +1,15 @@
+package org.robolectric.integrationtests.room;
+
+import androidx.room.Entity;
+
+/** A simple User entity */
+@Entity(
+    tableName = "users",
+    primaryKeys = {"id"})
+public class User {
+  public long id;
+
+  public String username;
+
+  public String email;
+}

integration_tests/room/src/main/java/org/robolectric/integrationtests/room/UserDao.java

@@ -0,0 +1,20 @@
+package org.robolectric.integrationtests.room;
+
+import androidx.room.Dao;
+import androidx.room.Insert;
+import androidx.room.Query;
+import androidx.room.Upsert;
+import java.util.List;
+
+/** Dao for {@link User} */
+@Dao
+public interface UserDao {
+  @Upsert
+  void upsert(User user);
+
+  @Insert
+  void insert(User user);
+
+  @Query("SELECT * FROM users")
+  List<User> getAllUsers();
+}

integration_tests/room/src/main/java/org/robolectric/integrationtests/room/UserDatabase.java

@@ -0,0 +1,24 @@
+package org.robolectric.integrationtests.room;
+
+import android.content.Context;
+import androidx.room.Database;
+import androidx.room.Room;
+import androidx.room.RoomDatabase;
+
+/** Room database for {@link User} */
+@Database(
+    entities = {User.class},
+    version = 1,
+    exportSchema = false)
+public abstract class UserDatabase extends RoomDatabase {
+
+  public abstract UserDao userDao();
+
+  public static synchronized UserDatabase getInstance(Context context) {
+    return Room.databaseBuilder(
+            context.getApplicationContext(), UserDatabase.class, "user_database")
+        .fallbackToDestructiveMigration()
+        .allowMainThreadQueries()
+        .build();
+  }
+}

integration_tests/room/src/test/java/org/robolectric/integrationtests/room/UserDatabaseTest.java

@@ -0,0 +1,35 @@
+package org.robolectric.integrationtests.room;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.SQLiteMode;
+
+@RunWith(RobolectricTestRunner.class)
+public final class UserDatabaseTest {
+
+  /**
+   * There was an issue using Room with {@link SQLiteMode.Mode.LEGACY}. The {@link
+   * android.database.sqlite.SQLiteException} exceptions were wrapped in a way that was not
+   * compatible with Room.
+   */
+  @Test
+  @SQLiteMode(SQLiteMode.Mode.LEGACY)
+  public void upsert_conflict_usingLegacySQLite() {
+    UserDatabase db = UserDatabase.getInstance(RuntimeEnvironment.getApplication());
+
+    User user = new User();
+    user.id = 12;
+    user.username = "username";
+    user.email = "username@example.com";
+
+    UserDao dao = db.userDao();
+    dao.upsert(user);
+    dao.upsert(user); // Should succeed
+
+    assertThat(dao.getAllUsers()).hasSize(1);
+  }
+}

robolectric/src/test/java/org/robolectric/shadows/ShadowSQLiteConnectionTest.java

@@ -4,12 +4,14 @@
 import static com.google.common.truth.Truth.assertThat;
 import static com.google.common.truth.Truth.assertWithMessage;
 import static com.google.common.truth.TruthJUnit.assume;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.fail;
 import static org.robolectric.annotation.SQLiteMode.Mode.LEGACY;
 import static org.robolectric.shadows.ShadowLegacySQLiteConnection.convertSQLWithLocalizedUnicodeCollator;
 
 import android.content.ContentValues;
 import android.database.Cursor;
+import android.database.sqlite.SQLiteConstraintException;
 import android.database.sqlite.SQLiteDatabase;
 import android.database.sqlite.SQLiteDatatypeMismatchException;
 import android.database.sqlite.SQLiteStatement;
@@ -188,6 +190,23 @@ public void interruption_doesNotConcurrentlyModifyDatabase() {
     ShadowLegacySQLiteConnection.reset();
   }
 
+  @Test
+  public void uniqueConstraintViolation_errorMessage() {
+    database.execSQL(
+        "CREATE TABLE my_table(\n"
+            + "  _id INTEGER PRIMARY KEY AUTOINCREMENT, \n"
+            + "  unique_column TEXT UNIQUE\n"
+            + ");\n");
+    ContentValues values = new ContentValues();
+    values.put("unique_column", "test");
+    database.insertOrThrow("my_table", null, values);
+    SQLiteConstraintException exception =
+        assertThrows(
+            SQLiteConstraintException.class,
+            () -> database.insertOrThrow("my_table", null, values));
+    assertThat(exception).hasMessageThat().endsWith("(code 2067 SQLITE_CONSTRAINT_UNIQUE)");
+  }
+
   @Test
   public void test_setUseInMemoryDatabase() {
     assume().that(SQLiteLibraryLoader.isOsSupported()).isTrue();

settings.gradle

@@ -41,4 +41,5 @@ include ":integration_tests:multidex"
 include ":integration_tests:play_services"
 include ":integration_tests:sparsearray"
 include ":integration_tests:nativegraphics"
+include ":integration_tests:room"
 include ':testapp'