Use response from calls to insertRecords in tests (datatypes P-W)

Most tests assert the initial record passed into insertRecords.
Since we mutate the inserted records to add the uuid this
currently works, but in a follow up change we'll update the
insertRecords API so it no longer mutates the metadata. This
requires changes to most of the cts tests.

Bug: 314128192
Test: atest
Change-Id: I9ecf3dffcda332e9db69de8511d47871bfa53e7b
Merged-In: I9ecf3dffcda332e9db69de8511d47871bfa53e7b
(cherry picked from commit c43e419d76c0de56d7f1fc3834ee12dfb4320e37)

12 files changed, 220 insertions, 170 deletions

diff --git a/tests/cts/src/android/healthconnect/cts/PowerRecordTest.java b/tests/cts/src/android/healthconnect/cts/PowerRecordTest.java
index e75f7be3..1d7936ba 100644
--- a/tests/cts/src/android/healthconnect/cts/PowerRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/PowerRecordTest.java
@@ -128,8 +128,8 @@ public class PowerRecordTest {
         List<PowerRecord> oldPowerRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(PowerRecord.class).build());
-        PowerRecord testRecord = getCompletePowerRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        PowerRecord testRecord = (PowerRecord) TestUtils.insertRecord(getCompletePowerRecord());
         List<PowerRecord> newPowerRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(PowerRecord.class).build());
@@ -144,8 +144,8 @@ public class PowerRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        PowerRecord testRecord = getCompletePowerRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        PowerRecord testRecord = (PowerRecord) TestUtils.insertRecord(getCompletePowerRecord());
         List<PowerRecord> newPowerRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(PowerRecord.class)
@@ -165,8 +165,8 @@ public class PowerRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        PowerRecord testRecord = getCompletePowerRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        PowerRecord testRecord = (PowerRecord) TestUtils.insertRecord(getCompletePowerRecord());
         List<PowerRecord> newPowerRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(PowerRecord.class)
@@ -224,8 +224,8 @@ public class PowerRecordTest {
 
     @Test
     public void testDeletePowerRecord_recordId_filters() throws InterruptedException {
-        List<Record> records = List.of(getBasePowerRecord(), getCompletePowerRecord());
-        TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(List.of(getBasePowerRecord(), getCompletePowerRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -262,10 +262,10 @@ public class PowerRecordTest {
 
     @Test
     public void testDeletePowerRecord_usingIds() throws InterruptedException {
-        List<Record> records = List.of(getBasePowerRecord(), getCompletePowerRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(List.of(getBasePowerRecord(), getCompletePowerRecord()));
         List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
-        for (Record record : insertedRecord) {
+        for (Record record : records) {
             recordIds.add(RecordIdFilter.fromId(record.getClass(), record.getMetadata().getId()));
         }
 
@@ -476,8 +476,8 @@ public class PowerRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompletePowerRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(Collections.singletonList(getCompletePowerRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
diff --git a/tests/cts/src/android/healthconnect/cts/RespiratoryRateRecordTest.java b/tests/cts/src/android/healthconnect/cts/RespiratoryRateRecordTest.java
index e816d51b..72b16aee 100644
--- a/tests/cts/src/android/healthconnect/cts/RespiratoryRateRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/RespiratoryRateRecordTest.java
@@ -120,8 +120,9 @@ public class RespiratoryRateRecordTest {
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(RespiratoryRateRecord.class)
                                 .build());
-        RespiratoryRateRecord testRecord = getCompleteRespiratoryRateRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        RespiratoryRateRecord testRecord =
+                (RespiratoryRateRecord) TestUtils.insertRecord(getCompleteRespiratoryRateRecord());
         List<RespiratoryRateRecord> newRespiratoryRateRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(RespiratoryRateRecord.class)
@@ -142,8 +143,9 @@ public class RespiratoryRateRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        RespiratoryRateRecord testRecord = getCompleteRespiratoryRateRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        RespiratoryRateRecord testRecord =
+                (RespiratoryRateRecord) TestUtils.insertRecord(getCompleteRespiratoryRateRecord());
         List<RespiratoryRateRecord> newRespiratoryRateRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(RespiratoryRateRecord.class)
@@ -169,8 +171,9 @@ public class RespiratoryRateRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        RespiratoryRateRecord testRecord = getCompleteRespiratoryRateRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        RespiratoryRateRecord testRecord =
+                (RespiratoryRateRecord) TestUtils.insertRecord(getCompleteRespiratoryRateRecord());
         List<RespiratoryRateRecord> newRespiratoryRateRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(RespiratoryRateRecord.class)
@@ -253,8 +256,10 @@ public class RespiratoryRateRecordTest {
     @Test
     public void testDeleteRespiratoryRateRecord_recordId_filters() throws InterruptedException {
         List<Record> records =
-                List.of(getBaseRespiratoryRateRecord(), getCompleteRespiratoryRateRecord());
-        TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(
+                                getBaseRespiratoryRateRecord(),
+                                getCompleteRespiratoryRateRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -293,10 +298,12 @@ public class RespiratoryRateRecordTest {
     @Test
     public void testDeleteRespiratoryRateRecord_usingIds() throws InterruptedException {
         List<Record> records =
-                List.of(getBaseRespiratoryRateRecord(), getCompleteRespiratoryRateRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(
+                                getBaseRespiratoryRateRecord(),
+                                getCompleteRespiratoryRateRecord()));
         List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
-        for (Record record : insertedRecord) {
+        for (Record record : records) {
             recordIds.add(RecordIdFilter.fromId(record.getClass(), record.getMetadata().getId()));
         }
 
@@ -475,8 +482,9 @@ public class RespiratoryRateRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteRespiratoryRateRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(
+                        Collections.singletonList(getCompleteRespiratoryRateRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
diff --git a/tests/cts/src/android/healthconnect/cts/RestingHeartRateRecordTest.java b/tests/cts/src/android/healthconnect/cts/RestingHeartRateRecordTest.java
index dbfc4250..1b9546b0 100644
--- a/tests/cts/src/android/healthconnect/cts/RestingHeartRateRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/RestingHeartRateRecordTest.java
@@ -133,8 +133,10 @@ public class RestingHeartRateRecordTest {
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(RestingHeartRateRecord.class)
                                 .build());
-        RestingHeartRateRecord testRecord = getCompleteRestingHeartRateRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        RestingHeartRateRecord testRecord =
+                (RestingHeartRateRecord)
+                        TestUtils.insertRecord(getCompleteRestingHeartRateRecord());
         List<RestingHeartRateRecord> newRestingHeartRateRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(RestingHeartRateRecord.class)
@@ -156,8 +158,10 @@ public class RestingHeartRateRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        RestingHeartRateRecord testRecord = getCompleteRestingHeartRateRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        RestingHeartRateRecord testRecord =
+                (RestingHeartRateRecord)
+                        TestUtils.insertRecord(getCompleteRestingHeartRateRecord());
         List<RestingHeartRateRecord> newRestingHeartRateRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(RestingHeartRateRecord.class)
@@ -183,8 +187,10 @@ public class RestingHeartRateRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        RestingHeartRateRecord testRecord = getCompleteRestingHeartRateRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        RestingHeartRateRecord testRecord =
+                (RestingHeartRateRecord)
+                        TestUtils.insertRecord(getCompleteRestingHeartRateRecord());
         List<RestingHeartRateRecord> newRestingHeartRateRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(RestingHeartRateRecord.class)
@@ -267,8 +273,10 @@ public class RestingHeartRateRecordTest {
     @Test
     public void testDeleteRestingHeartRateRecord_recordId_filters() throws InterruptedException {
         List<Record> records =
-                List.of(getBaseRestingHeartRateRecord(), getCompleteRestingHeartRateRecord());
-        TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(
+                                getBaseRestingHeartRateRecord(),
+                                getCompleteRestingHeartRateRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -307,10 +315,12 @@ public class RestingHeartRateRecordTest {
     @Test
     public void testDeleteRestingHeartRateRecord_usingIds() throws InterruptedException {
         List<Record> records =
-                List.of(getBaseRestingHeartRateRecord(), getCompleteRestingHeartRateRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(
+                                getBaseRestingHeartRateRecord(),
+                                getCompleteRestingHeartRateRecord()));
         List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
-        for (Record record : insertedRecord) {
+        for (Record record : records) {
             recordIds.add(RecordIdFilter.fromId(record.getClass(), record.getMetadata().getId()));
         }
 
@@ -535,7 +545,7 @@ public class RestingHeartRateRecordTest {
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
         List<Record> testRecord = Collections.singletonList(getCompleteRestingHeartRateRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> insertedRecords = TestUtils.insertRecords(testRecord);
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
@@ -544,7 +554,10 @@ public class RestingHeartRateRecordTest {
                                 .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(
diff --git a/tests/cts/src/android/healthconnect/cts/SexualActivityRecordTest.java b/tests/cts/src/android/healthconnect/cts/SexualActivityRecordTest.java
index 50cc1c67..73d2f50a 100644
--- a/tests/cts/src/android/healthconnect/cts/SexualActivityRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/SexualActivityRecordTest.java
@@ -118,8 +118,9 @@ public class SexualActivityRecordTest {
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(SexualActivityRecord.class)
                                 .build());
-        SexualActivityRecord testRecord = getCompleteSexualActivityRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        SexualActivityRecord testRecord =
+                (SexualActivityRecord) TestUtils.insertRecord(getCompleteSexualActivityRecord());
         List<SexualActivityRecord> newSexualActivityRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(SexualActivityRecord.class)
@@ -139,8 +140,9 @@ public class SexualActivityRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        SexualActivityRecord testRecord = getCompleteSexualActivityRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        SexualActivityRecord testRecord =
+                (SexualActivityRecord) TestUtils.insertRecord(getCompleteSexualActivityRecord());
         List<SexualActivityRecord> newSexualActivityRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(SexualActivityRecord.class)
@@ -166,8 +168,9 @@ public class SexualActivityRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        SexualActivityRecord testRecord = getCompleteSexualActivityRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        SexualActivityRecord testRecord =
+                (SexualActivityRecord) TestUtils.insertRecord(getCompleteSexualActivityRecord());
         List<SexualActivityRecord> newSexualActivityRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(SexualActivityRecord.class)
@@ -249,8 +252,8 @@ public class SexualActivityRecordTest {
     @Test
     public void testDeleteSexualActivityRecord_recordId_filters() throws InterruptedException {
         List<Record> records =
-                List.of(getBaseSexualActivityRecord(), getCompleteSexualActivityRecord());
-        TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(getBaseSexualActivityRecord(), getCompleteSexualActivityRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -289,10 +292,10 @@ public class SexualActivityRecordTest {
     @Test
     public void testDeleteSexualActivityRecord_usingIds() throws InterruptedException {
         List<Record> records =
-                List.of(getBaseSexualActivityRecord(), getCompleteSexualActivityRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(getBaseSexualActivityRecord(), getCompleteSexualActivityRecord()));
         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,9 @@ public class SexualActivityRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteSexualActivityRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(
+                        Collections.singletonList(getCompleteSexualActivityRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
diff --git a/tests/cts/src/android/healthconnect/cts/SleepSessionRecordTest.java b/tests/cts/src/android/healthconnect/cts/SleepSessionRecordTest.java
index 3bd0a15f..46b52a6a 100644
--- a/tests/cts/src/android/healthconnect/cts/SleepSessionRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/SleepSessionRecordTest.java
@@ -216,15 +216,14 @@ public class SleepSessionRecordTest {
 
     @Test
     public void testReadById_insertAndReadByIdOne_recordsAreEqual() throws InterruptedException {
-        List<Record> records = List.of(TestUtils.buildSleepSession());
-        TestUtils.insertRecords(records);
+        SleepSessionRecord insertedRecord =
+                (SleepSessionRecord) TestUtils.insertRecord(TestUtils.buildSleepSession());
 
         ReadRecordsRequestUsingIds.Builder<SleepSessionRecord> request =
                 new ReadRecordsRequestUsingIds.Builder<>(SleepSessionRecord.class);
-        request.addId(records.get(0).getMetadata().getId());
+        request.addId(insertedRecord.getMetadata().getId());
 
         SleepSessionRecord readRecord = TestUtils.readRecords(request.build()).get(0);
-        SleepSessionRecord insertedRecord = (SleepSessionRecord) records.get(0);
         assertThat(readRecord.getMetadata()).isEqualTo(insertedRecord.getMetadata());
         assertThat(CharSequence.compare(readRecord.getTitle(), insertedRecord.getTitle()))
                 .isEqualTo(0);
@@ -236,8 +235,9 @@ public class SleepSessionRecordTest {
 
     @Test
     public void testReadById_insertAndReadById_recordsAreEqual() throws InterruptedException {
-        List<Record> records = List.of(TestUtils.buildSleepSession(), buildSleepSessionMinimal());
-        TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(
+                        List.of(TestUtils.buildSleepSession(), buildSleepSessionMinimal()));
 
         ReadRecordsRequestUsingIds.Builder<SleepSessionRecord> request =
                 new ReadRecordsRequestUsingIds.Builder<>(SleepSessionRecord.class);
@@ -250,8 +250,9 @@ public class SleepSessionRecordTest {
     @Test
     public void testReadByClientId_insertAndReadByClientId_recordsAreEqual()
             throws InterruptedException {
-        List<Record> records = List.of(TestUtils.buildSleepSession(), buildSleepSessionMinimal());
-        TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(
+                        List.of(TestUtils.buildSleepSession(), buildSleepSessionMinimal()));
 
         ReadRecordsRequestUsingIds.Builder<SleepSessionRecord> request =
                 new ReadRecordsRequestUsingIds.Builder<>(SleepSessionRecord.class);
@@ -264,26 +265,28 @@ public class SleepSessionRecordTest {
     @Test
     public void testReadByClientId_insertAndReadByDefaultFilter_filteredAll()
             throws InterruptedException {
-        List<Record> records = List.of(TestUtils.buildSleepSession(), buildSleepSessionMinimal());
-        TestUtils.insertRecords(records);
+        List<Record> insertedRecords =
+                TestUtils.insertRecords(
+                        List.of(TestUtils.buildSleepSession(), buildSleepSessionMinimal()));
 
         List<SleepSessionRecord> readRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(SleepSessionRecord.class)
                                 .build());
-        assertRecordsAreEqual(records, readRecords);
+        assertRecordsAreEqual(insertedRecords, readRecords);
     }
 
     @Test
     public void testDeleteRecords_insertAndDeleteById_recordsNotFoundAnymore()
             throws InterruptedException {
-        List<Record> records = List.of(TestUtils.buildSleepSession(), buildSleepSessionMinimal());
-        List<Record> insertedRecords = TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(
+                        List.of(TestUtils.buildSleepSession(), buildSleepSessionMinimal()));
 
         TestUtils.assertRecordFound(records.get(0).getMetadata().getId(), SleepSessionRecord.class);
         TestUtils.assertRecordFound(records.get(1).getMetadata().getId(), SleepSessionRecord.class);
 
-        TestUtils.deleteRecords(insertedRecords);
+        TestUtils.deleteRecords(records);
 
         TestUtils.assertRecordNotFound(
                 records.get(0).getMetadata().getId(), SleepSessionRecord.class);
@@ -424,8 +427,8 @@ public class SleepSessionRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(buildSleepSession());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(Collections.singletonList(buildSleepSession()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
diff --git a/tests/cts/src/android/healthconnect/cts/SpeedRecordTest.java b/tests/cts/src/android/healthconnect/cts/SpeedRecordTest.java
index 7677a428..27c34705 100644
--- a/tests/cts/src/android/healthconnect/cts/SpeedRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/SpeedRecordTest.java
@@ -95,7 +95,11 @@ public class SpeedRecordTest {
 
     @Test
     public void testReadSpeedRecord_usingIds() throws InterruptedException {
-        testReadSpeedRecordIds();
+        List<Record> recordList =
+                TestUtils.insertRecords(
+                        Arrays.asList(getCompleteSpeedRecord(), getCompleteSpeedRecord()));
+
+        readSpeedRecordUsingIds(recordList);
     }
 
     @Test
@@ -130,8 +134,8 @@ public class SpeedRecordTest {
         List<SpeedRecord> oldSpeedRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(SpeedRecord.class).build());
-        SpeedRecord testRecord = getCompleteSpeedRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        SpeedRecord testRecord = (SpeedRecord) TestUtils.insertRecord(getCompleteSpeedRecord());
         List<SpeedRecord> newSpeedRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(SpeedRecord.class).build());
@@ -146,8 +150,8 @@ public class SpeedRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        SpeedRecord testRecord = getCompleteSpeedRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        SpeedRecord testRecord = (SpeedRecord) TestUtils.insertRecord(getCompleteSpeedRecord());
         List<SpeedRecord> newSpeedRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(SpeedRecord.class)
@@ -168,8 +172,8 @@ public class SpeedRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        SpeedRecord testRecord = getCompleteSpeedRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        SpeedRecord testRecord = (SpeedRecord) TestUtils.insertRecord(getCompleteSpeedRecord());
         List<SpeedRecord> newSpeedRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(SpeedRecord.class)
@@ -227,8 +231,8 @@ public class SpeedRecordTest {
 
     @Test
     public void testDeleteSpeedRecord_recordId_filters() throws InterruptedException {
-        List<Record> records = List.of(getBaseSpeedRecord(), getCompleteSpeedRecord());
-        TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(List.of(getBaseSpeedRecord(), getCompleteSpeedRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -265,10 +269,10 @@ public class SpeedRecordTest {
 
     @Test
     public void testDeleteSpeedRecord_usingIds() throws InterruptedException {
-        List<Record> records = List.of(getBaseSpeedRecord(), getCompleteSpeedRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(List.of(getBaseSpeedRecord(), getCompleteSpeedRecord()));
         List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
-        for (Record record : insertedRecord) {
+        for (Record record : records) {
             recordIds.add(RecordIdFilter.fromId(record.getClass(), record.getMetadata().getId()));
         }
 
@@ -331,8 +335,8 @@ public class SpeedRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteSpeedRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(Collections.singletonList(getCompleteSpeedRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
@@ -391,11 +395,6 @@ public class SpeedRecordTest {
         }
     }
 
-    private void testReadSpeedRecordIds() throws InterruptedException {
-        List<Record> recordList = Arrays.asList(getCompleteSpeedRecord(), getCompleteSpeedRecord());
-        readSpeedRecordUsingIds(recordList);
-    }
-
     private void readSpeedRecordUsingClientId(List<Record> insertedRecord)
             throws InterruptedException {
         ReadRecordsRequestUsingIds.Builder<SpeedRecord> request =
diff --git a/tests/cts/src/android/healthconnect/cts/StepsCadenceRecordTest.java b/tests/cts/src/android/healthconnect/cts/StepsCadenceRecordTest.java
index 1465a946..6e0bffab 100644
--- a/tests/cts/src/android/healthconnect/cts/StepsCadenceRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/StepsCadenceRecordTest.java
@@ -133,8 +133,9 @@ public class StepsCadenceRecordTest {
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(StepsCadenceRecord.class)
                                 .build());
-        StepsCadenceRecord testRecord = getCompleteStepsCadenceRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        StepsCadenceRecord testRecord =
+                (StepsCadenceRecord) TestUtils.insertRecord(getCompleteStepsCadenceRecord());
         List<StepsCadenceRecord> newStepsCadenceRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(StepsCadenceRecord.class)
@@ -151,8 +152,9 @@ public class StepsCadenceRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        StepsCadenceRecord testRecord = getCompleteStepsCadenceRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        StepsCadenceRecord testRecord =
+                (StepsCadenceRecord) TestUtils.insertRecord(getCompleteStepsCadenceRecord());
         List<StepsCadenceRecord> newStepsCadenceRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(StepsCadenceRecord.class)
@@ -175,8 +177,9 @@ public class StepsCadenceRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        StepsCadenceRecord testRecord = getCompleteStepsCadenceRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        StepsCadenceRecord testRecord =
+                (StepsCadenceRecord) TestUtils.insertRecord(getCompleteStepsCadenceRecord());
         List<StepsCadenceRecord> newStepsCadenceRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(StepsCadenceRecord.class)
@@ -238,8 +241,8 @@ public class StepsCadenceRecordTest {
     @Test
     public void testDeleteStepsCadenceRecord_recordId_filters() throws InterruptedException {
         List<Record> records =
-                List.of(getBaseStepsCadenceRecord(), getCompleteStepsCadenceRecord());
-        TestUtils.insertRecords(records);
+                TestUtils.insertRecords(
+                        List.of(getBaseStepsCadenceRecord(), getCompleteStepsCadenceRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -277,16 +280,16 @@ public class StepsCadenceRecordTest {
 
     @Test
     public void testDeleteStepsCadenceRecord_usingIds() throws InterruptedException {
-        List<Record> records =
-                List.of(getBaseStepsCadenceRecord(), getCompleteStepsCadenceRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
-        List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
+        List<Record> insertedRecord =
+                TestUtils.insertRecords(
+                        List.of(getBaseStepsCadenceRecord(), getCompleteStepsCadenceRecord()));
+        List<RecordIdFilter> recordIds = new ArrayList<>(insertedRecord.size());
         for (Record record : insertedRecord) {
             recordIds.add(RecordIdFilter.fromId(record.getClass(), record.getMetadata().getId()));
         }
 
         TestUtils.verifyDeleteRecords(recordIds);
-        for (Record record : records) {
+        for (Record record : insertedRecord) {
             TestUtils.assertRecordNotFound(record.getMetadata().getId(), record.getClass());
         }
     }
@@ -458,8 +461,8 @@ public class StepsCadenceRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteStepsCadenceRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(Collections.singletonList(getCompleteStepsCadenceRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
diff --git a/tests/cts/src/android/healthconnect/cts/StepsRecordTest.java b/tests/cts/src/android/healthconnect/cts/StepsRecordTest.java
index 7b6b40e1..cdf3b045 100644
--- a/tests/cts/src/android/healthconnect/cts/StepsRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/StepsRecordTest.java
@@ -168,8 +168,9 @@ public class StepsRecordTest {
                         new ReadRecordsRequestUsingFilters.Builder<>(StepsRecord.class)
                                 .setAscending(true)
                                 .build());
-        StepsRecord testRecord = TestUtils.getCompleteStepsRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        StepsRecord testRecord =
+                (StepsRecord) TestUtils.insertRecord(TestUtils.getCompleteStepsRecord());
         List<StepsRecord> newStepsRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(StepsRecord.class)
@@ -186,8 +187,9 @@ public class StepsRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        StepsRecord testRecord = TestUtils.getCompleteStepsRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        StepsRecord testRecord =
+                (StepsRecord) TestUtils.insertRecord(TestUtils.getCompleteStepsRecord());
         List<StepsRecord> newStepsRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(StepsRecord.class)
@@ -219,8 +221,9 @@ public class StepsRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        StepsRecord testRecord = TestUtils.getCompleteStepsRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        StepsRecord testRecord =
+                (StepsRecord) TestUtils.insertRecord(TestUtils.getCompleteStepsRecord());
         List<StepsRecord> newStepsRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(StepsRecord.class)
@@ -250,9 +253,8 @@ public class StepsRecordTest {
 
     @Test
     public void testReadStepsRecordUsingFilters_withPageSize() throws InterruptedException {
-        List<Record> recordList =
-                Arrays.asList(getStepsRecord_minusDays(1), getStepsRecord_minusDays(2));
-        TestUtils.insertRecords(recordList);
+        TestUtils.insertRecords(
+                Arrays.asList(getStepsRecord_minusDays(1), getStepsRecord_minusDays(2)));
         ReadRecordsResponse<StepsRecord> response =
                 readRecordsWithPagination(
                         new ReadRecordsRequestUsingFilters.Builder<>(StepsRecord.class)
@@ -549,8 +551,9 @@ public class StepsRecordTest {
 
     @Test
     public void testDeleteStepsRecord_recordId_filters() throws InterruptedException {
-        List<Record> records = List.of(getBaseStepsRecord(), TestUtils.getCompleteStepsRecord());
-        TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(
+                        List.of(getBaseStepsRecord(), TestUtils.getCompleteStepsRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -587,10 +590,11 @@ public class StepsRecordTest {
 
     @Test
     public void testDeleteStepsRecord_usingIds() throws InterruptedException {
-        List<Record> records = List.of(getBaseStepsRecord(), TestUtils.getCompleteStepsRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(
+                        List.of(getBaseStepsRecord(), TestUtils.getCompleteStepsRecord()));
         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) {
@@ -607,10 +611,11 @@ public class StepsRecordTest {
 
     @Test
     public void testDeleteStepsRecord_usingInvalidClientIds() throws InterruptedException {
-        List<Record> records = List.of(getBaseStepsRecord(), TestUtils.getCompleteStepsRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(
+                        List.of(getBaseStepsRecord(), TestUtils.getCompleteStepsRecord()));
         List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
-        for (Record record : insertedRecord) {
+        for (Record record : records) {
             recordIds.add(
                     RecordIdFilter.fromClientRecordId(
                             record.getClass(), record.getMetadata().getId()));
@@ -1084,8 +1089,9 @@ public class StepsRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(TestUtils.getCompleteStepsRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(
+                        Collections.singletonList(TestUtils.getCompleteStepsRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
diff --git a/tests/cts/src/android/healthconnect/cts/TotalCaloriesBurnedRecordTest.java b/tests/cts/src/android/healthconnect/cts/TotalCaloriesBurnedRecordTest.java
index 9d44665e..abefafb0 100644
--- a/tests/cts/src/android/healthconnect/cts/TotalCaloriesBurnedRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/TotalCaloriesBurnedRecordTest.java
@@ -139,8 +139,10 @@ public class TotalCaloriesBurnedRecordTest {
                         new ReadRecordsRequestUsingFilters.Builder<>(
                                         TotalCaloriesBurnedRecord.class)
                                 .build());
-        TotalCaloriesBurnedRecord testRecord = getCompleteTotalCaloriesBurnedRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        TotalCaloriesBurnedRecord testRecord =
+                (TotalCaloriesBurnedRecord)
+                        TestUtils.insertRecord(getCompleteTotalCaloriesBurnedRecord());
         List<TotalCaloriesBurnedRecord> newTotalCaloriesBurnedRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(
@@ -163,8 +165,10 @@ public class TotalCaloriesBurnedRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        TotalCaloriesBurnedRecord testRecord = getCompleteTotalCaloriesBurnedRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        TotalCaloriesBurnedRecord testRecord =
+                (TotalCaloriesBurnedRecord)
+                        TestUtils.insertRecord(getCompleteTotalCaloriesBurnedRecord());
         List<TotalCaloriesBurnedRecord> newTotalCaloriesBurnedRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(
@@ -192,8 +196,10 @@ public class TotalCaloriesBurnedRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        TotalCaloriesBurnedRecord testRecord = getCompleteTotalCaloriesBurnedRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        TotalCaloriesBurnedRecord testRecord =
+                (TotalCaloriesBurnedRecord)
+                        TestUtils.insertRecord(getCompleteTotalCaloriesBurnedRecord());
         List<TotalCaloriesBurnedRecord> newTotalCaloriesBurnedRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(
@@ -422,8 +428,9 @@ public class TotalCaloriesBurnedRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteTotalCaloriesBurnedRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(
+                        Collections.singletonList(getCompleteTotalCaloriesBurnedRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
diff --git a/tests/cts/src/android/healthconnect/cts/Vo2MaxRecordTest.java b/tests/cts/src/android/healthconnect/cts/Vo2MaxRecordTest.java
index 52af3768..ea0f11f1 100644
--- a/tests/cts/src/android/healthconnect/cts/Vo2MaxRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/Vo2MaxRecordTest.java
@@ -116,8 +116,8 @@ public class Vo2MaxRecordTest {
         List<Vo2MaxRecord> oldVo2MaxRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(Vo2MaxRecord.class).build());
-        Vo2MaxRecord testRecord = getCompleteVo2MaxRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        Vo2MaxRecord testRecord = (Vo2MaxRecord) TestUtils.insertRecord(getCompleteVo2MaxRecord());
         List<Vo2MaxRecord> newVo2MaxRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(Vo2MaxRecord.class).build());
@@ -132,8 +132,8 @@ public class Vo2MaxRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        Vo2MaxRecord testRecord = getCompleteVo2MaxRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        Vo2MaxRecord testRecord = (Vo2MaxRecord) TestUtils.insertRecord(getCompleteVo2MaxRecord());
         List<Vo2MaxRecord> newVo2MaxRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(Vo2MaxRecord.class)
@@ -154,8 +154,8 @@ public class Vo2MaxRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        Vo2MaxRecord testRecord = getCompleteVo2MaxRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        Vo2MaxRecord testRecord = (Vo2MaxRecord) TestUtils.insertRecord(getCompleteVo2MaxRecord());
         List<Vo2MaxRecord> newVo2MaxRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(Vo2MaxRecord.class)
@@ -236,8 +236,8 @@ public class Vo2MaxRecordTest {
 
     @Test
     public void testDeleteVo2MaxRecord_recordId_filters() throws InterruptedException {
-        List<Record> records = List.of(getBaseVo2MaxRecord(), getCompleteVo2MaxRecord());
-        TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(List.of(getBaseVo2MaxRecord(), getCompleteVo2MaxRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -274,10 +274,10 @@ public class Vo2MaxRecordTest {
 
     @Test
     public void testDeleteVo2MaxRecord_usingIds() throws InterruptedException {
-        List<Record> records = List.of(getBaseVo2MaxRecord(), getCompleteVo2MaxRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(List.of(getBaseVo2MaxRecord(), getCompleteVo2MaxRecord()));
         List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
-        for (Record record : insertedRecord) {
+        for (Record record : records) {
             recordIds.add(RecordIdFilter.fromId(record.getClass(), record.getMetadata().getId()));
         }
 
@@ -445,8 +445,8 @@ public class Vo2MaxRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteVo2MaxRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(Collections.singletonList(getCompleteVo2MaxRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
diff --git a/tests/cts/src/android/healthconnect/cts/WeightRecordTest.java b/tests/cts/src/android/healthconnect/cts/WeightRecordTest.java
index 06febc42..ea927aa3 100644
--- a/tests/cts/src/android/healthconnect/cts/WeightRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/WeightRecordTest.java
@@ -142,8 +142,8 @@ public class WeightRecordTest {
         List<WeightRecord> oldWeightRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(WeightRecord.class).build());
-        WeightRecord testRecord = getCompleteWeightRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        WeightRecord testRecord = (WeightRecord) TestUtils.insertRecord(getCompleteWeightRecord());
         List<WeightRecord> newWeightRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(WeightRecord.class).build());
@@ -158,8 +158,8 @@ public class WeightRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        WeightRecord testRecord = getCompleteWeightRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        WeightRecord testRecord = (WeightRecord) TestUtils.insertRecord(getCompleteWeightRecord());
         List<WeightRecord> newWeightRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(WeightRecord.class)
@@ -180,8 +180,8 @@ public class WeightRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        WeightRecord testRecord = getCompleteWeightRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        WeightRecord testRecord = (WeightRecord) TestUtils.insertRecord(getCompleteWeightRecord());
         List<WeightRecord> newWeightRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(WeightRecord.class)
@@ -367,8 +367,8 @@ public class WeightRecordTest {
 
     @Test
     public void testDeleteWeightRecord_recordId_filters() throws InterruptedException {
-        List<Record> records = List.of(getBaseWeightRecord(), getCompleteWeightRecord());
-        TestUtils.insertRecords(records);
+        List<Record> records =
+                TestUtils.insertRecords(List.of(getBaseWeightRecord(), getCompleteWeightRecord()));
 
         for (Record record : records) {
             TestUtils.verifyDeleteRecords(
@@ -405,15 +405,15 @@ public class WeightRecordTest {
 
     @Test
     public void testDeleteWeightRecord_usingIds() throws InterruptedException {
-        List<Record> records = List.of(getBaseWeightRecord(), getCompleteWeightRecord());
-        List<Record> insertedRecord = TestUtils.insertRecords(records);
-        List<RecordIdFilter> recordIds = new ArrayList<>(records.size());
-        for (Record record : insertedRecord) {
+        List<Record> insertedRecords =
+                TestUtils.insertRecords(List.of(getBaseWeightRecord(), getCompleteWeightRecord()));
+        List<RecordIdFilter> recordIds = new ArrayList<>(insertedRecords.size());
+        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());
         }
     }
@@ -572,8 +572,8 @@ public class WeightRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteWeightRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(Collections.singletonList(getCompleteWeightRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
diff --git a/tests/cts/src/android/healthconnect/cts/WheelchairPushesRecordTest.java b/tests/cts/src/android/healthconnect/cts/WheelchairPushesRecordTest.java
index 66efed7b..64885b94 100644
--- a/tests/cts/src/android/healthconnect/cts/WheelchairPushesRecordTest.java
+++ b/tests/cts/src/android/healthconnect/cts/WheelchairPushesRecordTest.java
@@ -130,8 +130,10 @@ public class WheelchairPushesRecordTest {
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(WheelchairPushesRecord.class)
                                 .build());
-        WheelchairPushesRecord testRecord = getCompleteWheelchairPushesRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        WheelchairPushesRecord testRecord =
+                (WheelchairPushesRecord)
+                        TestUtils.insertRecord(getCompleteWheelchairPushesRecord());
         List<WheelchairPushesRecord> newWheelchairPushesRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(WheelchairPushesRecord.class)
@@ -153,8 +155,10 @@ public class WheelchairPushesRecordTest {
                         .setStartTime(Instant.now())
                         .setEndTime(Instant.now().plusMillis(3000))
                         .build();
-        WheelchairPushesRecord testRecord = getCompleteWheelchairPushesRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        WheelchairPushesRecord testRecord =
+                (WheelchairPushesRecord)
+                        TestUtils.insertRecord(getCompleteWheelchairPushesRecord());
         List<WheelchairPushesRecord> newWheelchairPushesRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(WheelchairPushesRecord.class)
@@ -180,8 +184,10 @@ public class WheelchairPushesRecordTest {
                                                 .setPackageName(context.getPackageName())
                                                 .build())
                                 .build());
-        WheelchairPushesRecord testRecord = getCompleteWheelchairPushesRecord();
-        TestUtils.insertRecords(Collections.singletonList(testRecord));
+
+        WheelchairPushesRecord testRecord =
+                (WheelchairPushesRecord)
+                        TestUtils.insertRecord(getCompleteWheelchairPushesRecord());
         List<WheelchairPushesRecord> newWheelchairPushesRecords =
                 TestUtils.readRecords(
                         new ReadRecordsRequestUsingFilters.Builder<>(WheelchairPushesRecord.class)
@@ -416,8 +422,9 @@ public class WheelchairPushesRecordTest {
         assertThat(response.getUpsertedRecords().size()).isEqualTo(0);
         assertThat(response.getDeletedLogs().size()).isEqualTo(0);
 
-        List<Record> testRecord = Collections.singletonList(getCompleteWheelchairPushesRecord());
-        TestUtils.insertRecords(testRecord);
+        List<Record> testRecord =
+                TestUtils.insertRecords(
+                        Collections.singletonList(getCompleteWheelchairPushesRecord()));
         response = TestUtils.getChangeLogs(changeLogsRequest);
         assertThat(response.getUpsertedRecords().size()).isEqualTo(1);
         assertThat(
@@ -451,16 +458,16 @@ public class WheelchairPushesRecordTest {
 
     private void readWheelchairPushesRecordUsingIds(List<Record> recordList)
             throws InterruptedException {
-        List<Record> insertedRecords = TestUtils.insertRecords(recordList);
+        List<Record> records = TestUtils.insertRecords(recordList);
         ReadRecordsRequestUsingIds.Builder<WheelchairPushesRecord> request =
                 new ReadRecordsRequestUsingIds.Builder<>(WheelchairPushesRecord.class);
-        for (Record record : insertedRecords) {
+        for (Record record : records) {
             request.addId(record.getMetadata().getId());
         }
         List<WheelchairPushesRecord> result = TestUtils.readRecords(request.build());
-        assertThat(result).hasSize(insertedRecords.size());
-        assertThat(result.size()).isEqualTo(insertedRecords.size());
-        assertThat(result).containsExactlyElementsIn(insertedRecords);
+        assertThat(result).hasSize(records.size());
+        assertThat(result.size()).isEqualTo(records.size());
+        assertThat(result).containsExactlyElementsIn(records);
     }
 
     @Test(expected = IllegalArgumentException.class)