Revert^2 "Use response from calls to insertRecords in tests (datatypes E-O)"

This reverts commit eff985294c2c60eafd9a49b16f1d2097ec656921.

Reason for revert: Adding the fix that broke the original change.

Change-Id: If6aea7b31de808457f7c8eb7a5eec636672f0928

14 files changed, 276 insertions, 203 deletions

diff --git a/tests/cts/src/android/healthconnect/cts/ElevationGainedRecordTest.java b/tests/cts/src/android/healthconnect/cts/ElevationGainedRecordTest.java
index 7b678e37..4ae5117c 100644
--- a/tests/cts/src/android/healthconnect/cts/ElevationGainedRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/ElevationGainedRecordTest.java
@@ -135,8 +135,9 @@ public class ElevationGainedRecordTest {
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(ElevationGainedRecord.class)
                                 .build());
-        ElevationGainedRecord testRecord = getCompleteElevationGainedRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        ElevationGainedRecord testRecord =
+                (ElevationGainedRecord) TestUtils.insertRecord(getCompleteElevationGainedRecord());
         List<ElevationGainedRecord> newElevationGainedRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(ElevationGainedRecord.class)
@@ -157,8 +158,9 @@ public class ElevationGainedRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        ElevationGainedRecord testRecord = getCompleteElevationGainedRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        ElevationGainedRecord testRecord =
+                (ElevationGainedRecord) TestUtils.insertRecord(getCompleteElevationGainedRecord());
         List<ElevationGainedRecord> newElevationGainedRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(ElevationGainedRecord.class)
@@ -184,8 +186,9 @@ public class ElevationGainedRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        ElevationGainedRecord testRecord = getCompleteElevationGainedRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        ElevationGainedRecord testRecord =
+                (ElevationGainedRecord) TestUtils.insertRecord(getCompleteElevationGainedRecord());
         List<ElevationGainedRecord> newElevationGainedRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(ElevationGainedRecord.class)
@@ -241,8 +244,10 @@ public class ElevationGainedRecordTest {
     @Test
     public void testDeleteElevationGainedRecord_recordId_filters() throws InterruptedException {
         List<Record> records =
-                List.of(getBaseElevationGainedRecord(), getCompleteElevationGainedRecord());
-        TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(
+                                getBaseElevationGainedRecord(),
+                                getCompleteElevationGainedRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -281,10 +286,12 @@ public class ElevationGainedRecordTest {
     @Test
     public void testDeleteElevationGainedRecord_usingIds() throws InterruptedException {
         List<Record> records =
-                List.of(getBaseElevationGainedRecord(), getCompleteElevationGainedRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(
+                                getBaseElevationGainedRecord(),
+                                getCompleteElevationGainedRecord()));
         List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
-        for (Record record : insertedRecord) {
+        for (Record record : records) {
             recordIds.add(RecordIdFilter.fromId(record.getClass(), record.getMetadata().getId()));
         }
 
@@ -548,8 +555,9 @@ public class ElevationGainedRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteElevationGainedRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(
+                        Collections.singletonList(getCompleteElevationGainedRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
diff --git a/tests/cts/src/android/healthconnect/cts/ExerciseSessionRecordTest.java b/tests/cts/src/android/healthconnect/cts/ExerciseSessionRecordTest.java
index 0a708375..8e1565d3 100644
--- a/tests/cts/src/android/healthconnect/cts/ExerciseSessionRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/ExerciseSessionRecordTest.java
@@ -178,11 +178,11 @@ public class ExerciseSessionRecordTest {
                                 ExerciseSessionType.EXERCISE_SESSION_TYPE_FOOTBALL_AMERICAN)
                         .setRoute(route)
                         .build();
-        List<Record> recordList = TestUtils.insertRecords(Collections.singletonList(record));
+        ExerciseSessionRecord testRecord = (ExerciseSessionRecord) TestUtils.insertRecord(record);
 
         ReadRecordsRequestUsingIds.Builder<ExerciseSessionRecord> request =
                 new ReadRecordsRequestUsingIds.Builder<>(ExerciseSessionRecord.class);
-        request.addId(recordList.get(0).getMetadata().getId());
+        request.addId(testRecord.getMetadata().getId());
 
         ExerciseSessionRecord insertedRecord = TestUtils.readRecords(request.build()).get(0);
         assertThat(insertedRecord.hasRoute()).isTrue();
@@ -191,7 +191,7 @@ public class ExerciseSessionRecordTest {
         TestUtils.updateRecords(
                 Collections.singletonList(
                         getExerciseSessionRecord_update(
-                                record, recordList.get(0).getMetadata().getId(), null)));
+                                record, testRecord.getMetadata().getId(), null)));
 
         insertedRecord = TestUtils.readRecords(request.build()).get(0);
         assertThat(insertedRecord.hasRoute()).isFalse();
@@ -320,18 +320,9 @@ public class ExerciseSessionRecordTest {
     }
 
     @Test
-    public void testInsertRecord_apiReturnsRequestedRecords() throws InterruptedException {
-        List<Record> records =
-                Arrays.asList(TestUtils.buildExerciseSession(), TestUtils.buildExerciseSession());
-        List<Record> insertedRecords = TestUtils.insertRecords(records);
-        assertThat(records.size()).isEqualTo(insertedRecords.size());
-        assertThat(records).containsExactlyElementsIn(insertedRecords);
-    }
-
-    @Test
     public void testReadById_insertAndReadById_recordsAreEqual() throws InterruptedException {
-        List<Record> records = List.of(TestUtils.buildExerciseSession(), buildSessionMinimal());
-        TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(List.of(buildExerciseSession(), buildSessionMinimal()));
 
         ReadRecordsRequestUsingIds.Builder<ExerciseSessionRecord> request =
                 new ReadRecordsRequestUsingIds.Builder<>(ExerciseSessionRecord.class);
@@ -343,8 +334,7 @@ public class ExerciseSessionRecordTest {
 
     @Test
     public void testReadById_insertAndReadByIdOne_recordsAreEqual() throws InterruptedException {
-        List<Record> records = List.of(TestUtils.buildExerciseSession());
-        TestUtils.insertRecords(records);
+        List<Record> records = TestUtils.insertRecords(List.of(buildExerciseSession()));
 
         ReadRecordsRequestUsingIds.Builder<ExerciseSessionRecord> request =
                 new ReadRecordsRequestUsingIds.Builder<>(ExerciseSessionRecord.class);
@@ -362,8 +352,8 @@ public class ExerciseSessionRecordTest {
     @Test
     public void testReadByClientId_insertAndReadByClientId_recordsAreEqual()
             throws InterruptedException {
-        List<Record> records = List.of(TestUtils.buildExerciseSession(), buildSessionMinimal());
-        TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(List.of(buildExerciseSession(), buildSessionMinimal()));
 
         ReadRecordsRequestUsingIds.Builder<ExerciseSessionRecord> request =
                 new ReadRecordsRequestUsingIds.Builder<>(ExerciseSessionRecord.class);
@@ -376,8 +366,9 @@ public class ExerciseSessionRecordTest {
     @Test
     public void testReadByClientId_insertAndReadByDefaultFilter_filteredAll()
             throws InterruptedException {
-        List<Record> records = List.of(TestUtils.buildExerciseSession(), buildSessionMinimal());
-        assertThat(TestUtils.insertRecords(records)).hasSize(2);
+        List<Record> records =
+                TestUtils.insertRecords(List.of(buildExerciseSession(), buildSessionMinimal()));
+        assertThat(records).hasSize(2);
 
         List<ExerciseSessionRecord> readRecords =
                 TestUtils.readRecords(
@@ -389,8 +380,8 @@ public class ExerciseSessionRecordTest {
     @Test
     public void testReadByClientId_insertAndReadByTimeFilter_filteredCorrectly()
             throws InterruptedException {
-        List<Record> records = List.of(TestUtils.buildExerciseSession(), buildSessionMinimal());
-        TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(List.of(buildExerciseSession(), buildSessionMinimal()));
 
         TimeInstantRangeFilter filter =
                 new TimeInstantRangeFilter.Builder()
@@ -413,15 +404,15 @@ public class ExerciseSessionRecordTest {
     @Test
     public void testDeleteRecords_insertAndDeleteById_recordsNotFoundAnymore()
             throws InterruptedException {
-        List<Record> records = List.of(TestUtils.buildExerciseSession(), buildSessionMinimal());
-        List<Record> insertedRecords = TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(List.of(buildExerciseSession(), buildSessionMinimal()));
 
         TestUtils.assertRecordFound(
                 records.get(0).getMetadata().getId(), ExerciseSessionRecord.class);
         TestUtils.assertRecordFound(
                 records.get(1).getMetadata().getId(), ExerciseSessionRecord.class);
 
-        TestUtils.deleteRecords(insertedRecords);
+        TestUtils.deleteRecords(records);
 
         TestUtils.assertRecordNotFound(
                 records.get(0).getMetadata().getId(), ExerciseSessionRecord.class);
@@ -567,8 +558,8 @@ public class ExerciseSessionRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(buildExerciseSession());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(Collections.singletonList(buildExerciseSession()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
diff --git a/tests/cts/src/android/healthconnect/cts/FloorsClimbedRecordTest.java b/tests/cts/src/android/healthconnect/cts/FloorsClimbedRecordTest.java
index e2b3ff6d..eb58b1b2 100644
--- a/tests/cts/src/android/healthconnect/cts/FloorsClimbedRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/FloorsClimbedRecordTest.java
@@ -135,8 +135,9 @@ public class FloorsClimbedRecordTest {
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(FloorsClimbedRecord.class)
                                 .build());
-        FloorsClimbedRecord testRecord = getCompleteFloorsClimbedRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        FloorsClimbedRecord testRecord =
+                (FloorsClimbedRecord) TestUtils.insertRecord(getCompleteFloorsClimbedRecord());
         List<FloorsClimbedRecord> newFloorsClimbedRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(FloorsClimbedRecord.class)
@@ -156,8 +157,9 @@ public class FloorsClimbedRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        FloorsClimbedRecord testRecord = getCompleteFloorsClimbedRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        FloorsClimbedRecord testRecord =
+                (FloorsClimbedRecord) TestUtils.insertRecord(getCompleteFloorsClimbedRecord());
         List<FloorsClimbedRecord> newFloorsClimbedRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(FloorsClimbedRecord.class)
@@ -183,8 +185,9 @@ public class FloorsClimbedRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        FloorsClimbedRecord testRecord = getCompleteFloorsClimbedRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        FloorsClimbedRecord testRecord =
+                (FloorsClimbedRecord) TestUtils.insertRecord(getCompleteFloorsClimbedRecord());
         List<FloorsClimbedRecord> newFloorsClimbedRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(FloorsClimbedRecord.class)
@@ -446,8 +449,9 @@ public class FloorsClimbedRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteFloorsClimbedRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(
+                        Collections.singletonList(getCompleteFloorsClimbedRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
diff --git a/tests/cts/src/android/healthconnect/cts/HeartRateRecordTest.java b/tests/cts/src/android/healthconnect/cts/HeartRateRecordTest.java
index 623c8ed4..e9f53b44 100644
--- a/tests/cts/src/android/healthconnect/cts/HeartRateRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/HeartRateRecordTest.java
@@ -153,8 +153,9 @@ public class HeartRateRecordTest {
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(HeartRateRecord.class)
                                 .build());
-        HeartRateRecord testRecord = getCompleteHeartRateRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        HeartRateRecord testRecord =
+                (HeartRateRecord) TestUtils.insertRecord(getCompleteHeartRateRecord());
         List<HeartRateRecord> newHeartRateRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(HeartRateRecord.class)
@@ -171,8 +172,9 @@ public class HeartRateRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        HeartRateRecord testRecord = getCompleteHeartRateRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        HeartRateRecord testRecord =
+                (HeartRateRecord) TestUtils.insertRecord(getCompleteHeartRateRecord());
         ReadRecordsRequestUsingFilters<HeartRateRecord> requestUsingFilters =
                 new ReadRecordsRequestUsingFilters.Builder<>(HeartRateRecord.class)
                         .setTimeRangeFilter(filter)
@@ -198,8 +200,9 @@ public class HeartRateRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        HeartRateRecord testRecord = getCompleteHeartRateRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        HeartRateRecord testRecord =
+                (HeartRateRecord) TestUtils.insertRecord(getCompleteHeartRateRecord());
         List<HeartRateRecord> newHeartRateRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(HeartRateRecord.class)
@@ -367,8 +370,9 @@ public class HeartRateRecordTest {
 
     @Test
     public void testDeleteHeartRateRecord_recordId_filters() throws InterruptedException {
-        List<Record> records = List.of(getBaseHeartRateRecord(10), getCompleteHeartRateRecord());
-        TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(
+                        List.of(getBaseHeartRateRecord(10), getCompleteHeartRateRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -406,10 +410,11 @@ public class HeartRateRecordTest {
 
     @Test
     public void testDeleteHeartRateRecord_usingIds() throws InterruptedException {
-        List<Record> records = List.of(getBaseHeartRateRecord(10), getCompleteHeartRateRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(
+                        List.of(getBaseHeartRateRecord(10), getCompleteHeartRateRecord()));
         List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
-        for (Record record : insertedRecord) {
+        for (Record record : records) {
             recordIds.add(RecordIdFilter.fromId(record.getClass(), record.getMetadata().getId()));
         }
         for (RecordIdFilter recordIdFilter : recordIds) {
@@ -426,10 +431,11 @@ public class HeartRateRecordTest {
 
     @Test
     public void testDeleteHeartRateRecord_usingInvalidClientIds() throws InterruptedException {
-        List<Record> records = List.of(getBaseHeartRateRecord(10), getCompleteHeartRateRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(
+                        List.of(getBaseHeartRateRecord(10), getCompleteHeartRateRecord()));
         List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
-        for (Record record : insertedRecord) {
+        for (Record record : records) {
             recordIds.add(
                     RecordIdFilter.fromClientRecordId(
                             record.getClass(), record.getMetadata().getId()));
@@ -812,8 +818,8 @@ public class HeartRateRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteHeartRateRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(Collections.singletonList(getCompleteHeartRateRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
@@ -978,7 +984,8 @@ public class HeartRateRecordTest {
 
     private void testReadHeartRateRecordIds() throws InterruptedException {
         List<Record> recordList =
-                Arrays.asList(getCompleteHeartRateRecord(), getCompleteHeartRateRecord());
+                TestUtils.insertRecords(
+                        Arrays.asList(getCompleteHeartRateRecord(), getCompleteHeartRateRecord()));
         readHeartRateRecordUsingIds(recordList);
     }
 
@@ -994,8 +1001,8 @@ public class HeartRateRecordTest {
         assertThat(result).containsExactlyElementsIn(insertedRecord);
     }
 
-    private void readHeartRateRecordUsingIds(List<Record> recordList) throws InterruptedException {
-        List<Record> insertedRecords = TestUtils.insertRecords(recordList);
+    private void readHeartRateRecordUsingIds(List<Record> insertedRecords)
+            throws InterruptedException {
         ReadRecordsRequestUsingIds.Builder<HeartRateRecord> request =
                 new ReadRecordsRequestUsingIds.Builder<>(HeartRateRecord.class);
         for (Record record : insertedRecords) {
diff --git a/tests/cts/src/android/healthconnect/cts/HeartRateVariabilityRmssdRecordTest.java b/tests/cts/src/android/healthconnect/cts/HeartRateVariabilityRmssdRecordTest.java
index 72a0fbb9..b763b26c 100644
--- a/tests/cts/src/android/healthconnect/cts/HeartRateVariabilityRmssdRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/HeartRateVariabilityRmssdRecordTest.java
@@ -128,8 +128,10 @@ public class HeartRateVariabilityRmssdRecordTest {
                         new ReadRecordsRequestUsingFilters.Builder<>(
                                         HeartRateVariabilityRmssdRecord.class)
                                 .build());
-        HeartRateVariabilityRmssdRecord testRecord = getCompleteHeartRateVariabilityRmssdRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        HeartRateVariabilityRmssdRecord testRecord =
+                (HeartRateVariabilityRmssdRecord)
+                        TestUtils.insertRecord(getCompleteHeartRateVariabilityRmssdRecord());
         List<HeartRateVariabilityRmssdRecord> newHeartRateVariabilityRmssdRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(
@@ -152,8 +154,10 @@ public class HeartRateVariabilityRmssdRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        HeartRateVariabilityRmssdRecord testRecord = getCompleteHeartRateVariabilityRmssdRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        HeartRateVariabilityRmssdRecord testRecord =
+                (HeartRateVariabilityRmssdRecord)
+                        TestUtils.insertRecord(getCompleteHeartRateVariabilityRmssdRecord());
         List<HeartRateVariabilityRmssdRecord> newHeartRateVariabilityRmssdRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(
@@ -181,8 +185,10 @@ public class HeartRateVariabilityRmssdRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        HeartRateVariabilityRmssdRecord testRecord = getCompleteHeartRateVariabilityRmssdRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        HeartRateVariabilityRmssdRecord testRecord =
+                (HeartRateVariabilityRmssdRecord)
+                        TestUtils.insertRecord(getCompleteHeartRateVariabilityRmssdRecord());
         List<HeartRateVariabilityRmssdRecord> newHeartRateVariabilityRmssdRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(
@@ -245,10 +251,10 @@ public class HeartRateVariabilityRmssdRecordTest {
     public void testDeleteHeartRateVariabilityRmssdRecord_recordId_filters()
             throws InterruptedException {
         List<Record> records =
-                List.of(
-                        getBaseHeartRateVariabilityRmssdRecord(),
-                        getCompleteHeartRateVariabilityRmssdRecord());
-        TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(
+                                getBaseHeartRateVariabilityRmssdRecord(),
+                                getCompleteHeartRateVariabilityRmssdRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -291,14 +297,14 @@ public class HeartRateVariabilityRmssdRecordTest {
                 List.of(
                         getBaseHeartRateVariabilityRmssdRecord(),
                         getCompleteHeartRateVariabilityRmssdRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+        List<Record> insertedRecords = TestUtils.insertRecords(records);
         List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
-        for (Record record : insertedRecord) {
+        for (Record record : insertedRecords) {
             recordIds.add(RecordIdFilter.fromId(record.getClass(), record.getMetadata().getId()));
         }
 
         TestUtils.verifyDeleteRecords(recordIds);
-        for (Record record : records) {
+        for (Record record : insertedRecords) {
             TestUtils.assertRecordNotFound(record.getMetadata().getId(), record.getClass());
         }
     }
@@ -505,8 +511,9 @@ public class HeartRateVariabilityRmssdRecordTest {
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
         List<Record> testRecord =
-                Collections.singletonList(getCompleteHeartRateVariabilityRmssdRecord());
-        TestUtils.insertRecords(testRecord);
+                TestUtils.insertRecords(
+                        Collections.singletonList(getCompleteHeartRateVariabilityRmssdRecord()));
+
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
@@ -552,7 +559,7 @@ public class HeartRateVariabilityRmssdRecordTest {
         assertThat(requestUsingIds.getRecordIdFilters()).isNotNull();
         List<HeartRateVariabilityRmssdRecord> result = TestUtils.readRecords(requestUsingIds);
         assertThat(result).hasSize(insertedRecords.size());
-        assertThat(result).containsExactlyElementsIn(recordList);
+        assertThat(result).containsExactlyElementsIn(insertedRecords);
     }
 
     HeartRateVariabilityRmssdRecord getHeartRateVariabilityRmssdRecord_update(
diff --git a/tests/cts/src/android/healthconnect/cts/HeightRecordTest.java b/tests/cts/src/android/healthconnect/cts/HeightRecordTest.java
index 5022b9c7..70e39e2c 100644
--- a/tests/cts/src/android/healthconnect/cts/HeightRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/HeightRecordTest.java
@@ -133,8 +133,8 @@ public class HeightRecordTest {
         List<HeightRecord> oldHeightRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(HeightRecord.class).build());
-        HeightRecord testRecord = getCompleteHeightRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        HeightRecord testRecord = (HeightRecord) TestUtils.insertRecord(getCompleteHeightRecord());
         List<HeightRecord> newHeightRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(HeightRecord.class).build());
@@ -149,8 +149,8 @@ public class HeightRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        HeightRecord testRecord = getCompleteHeightRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        HeightRecord testRecord = (HeightRecord) TestUtils.insertRecord(getCompleteHeightRecord());
         List<HeightRecord> newHeightRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(HeightRecord.class)
@@ -171,8 +171,8 @@ public class HeightRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        HeightRecord testRecord = getCompleteHeightRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        HeightRecord testRecord = (HeightRecord) TestUtils.insertRecord(getCompleteHeightRecord());
         List<HeightRecord> newHeightRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(HeightRecord.class)
@@ -251,8 +251,8 @@ public class HeightRecordTest {
 
     @Test
     public void testDeleteHeightRecord_recordId_filters() throws InterruptedException {
-        List<Record> records = List.of(getBaseHeightRecord(), getCompleteHeightRecord());
-        TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(List.of(getBaseHeightRecord(), getCompleteHeightRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -289,10 +289,10 @@ public class HeightRecordTest {
 
     @Test
     public void testDeleteHeightRecord_usingIds() throws InterruptedException {
-        List<Record> records = List.of(getBaseHeightRecord(), getCompleteHeightRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(List.of(getBaseHeightRecord(), getCompleteHeightRecord()));
         List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
-        for (Record record : insertedRecord) {
+        for (Record record : records) {
             recordIds.add(RecordIdFilter.fromId(record.getClass(), record.getMetadata().getId()));
         }
 
@@ -496,8 +496,8 @@ public class HeightRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteHeightRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(Collections.singletonList(getCompleteHeightRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
diff --git a/tests/cts/src/android/healthconnect/cts/HydrationRecordTest.java b/tests/cts/src/android/healthconnect/cts/HydrationRecordTest.java
index 28b1b650..d72d9f23 100644
--- a/tests/cts/src/android/healthconnect/cts/HydrationRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/HydrationRecordTest.java
@@ -130,8 +130,9 @@ public class HydrationRecordTest {
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(HydrationRecord.class)
                                 .build());
-        HydrationRecord testRecord = getCompleteHydrationRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        HydrationRecord testRecord =
+                (HydrationRecord) TestUtils.insertRecord(getCompleteHydrationRecord());
         List<HydrationRecord> newHydrationRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(HydrationRecord.class)
@@ -148,8 +149,9 @@ public class HydrationRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        HydrationRecord testRecord = getCompleteHydrationRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        HydrationRecord testRecord =
+                (HydrationRecord) TestUtils.insertRecord(getCompleteHydrationRecord());
         List<HydrationRecord> newHydrationRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(HydrationRecord.class)
@@ -172,8 +174,9 @@ public class HydrationRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        HydrationRecord testRecord = getCompleteHydrationRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        HydrationRecord testRecord =
+                (HydrationRecord) TestUtils.insertRecord(getCompleteHydrationRecord());
         List<HydrationRecord> newHydrationRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(HydrationRecord.class)
@@ -226,8 +229,9 @@ public class HydrationRecordTest {
 
     @Test
     public void testDeleteHydrationRecord_recordId_filters() throws InterruptedException {
-        List<Record> records = List.of(getBaseHydrationRecord(), getCompleteHydrationRecord());
-        TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(
+                        List.of(getBaseHydrationRecord(), getCompleteHydrationRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -265,10 +269,11 @@ public class HydrationRecordTest {
 
     @Test
     public void testDeleteHydrationRecord_usingIds() throws InterruptedException {
-        List<Record> records = List.of(getBaseHydrationRecord(), getCompleteHydrationRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(
+                        List.of(getBaseHydrationRecord(), getCompleteHydrationRecord()));
         List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
-        for (Record record : insertedRecord) {
+        for (Record record : records) {
             recordIds.add(RecordIdFilter.fromId(record.getClass(), record.getMetadata().getId()));
         }
 
@@ -484,8 +489,8 @@ public class HydrationRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteHydrationRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(Collections.singletonList(getCompleteHydrationRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
diff --git a/tests/cts/src/android/healthconnect/cts/IntermenstrualBleedingRecordTest.java b/tests/cts/src/android/healthconnect/cts/IntermenstrualBleedingRecordTest.java
index f706f88a..6fb1c74b 100644
--- a/tests/cts/src/android/healthconnect/cts/IntermenstrualBleedingRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/IntermenstrualBleedingRecordTest.java
@@ -128,8 +128,10 @@ public class IntermenstrualBleedingRecordTest {
                         new ReadRecordsRequestUsingFilters.Builder<>(
                                         IntermenstrualBleedingRecord.class)
                                 .build());
-        IntermenstrualBleedingRecord testRecord = getCompleteIntermenstrualBleedingRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        IntermenstrualBleedingRecord testRecord =
+                (IntermenstrualBleedingRecord)
+                        TestUtils.insertRecord(getCompleteIntermenstrualBleedingRecord());
         List<IntermenstrualBleedingRecord> newIntermenstrualBleedingRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(
@@ -152,8 +154,10 @@ public class IntermenstrualBleedingRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        IntermenstrualBleedingRecord testRecord = getCompleteIntermenstrualBleedingRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        IntermenstrualBleedingRecord testRecord =
+                (IntermenstrualBleedingRecord)
+                        TestUtils.insertRecord(getCompleteIntermenstrualBleedingRecord());
         List<IntermenstrualBleedingRecord> newIntermenstrualBleedingRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(
@@ -181,8 +185,10 @@ public class IntermenstrualBleedingRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        IntermenstrualBleedingRecord testRecord = getCompleteIntermenstrualBleedingRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        IntermenstrualBleedingRecord testRecord =
+                (IntermenstrualBleedingRecord)
+                        TestUtils.insertRecord(getCompleteIntermenstrualBleedingRecord());
         List<IntermenstrualBleedingRecord> newIntermenstrualBleedingRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(
@@ -243,10 +249,10 @@ public class IntermenstrualBleedingRecordTest {
     public void testDeleteIntermenstrualBleedingRecord_recordId_filters()
             throws InterruptedException {
         List<Record> records =
-                List.of(
-                        getBaseIntermenstrualBleedingRecord(),
-                        getCompleteIntermenstrualBleedingRecord());
-        TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(
+                                getBaseIntermenstrualBleedingRecord(),
+                                getCompleteIntermenstrualBleedingRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -286,12 +292,12 @@ public class IntermenstrualBleedingRecordTest {
     @Test
     public void testDeleteIntermenstrualBleedingRecord_usingIds() throws InterruptedException {
         List<Record> records =
-                List.of(
-                        getBaseIntermenstrualBleedingRecord(),
-                        getCompleteIntermenstrualBleedingRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(
+                                getBaseIntermenstrualBleedingRecord(),
+                                getCompleteIntermenstrualBleedingRecord()));
         List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
-        for (Record record : insertedRecord) {
+        for (Record record : records) {
             recordIds.add(RecordIdFilter.fromId(record.getClass(), record.getMetadata().getId()));
         }
 
@@ -384,8 +390,8 @@ public class IntermenstrualBleedingRecordTest {
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
         List<Record> testRecord =
-                Collections.singletonList(getCompleteIntermenstrualBleedingRecord());
-        TestUtils.insertRecords(testRecord);
+                TestUtils.insertRecords(
+                        Collections.singletonList(getCompleteIntermenstrualBleedingRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
@@ -541,7 +547,7 @@ public class IntermenstrualBleedingRecordTest {
         assertThat(requestUsingIds.getRecordIdFilters()).isNotNull();
         List<IntermenstrualBleedingRecord> result = TestUtils.readRecords(requestUsingIds);
         assertThat(result).hasSize(insertedRecords.size());
-        assertThat(result).containsExactlyElementsIn(recordList);
+        assertThat(result).containsExactlyElementsIn(insertedRecords);
     }
 
     IntermenstrualBleedingRecord getIntermenstrualBleedingRecord_update(
diff --git a/tests/cts/src/android/healthconnect/cts/LeanBodyMassRecordTest.java b/tests/cts/src/android/healthconnect/cts/LeanBodyMassRecordTest.java
index cde7e327..c09ef6f8 100644
--- a/tests/cts/src/android/healthconnect/cts/LeanBodyMassRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/LeanBodyMassRecordTest.java
@@ -119,8 +119,9 @@ public class LeanBodyMassRecordTest {
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(LeanBodyMassRecord.class)
                                 .build());
-        LeanBodyMassRecord testRecord = getCompleteLeanBodyMassRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        LeanBodyMassRecord testRecord =
+                (LeanBodyMassRecord) TestUtils.insertRecord(getCompleteLeanBodyMassRecord());
         List<LeanBodyMassRecord> newLeanBodyMassRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(LeanBodyMassRecord.class)
@@ -137,8 +138,9 @@ public class LeanBodyMassRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        LeanBodyMassRecord testRecord = getCompleteLeanBodyMassRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        LeanBodyMassRecord testRecord =
+                (LeanBodyMassRecord) TestUtils.insertRecord(getCompleteLeanBodyMassRecord());
         List<LeanBodyMassRecord> newLeanBodyMassRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(LeanBodyMassRecord.class)
@@ -161,8 +163,9 @@ public class LeanBodyMassRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        LeanBodyMassRecord testRecord = getCompleteLeanBodyMassRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        LeanBodyMassRecord testRecord =
+                (LeanBodyMassRecord) TestUtils.insertRecord(getCompleteLeanBodyMassRecord());
         List<LeanBodyMassRecord> newLeanBodyMassRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(LeanBodyMassRecord.class)
@@ -244,8 +247,8 @@ public class LeanBodyMassRecordTest {
     @Test
     public void testDeleteLeanBodyMassRecord_recordId_filters() throws InterruptedException {
         List<Record> records =
-                List.of(getBaseLeanBodyMassRecord(), getCompleteLeanBodyMassRecord());
-        TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(getBaseLeanBodyMassRecord(), getCompleteLeanBodyMassRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -284,10 +287,10 @@ public class LeanBodyMassRecordTest {
     @Test
     public void testDeleteLeanBodyMassRecord_usingIds() throws InterruptedException {
         List<Record> records =
-                List.of(getBaseLeanBodyMassRecord(), getCompleteLeanBodyMassRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(getBaseLeanBodyMassRecord(), getCompleteLeanBodyMassRecord()));
         List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
-        for (Record record : insertedRecord) {
+        for (Record record : records) {
             recordIds.add(RecordIdFilter.fromId(record.getClass(), record.getMetadata().getId()));
         }
 
@@ -461,8 +464,8 @@ public class LeanBodyMassRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteLeanBodyMassRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(Collections.singletonList(getCompleteLeanBodyMassRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
diff --git a/tests/cts/src/android/healthconnect/cts/MenstruationFlowRecordTest.java b/tests/cts/src/android/healthconnect/cts/MenstruationFlowRecordTest.java
index f48a814d..5e6e942c 100644
--- a/tests/cts/src/android/healthconnect/cts/MenstruationFlowRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/MenstruationFlowRecordTest.java
@@ -121,8 +121,10 @@ public class MenstruationFlowRecordTest {
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(MenstruationFlowRecord.class)
                                 .build());
-        MenstruationFlowRecord testRecord = getCompleteMenstruationFlowRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        MenstruationFlowRecord testRecord =
+                (MenstruationFlowRecord)
+                        TestUtils.insertRecord(getCompleteMenstruationFlowRecord());
         List<MenstruationFlowRecord> newMenstruationFlowRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(MenstruationFlowRecord.class)
@@ -144,8 +146,10 @@ public class MenstruationFlowRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        MenstruationFlowRecord testRecord = getCompleteMenstruationFlowRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        MenstruationFlowRecord testRecord =
+                (MenstruationFlowRecord)
+                        TestUtils.insertRecord(getCompleteMenstruationFlowRecord());
         List<MenstruationFlowRecord> newMenstruationFlowRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(MenstruationFlowRecord.class)
@@ -171,8 +175,10 @@ public class MenstruationFlowRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        MenstruationFlowRecord testRecord = getCompleteMenstruationFlowRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        MenstruationFlowRecord testRecord =
+                (MenstruationFlowRecord)
+                        TestUtils.insertRecord(getCompleteMenstruationFlowRecord());
         List<MenstruationFlowRecord> newMenstruationFlowRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(MenstruationFlowRecord.class)
@@ -255,8 +261,10 @@ public class MenstruationFlowRecordTest {
     @Test
     public void testDeleteMenstruationFlowRecord_recordId_filters() throws InterruptedException {
         List<Record> records =
-                List.of(getBaseMenstruationFlowRecord(), getCompleteMenstruationFlowRecord());
-        TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(
+                                getBaseMenstruationFlowRecord(),
+                                getCompleteMenstruationFlowRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -295,10 +303,12 @@ public class MenstruationFlowRecordTest {
     @Test
     public void testDeleteMenstruationFlowRecord_usingIds() throws InterruptedException {
         List<Record> records =
-                List.of(getBaseMenstruationFlowRecord(), getCompleteMenstruationFlowRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(
+                                getBaseMenstruationFlowRecord(),
+                                getCompleteMenstruationFlowRecord()));
         List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
-        for (Record record : insertedRecord) {
+        for (Record record : records) {
             recordIds.add(RecordIdFilter.fromId(record.getClass(), record.getMetadata().getId()));
         }
 
@@ -471,8 +481,9 @@ public class MenstruationFlowRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteMenstruationFlowRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(
+                        Collections.singletonList(getCompleteMenstruationFlowRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
diff --git a/tests/cts/src/android/healthconnect/cts/MenstruationPeriodRecordTest.java b/tests/cts/src/android/healthconnect/cts/MenstruationPeriodRecordTest.java
index f87fd26c..83fd4bcc 100644
--- a/tests/cts/src/android/healthconnect/cts/MenstruationPeriodRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/MenstruationPeriodRecordTest.java
@@ -125,8 +125,10 @@ public class MenstruationPeriodRecordTest {
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(MenstruationPeriodRecord.class)
                                 .build());
-        MenstruationPeriodRecord testRecord = getCompleteMenstruationPeriodRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        MenstruationPeriodRecord testRecord =
+                (MenstruationPeriodRecord)
+                        TestUtils.insertRecord(getCompleteMenstruationPeriodRecord());
         List<MenstruationPeriodRecord> newMenstruationPeriodRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(MenstruationPeriodRecord.class)
@@ -148,8 +150,10 @@ public class MenstruationPeriodRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        MenstruationPeriodRecord testRecord = getCompleteMenstruationPeriodRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        MenstruationPeriodRecord testRecord =
+                (MenstruationPeriodRecord)
+                        TestUtils.insertRecord(getCompleteMenstruationPeriodRecord());
         List<MenstruationPeriodRecord> newMenstruationPeriodRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(MenstruationPeriodRecord.class)
@@ -175,8 +179,10 @@ public class MenstruationPeriodRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        MenstruationPeriodRecord testRecord = getCompleteMenstruationPeriodRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        MenstruationPeriodRecord testRecord =
+                (MenstruationPeriodRecord)
+                        TestUtils.insertRecord(getCompleteMenstruationPeriodRecord());
         List<MenstruationPeriodRecord> newMenstruationPeriodRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(MenstruationPeriodRecord.class)
@@ -231,8 +237,10 @@ public class MenstruationPeriodRecordTest {
     @Test
     public void testDeleteMenstruationPeriodRecord_recordId_filters() throws InterruptedException {
         List<Record> records =
-                List.of(getBaseMenstruationPeriodRecord(), getCompleteMenstruationPeriodRecord());
-        TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(
+                                getBaseMenstruationPeriodRecord(),
+                                getCompleteMenstruationPeriodRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -272,10 +280,12 @@ public class MenstruationPeriodRecordTest {
     @Test
     public void testDeleteMenstruationPeriodRecord_usingIds() throws InterruptedException {
         List<Record> records =
-                List.of(getBaseMenstruationPeriodRecord(), getCompleteMenstruationPeriodRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(
+                                getBaseMenstruationPeriodRecord(),
+                                getCompleteMenstruationPeriodRecord()));
         List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
-        for (Record record : insertedRecord) {
+        for (Record record : records) {
             recordIds.add(RecordIdFilter.fromId(record.getClass(), record.getMetadata().getId()));
         }
 
@@ -492,8 +502,9 @@ public class MenstruationPeriodRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteMenstruationPeriodRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(
+                        Collections.singletonList(getCompleteMenstruationPeriodRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
@@ -538,7 +549,7 @@ public class MenstruationPeriodRecordTest {
         assertThat(requestUsingIds.getRecordIdFilters()).isNotNull();
         List<MenstruationPeriodRecord> result = TestUtils.readRecords(requestUsingIds);
         assertThat(result).hasSize(insertedRecords.size());
-        assertThat(result).containsExactlyElementsIn(recordList);
+        assertThat(result).containsExactlyElementsIn(insertedRecords);
     }
 
     MenstruationPeriodRecord getMenstruationPeriodRecord_update(
diff --git a/tests/cts/src/android/healthconnect/cts/NutritionRecordTest.java b/tests/cts/src/android/healthconnect/cts/NutritionRecordTest.java
index 0c3848f6..02034088 100644
--- a/tests/cts/src/android/healthconnect/cts/NutritionRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/NutritionRecordTest.java
@@ -217,8 +217,9 @@ public class NutritionRecordTest {
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(NutritionRecord.class)
                                 .build());
-        NutritionRecord testRecord = getCompleteNutritionRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        NutritionRecord testRecord =
+                (NutritionRecord) TestUtils.insertRecord(getCompleteNutritionRecord());
         List<NutritionRecord> newNutritionRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(NutritionRecord.class)
@@ -235,8 +236,9 @@ public class NutritionRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        NutritionRecord testRecord = getCompleteNutritionRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        NutritionRecord testRecord =
+                (NutritionRecord) TestUtils.insertRecord(getCompleteNutritionRecord());
         List<NutritionRecord> newNutritionRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(NutritionRecord.class)
@@ -259,8 +261,9 @@ public class NutritionRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        NutritionRecord testRecord = getCompleteNutritionRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        NutritionRecord testRecord =
+                (NutritionRecord) TestUtils.insertRecord(getCompleteNutritionRecord());
         List<NutritionRecord> newNutritionRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(NutritionRecord.class)
@@ -357,8 +360,9 @@ public class NutritionRecordTest {
 
     @Test
     public void testDeleteNutritionRecord_recordId_filters() throws InterruptedException {
-        List<Record> records = List.of(getBaseNutritionRecord(), getCompleteNutritionRecord());
-        TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(
+                        List.of(getBaseNutritionRecord(), getCompleteNutritionRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -404,7 +408,7 @@ public class NutritionRecordTest {
         }
 
         TestUtils.verifyDeleteRecords(recordIds);
-        for (Record record : records) {
+        for (Record record : insertedRecord) {
             TestUtils.assertRecordNotFound(record.getMetadata().getId(), record.getClass());
         }
     }
@@ -734,8 +738,8 @@ public class NutritionRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteNutritionRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(Collections.singletonList(getCompleteNutritionRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
diff --git a/tests/cts/src/android/healthconnect/cts/OvulationTestRecordTest.java b/tests/cts/src/android/healthconnect/cts/OvulationTestRecordTest.java
index 4d080439..8ade6f7d 100644
--- a/tests/cts/src/android/healthconnect/cts/OvulationTestRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/OvulationTestRecordTest.java
@@ -118,8 +118,9 @@ public class OvulationTestRecordTest {
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(OvulationTestRecord.class)
                                 .build());
-        OvulationTestRecord testRecord = getCompleteOvulationTestRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        OvulationTestRecord testRecord =
+                (OvulationTestRecord) TestUtils.insertRecord(getCompleteOvulationTestRecord());
         List<OvulationTestRecord> newOvulationTestRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(OvulationTestRecord.class)
@@ -139,8 +140,8 @@ public class OvulationTestRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        OvulationTestRecord testRecord = getCompleteOvulationTestRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+        OvulationTestRecord testRecord =
+                (OvulationTestRecord) TestUtils.insertRecord(getCompleteOvulationTestRecord());
         List<OvulationTestRecord> newOvulationTestRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(OvulationTestRecord.class)
@@ -166,8 +167,8 @@ public class OvulationTestRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        OvulationTestRecord testRecord = getCompleteOvulationTestRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+        OvulationTestRecord testRecord =
+                (OvulationTestRecord) TestUtils.insertRecord(getCompleteOvulationTestRecord());
         List<OvulationTestRecord> newOvulationTestRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(OvulationTestRecord.class)
@@ -249,8 +250,8 @@ public class OvulationTestRecordTest {
     @Test
     public void testDeleteOvulationTestRecord_recordId_filters() throws InterruptedException {
         List<Record> records =
-                List.of(getBaseOvulationTestRecord(), getCompleteOvulationTestRecord());
-        TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(getBaseOvulationTestRecord(), getCompleteOvulationTestRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -297,7 +298,7 @@ public class OvulationTestRecordTest {
         }
 
         TestUtils.verifyDeleteRecords(recordIds);
-        for (Record record : records) {
+        for (Record record : insertedRecord) {
             TestUtils.assertRecordNotFound(record.getMetadata().getId(), record.getClass());
         }
     }
@@ -461,8 +462,9 @@ public class OvulationTestRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteOvulationTestRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(
+                        Collections.singletonList(getCompleteOvulationTestRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
diff --git a/tests/cts/src/android/healthconnect/cts/OxygenSaturationRecordTest.java b/tests/cts/src/android/healthconnect/cts/OxygenSaturationRecordTest.java
index 559e5188..debfab67 100644
--- a/tests/cts/src/android/healthconnect/cts/OxygenSaturationRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/OxygenSaturationRecordTest.java
@@ -122,8 +122,10 @@ public class OxygenSaturationRecordTest {
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(OxygenSaturationRecord.class)
                                 .build());
-        OxygenSaturationRecord testRecord = getCompleteOxygenSaturationRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        OxygenSaturationRecord testRecord =
+                (OxygenSaturationRecord)
+                        TestUtils.insertRecord(getCompleteOxygenSaturationRecord());
         List<OxygenSaturationRecord> newOxygenSaturationRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(OxygenSaturationRecord.class)
@@ -145,8 +147,10 @@ public class OxygenSaturationRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        OxygenSaturationRecord testRecord = getCompleteOxygenSaturationRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        OxygenSaturationRecord testRecord =
+                (OxygenSaturationRecord)
+                        TestUtils.insertRecord(getCompleteOxygenSaturationRecord());
         List<OxygenSaturationRecord> newOxygenSaturationRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(OxygenSaturationRecord.class)
@@ -172,8 +176,10 @@ public class OxygenSaturationRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        OxygenSaturationRecord testRecord = getCompleteOxygenSaturationRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        OxygenSaturationRecord testRecord =
+                (OxygenSaturationRecord)
+                        TestUtils.insertRecord(getCompleteOxygenSaturationRecord());
         List<OxygenSaturationRecord> newOxygenSaturationRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(OxygenSaturationRecord.class)
@@ -256,8 +262,10 @@ public class OxygenSaturationRecordTest {
     @Test
     public void testDeleteOxygenSaturationRecord_recordId_filters() throws InterruptedException {
         List<Record> records =
-                List.of(getBaseOxygenSaturationRecord(), getCompleteOxygenSaturationRecord());
-        TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(
+                                getBaseOxygenSaturationRecord(),
+                                getCompleteOxygenSaturationRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -296,10 +304,12 @@ public class OxygenSaturationRecordTest {
     @Test
     public void testDeleteOxygenSaturationRecord_usingIds() throws InterruptedException {
         List<Record> records =
-                List.of(getBaseOxygenSaturationRecord(), getCompleteOxygenSaturationRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(
+                                getBaseOxygenSaturationRecord(),
+                                getCompleteOxygenSaturationRecord()));
         List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
-        for (Record record : insertedRecord) {
+        for (Record record : records) {
             recordIds.add(RecordIdFilter.fromId(record.getClass(), record.getMetadata().getId()));
         }
 
@@ -479,8 +489,9 @@ public class OxygenSaturationRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteOxygenSaturationRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> insertedRecords =
+                TestUtils.insertRecords(
+                        Collections.singletonList(getCompleteOxygenSaturationRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
@@ -489,7 +500,10 @@ public class OxygenSaturationRecordTest {
                                 .map(Metadata::getId)
                                 .toList())
                 .containsExactlyElementsIn(
-                        testRecord.stream().map(Record::getMetadata).map(Metadata::getId).toList());
+                        insertedRecords.stream()
+                                .map(Record::getMetadata)
+                                .map(Metadata::getId)
+                                .toList());
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
         TestUtils.verifyDeleteRecords(