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

This reverts commit 020e262a9b7b3611466c6ff1efbeef2d41f9b510.

Reason for revert: test if build assemble fixed

Change-Id: I387dee5931fe0535809aa6372f0a881a14abb094

14 files changed, 204 insertions, 276 deletions

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